Como lançar std :: exceções com mensagens variáveis?

Este é um exemplo do que costumo fazer quando desejo adicionar algumas informações a uma exceção:

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

Existe uma maneira melhor de fazer isso?

Aqui está minha solução:

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

Exemplo:

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

As exceções padrão podem ser construídas a partir de 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);

Observe que a classe base nãostd::exception pode ser construída dessa forma; você tem que usar uma das classes derivadas concretas.

Existem diferentes exceções, como runtime_error, range_error, overflow_error, logic_error, etc .. Você precisa passar a corda em seu construtor, e você pode concatenar o que quiser à sua mensagem. Isso é apenas uma operação de string.

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

Você também pode usar boost::formatdesta forma:

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

A seguinte classe pode ser muito útil:

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

Exemplo de uso:

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

Use o operador literal de string se C ++ 14 ( operator ""s)

using namespace std::string_literals;

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

ou defina seu próprio se estiver em C ++ 11. Por exemplo

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

Sua declaração de lançamento ficará assim

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

que parece bom e limpo.

Uma maneira realmente melhor seria criar uma classe (ou classes) para as exceções.

Algo como:

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

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

O motivo é que as exceções são muito mais preferíveis do que apenas transferir uma string. Fornecendo classes diferentes para os erros, você dá aos desenvolvedores a chance de lidar com um erro específico de uma forma correspondente (não apenas exibir uma mensagem de erro). As pessoas que detectam sua exceção podem ser tão específicas quanto precisam se você usar uma hierarquia.

a) Pode ser necessário saber o motivo específico

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

a) outro não quer saber detalhes

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

Você pode encontrar inspiração neste tópico no https://books.google.ru/books?id=6tjfmnKhT24C Capítulo 9

Além disso, você pode fornecer uma mensagem personalizada também, mas tenha cuidado - não é seguro para compor uma mensagem com qualquer um std::stringou std::stringstreamou qualquer outra forma que pode causar uma exceção .

Geralmente, não há diferença se você aloca memória (trabalha com strings no modo C ++) no construtor da exceção ou imediatamente antes de lançar - a std::bad_allocexceção pode ser lançada antes daquela que você realmente deseja.

Portanto, um buffer alocado na pilha (como na resposta de Maxim) é uma maneira mais segura.

É muito bem explicado em http://www.boost.org/community/error_handling.html

Então, a maneira mais legal seria um tipo específico de exceção e evitar a composição da string formatada (pelo menos ao lançar).

Tive um problema semelhante, pois a criação de mensagens de erro personalizadas para minhas exceções personalizadas tornava o código feio. Esta foi a minha solução:

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

Isso separa a lógica para criar as mensagens. Eu tinha pensado originalmente em substituir what (), mas então você tem que capturar sua mensagem em algum lugar. std :: runtime_error já tem um buffer interno.

Talvez isto?

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

Ele cria um ostringstream temporário, chama os operadores << conforme necessário e então você envolve isso entre colchetes e chama a função .str () no resultado avaliado (que é um ostringstream) para passar uma std :: string temporária para o construtor de runtime_error.

Observação: o ostringstream e a string são temporários com valor r e, portanto, saem do escopo após o término desta linha. O construtor do seu objeto de exceção DEVE receber a string de entrada usando cópia ou (melhor) semântica de movimentação.

Adicional: não considero necessariamente essa abordagem como "prática recomendada", mas ela funciona e pode ser usada em uma pitada. Um dos maiores problemas é que esse método requer alocações de heap e, portanto, o operador << pode lançar. Você provavelmente não quer que isso aconteça; no entanto, se você entrar nesse estado, provavelmente terá muito mais problemas com que se preocupar!