Comment lancer des exceptions std :: avec des messages variables?

Voici un exemple de ce que je fais souvent lorsque je souhaite ajouter des informations à une exception:

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

Y a-t-il une meilleure façon de le faire?

Voici ma solution:

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

Exemple:

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

Les exceptions standard peuvent être construites à partir d'un 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);

Notez que la classe de base nestd::exception peut pas être construite ainsi; vous devez utiliser l'une des classes dérivées concrètes.

Il existe différentes exceptions comme runtime_error, range_error, overflow_error, logic_error, etc .. Vous devez passer la chaîne dans son constructeur, et vous pouvez concaténer tout ce que vous voulez à votre message. C'est juste une opération de chaîne.

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

Vous pouvez également utiliser boost::formatcomme ceci:

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

La classe suivante peut être très utile:

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

Exemple d'utilisation:

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

Utilisez l'opérateur littéral de chaîne si C ++ 14 ( operator ""s)

using namespace std::string_literals;

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

ou définissez le vôtre si en C ++ 11. Par exemple

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

Votre déclaration de lancer ressemblera alors à ceci

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

qui a l'air bien et propre.

Une manière vraiment plus agréable serait de créer une classe (ou des classes) pour les exceptions.

Quelque chose comme:

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

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

La raison en est que les exceptions sont bien plus préférables que le simple transfert d'une chaîne. En fournissant différentes classes pour les erreurs, vous donnez aux développeurs une chance de gérer une erreur particulière d'une manière correspondante (pas seulement d'afficher un message d'erreur). Les personnes qui interceptent votre exception peuvent être aussi spécifiques qu'elles en ont besoin si vous utilisez une hiérarchie.

a) On peut avoir besoin de connaître la raison spécifique

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

a) un autre ne veut pas connaître les détails

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

Vous pouvez trouver de l'inspiration sur ce sujet dans https://books.google.ru/books?id=6tjfmnKhT24C Chapitre 9

En outre, vous pouvez fournir un message personnalisé aussi, mais attention - il n'est pas sûr de composer un message soit avec std::stringou std::stringstreamou tout autre moyen qui peut provoquer une exception .

Généralement, il n'y a aucune différence que vous allouiez de la mémoire (travaillez avec des chaînes de manière C ++) dans le constructeur de l'exception ou juste avant de lancer - l' std::bad_allocexception peut être levée avant celle que vous voulez vraiment.

Ainsi, un tampon alloué sur la pile (comme dans la réponse de Maxim) est un moyen plus sûr.

Cela est très bien expliqué sur http://www.boost.org/community/error_handling.html

Ainsi, la meilleure façon serait un type spécifique d'exception et d'éviter de composer la chaîne formatée (au moins lors du lancement).

Ran dans un problème similaire, en ce que la création de messages d'erreur personnalisés pour mes exceptions personnalisées rend le code laid. C'était ma solution:

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

Cela sépare la logique de création des messages. J'avais initialement pensé à remplacer what (), mais vous devez ensuite capturer votre message quelque part. std :: runtime_error a déjà un tampon interne.

Peut être ça?

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

Il crée un ostringstream temporaire, appelle les opérateurs << si nécessaire, puis vous mettez cela entre crochets et appelez la fonction .str () sur le résultat évalué (qui est un ostringstream) pour passer un std :: string temporaire au constructeur de runtime_error.

Remarque: l'ostringstream et la chaîne sont des temporaires de valeur r et sortent donc de la portée après la fin de cette ligne. Le constructeur de votre objet d'exception DOIT prendre la chaîne d'entrée en utilisant la sémantique copy ou (meilleure) move.

Supplémentaire: je ne considère pas nécessairement cette approche comme une «meilleure pratique», mais elle fonctionne et peut être utilisée à la rigueur. L'un des plus gros problèmes est que cette méthode nécessite des allocations de tas et que l'opérateur << peut lancer. Vous ne voulez probablement pas que cela se produise; Cependant, si vous entrez dans cet état, vous aurez probablement beaucoup plus de problèmes à craindre!