Wie werden std :: Ausnahmen mit variablen Nachrichten ausgelöst?

Dies ist ein Beispiel dafür, was ich häufig mache, wenn ich einer Ausnahme einige Informationen hinzufügen möchte:

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

Gibt es einen schöneren Weg, es zu tun?

Hier ist meine Lösung:

#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 &);
};

Beispiel:

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

Die Standardausnahmen können konstruiert werden aus 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);

Beachten Sie, dass die Basisklasse std::exceptionkann nicht so konstruiert werden; Sie müssen eine der konkreten, abgeleiteten Klassen verwenden.

Es gibt verschiedene Ausnahmen wie runtime_error, range_error, overflow_error, logic_error, etc .. Sie müssen die Zeichenfolge in den Konstruktor zu übergeben, und Sie können verketten , was Sie zu Ihrer Nachricht. Das ist nur eine String-Operation.

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

Sie können auch boost::formatwie folgt verwenden:

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

Die folgende Klasse könnte sehr praktisch sein:

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; }
};

Anwendungsbeispiel:

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

Verwenden Sie den String-Literal-Operator, wenn C ++ 14 ( operator ""s)

using namespace std::string_literals;

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

oder definieren Sie Ihre eigenen, wenn in C ++ 11. Zum Beispiel

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

Ihre Wurfanweisung sieht dann so aus

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

das sieht schön und sauber aus.

Ein wirklich schöner Weg wäre, eine Klasse (oder Klassen) für die Ausnahmen zu erstellen.

Etwas wie:

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

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

Der Grund dafür ist, dass Ausnahmen viel besser sind als nur das Übertragen einer Zeichenfolge. Indem Sie verschiedene Klassen für die Fehler bereitstellen, geben Sie Entwicklern die Möglichkeit, einen bestimmten Fehler entsprechend zu behandeln (und nicht nur eine Fehlermeldung anzuzeigen). Personen, die Ihre Ausnahme abfangen, können so spezifisch sein, wie sie es benötigen, wenn Sie eine Hierarchie verwenden.

a) Möglicherweise muss der genaue Grund bekannt sein

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

a) Ein anderer möchte keine Details wissen

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

Inspirationen zu diesem Thema finden Sie unter https://books.google.ru/books?id=6tjfmnKhT24C Kapitel 9

Darüber hinaus können Sie auch eine benutzerdefinierte Nachricht liefern, aber seien Sie vorsichtig - es ist nicht sicher ist , eine Nachricht mit entweder zu komponieren std::stringoder std::stringstreamoder irgendeine andere Art und Weise , die eine Ausnahme verursachen kann .

Im Allgemeinen gibt es keinen Unterschied, ob Sie im Konstruktor der Ausnahme oder kurz vor dem Auslösen Speicher zuweisen (mit Zeichenfolgen in C ++ arbeiten). std::bad_alloc Ausnahme kann vor dem ausgelöst werden, den Sie wirklich möchten.

Ein auf dem Stapel zugewiesener Puffer (wie in Maxim's Antwort) ist also sicherer.

Es wird sehr gut unter http://www.boost.org/community/error_handling.html erklärt

Der schönere Weg wäre also ein bestimmter Typ der Ausnahme und das Vermeiden des Komponierens der formatierten Zeichenfolge (zumindest beim Werfen).

Stieß auf ein ähnliches Problem: Das Erstellen von benutzerdefinierten Fehlermeldungen für meine benutzerdefinierten Ausnahmen führt zu hässlichem Code. Das war meine Lösung:

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
     }
}

Dies trennt die Logik zum Erstellen der Nachrichten. Ich hatte ursprünglich darüber nachgedacht, what () zu überschreiben, aber dann müssen Sie Ihre Nachricht irgendwo erfassen. std :: runtime_error hat bereits einen internen Puffer.

Vielleicht das?

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

Es erstellt einen temporären ostringstream, ruft die Operatoren << nach Bedarf auf und umschließt diesen in runde Klammern und ruft die Funktion .str () für das ausgewertete Ergebnis (das ein ostringstream ist) auf, um einen temporären std :: string an den Konstruktor zu übergeben von runtime_error.

Hinweis: Der ostringstream und der String sind temporäre R-Werte und verlassen daher den Gültigkeitsbereich, nachdem diese Zeile endet. Der Konstruktor Ihres Ausnahmeobjekts MUSS die Eingabezeichenfolge entweder mit Kopier- oder (besser) Verschiebungssemantik verwenden.

Zusätzlich: Ich betrachte diesen Ansatz nicht unbedingt als "Best Practice", aber er funktioniert und kann zur Not verwendet werden. Eines der größten Probleme ist, dass diese Methode Heap-Zuweisungen erfordert und der Operator << werfen kann. Sie wollen wahrscheinlich nicht, dass das passiert; Wenn Sie jedoch in diesen Zustand geraten, müssen Sie sich wahrscheinlich mehr Sorgen machen!