可変メッセージでstd :: exceptionsをスローする方法は？

これは、例外に情報を追加したいときによく行うことの例です。

std::stringstream errMsg;
errMsg << "Could not load config file '" << configfile << "'";
throw std::exception(errMsg.str().c_str());

それを行うより良い方法はありますか？

これが私の解決策です：

#include <stdexcept>
#include <sstream>

class Formatter
{
public:
    Formatter() {}
    ~Formatter() {}

    template <typename Type>
    Formatter & operator << (const Type & value)
    {
        stream_ << value;
        return *this;
    }

    std::string str() const         { return stream_.str(); }
    operator std::string () const   { return stream_.str(); }

    enum ConvertToString 
    {
        to_str
    };
    std::string operator >> (ConvertToString) { return stream_.str(); }

private:
    std::stringstream stream_;

    Formatter(const Formatter &);
    Formatter & operator = (Formatter &);
};

例：

throw std::runtime_error(Formatter() << foo << 13 << ", bar" << myData);   // implicitly cast to std::string
throw std::runtime_error(Formatter() << foo << 13 << ", bar" << myData >> Formatter::to_str);    // explicitly cast to std::string

標準の例外は、std::string以下から構築できます。

#include <stdexcept>

char const * configfile = "hardcode.cfg";
std::string const anotherfile = get_file();

throw std::runtime_error(std::string("Failed: ") + configfile);
throw std::runtime_error("Error: " + anotherfile);

基本クラスstd::exceptionはこのように構築できないことに注意してください。具体的な派生クラスの1つを使用する必要があります。

など、さまざまな例外がありますがruntime_error、range_error、overflow_error、 logic_error、など。あなたは、コンストラクタに文字列を渡す必要があり、そしてあなたがあなたのメッセージにしたいものは何でも連結できます。これは単なる文字列操作です。

std::string errorMessage = std::string("Error: on file ")+fileName;
throw std::runtime_error(errorMessage);

次のboost::formatように使用することもできます：

throw std::runtime_error(boost::format("Error processing file %1") % fileName);

次のクラスは非常に便利です。

struct Error : std::exception
{
    char text[1000];

    Error(char const* fmt, ...) __attribute__((format(printf,2,3))) {
        va_list ap;
        va_start(ap, fmt);
        vsnprintf(text, sizeof text, fmt, ap);
        va_end(ap);
    }

    char const* what() const throw() { return text; }
};

使用例：

throw Error("Could not load config file '%s'", configfile.c_str());

C ++ 14（operator ""s）の場合、文字列リテラル演算子を使用します

using namespace std::string_literals;

throw std::exception("Could not load config file '"s + configfile + "'"s);

または、C ++ 11の場合は独自に定義します。例えば

std::string operator ""_s(const char * str, std::size_t len) {
    return std::string(str, str + len);
}

あなたのthrowステートメントはこのようになります

throw std::exception("Could not load config file '"_s + configfile + "'"_s);

きれいに見えます。

本当に良い方法は、例外のクラスを作成することです。

何かのようなもの：

class ConfigurationError : public std::exception {
public:
    ConfigurationError();
};

class ConfigurationLoadError : public ConfigurationError {
public:
    ConfigurationLoadError(std::string & filename);
};

その理由は、単に文字列を転送するよりも例外の方がはるかに望ましいからです。エラーにさまざまなクラスを提供することで、開発者は特定のエラーを対応する方法で処理することができます（エラーメッセージを表示するだけではありません）。階層を使用する場合、例外をキャッチする人々は必要に応じて具体的にすることができます。

a）特定の理由を知る必要があるかもしれない

} catch (const ConfigurationLoadError & ex) {
// ...
} catch (const ConfigurationError & ex) {

a）他の人が詳細を知りたくない

} catch (const std::exception & ex) {

このトピックについてのインスピレーションは、https：//books.google.ru/books？id = 6tjfmnKhT24Cの第9章にあります。

また、あなたもカスタムメッセージを提供していますが、注意することができます- どちらかとメッセージを作成することは安全ではないstd::stringか、std::stringstreamまたは例外を引き起こす可能性が他の方法。

一般に、例外のコンストラクターでメモリを割り当てる（C ++の方法で文字列を処理する）かstd::bad_alloc、スローする直前に違いはありません。例外は、本当に必要なものの前にスローできます。

したがって、スタックに割り当てられたバッファ（マキシムの答えのように）はより安全な方法です。

http://www.boost.org/community/error_handling.htmlで非常によく説明されています

したがって、より良い方法は、特定のタイプの例外であり、フォーマットされた文字列の作成を避けます（少なくともスローする場合）。

同様の問題に遭遇しました。私のカスタム例外のカスタムエラーメッセージを作成すると、コードが醜くなります。これは私の解決策でした：

class MyRunTimeException: public std::runtime_error
{
public:
      MyRunTimeException(const std::string &filename):std::runtime_error(GetMessage(filename)) {}
private:
      static std::string GetMessage(const std::string &filename)
     {
           // Do your message formatting here. 
           // The benefit of returning std::string, is that the compiler will make sure the buffer is good for the length of the constructor call
           // You can use a local std::ostringstream here, and return os.str()
           // Without worrying that the memory is out of scope. It'll get copied
           // You also can create multiple GetMessage functions that take all sorts of objects and add multiple constructors for your exception
     }
}

これにより、メッセージを作成するためのロジックが分離されます。私はもともとwhat（）をオーバーライドすることを考えていましたが、どこかでメッセージをキャプチャする必要があります。std :: runtime_errorにはすでに内部バッファがあります。

多分これ？

throw std::runtime_error(
    (std::ostringstream()
        << "Could not load config file '"
        << configfile
        << "'"
    ).str()
);

一時的なostringstreamを作成し、必要に応じて<<演算子を呼び出してから、角括弧で囲み、評価結果（ostringstream）で.str（）関数を呼び出して、一時的なstd :: stringをコンストラクターに渡します。 runtime_errorの。

注：ostringstreamとstringはr値の一時的なものであるため、この行が終了するとスコープ外になります。例外オブジェクトのコンストラクターは、コピーまたは（より良い）移動セマンティクスを使用して入力文字列を取得する必要があります。

追加：私はこのアプローチを「ベストプラクティス」とは必ずしも考えていませんが、機能し、ピンチで使用できます。最大の問題の1つは、このメソッドにはヒープの割り当てが必要なため、演算子<<がスローできることです。あなたはおそらくそのようなことを望まないでしょう。ただし、その状態になると、おそらくさらに多くの問題が発生します。