Как выбросить 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 может быть построен таким образом; вы должны использовать один из конкретных производных классов.

Существуют различные исключения , такие как 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);

или определите свой собственный, если в С ++ 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);
};

Причина в том, что исключения намного предпочтительнее, чем просто передача строки. Предоставляя различные классы для ошибок, вы даете разработчикам возможность обработать конкретную ошибку соответствующим образом (а не просто отображать сообщение об ошибке). Люди, перехватывающие ваше исключение, могут быть сколь угодно конкретными, если вы используете иерархию.

а) Возможно, потребуется знать конкретную причину

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

а) другой не хочет знать подробностей

} 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, вызывает операторы << по мере необходимости, а затем вы заключаете его в круглые скобки и вызываете функцию .str () для оцененного результата (который является потоком ostring) для передачи временного std :: string конструктору из runtime_error.

Примечание: поток ostringstream и строка являются временными значениями r и поэтому выходят из области видимости после окончания этой строки. Конструктор вашего объекта исключения ДОЛЖЕН принимать входную строку, используя семантику копирования или (лучше) перемещения.

Дополнительно: я не обязательно считаю этот подход «лучшей практикой», но он действительно работает и может быть использован в крайнем случае. Одна из самых больших проблем заключается в том, что этот метод требует выделения кучи, поэтому оператор << может бросать. Вероятно, вы этого не хотите; однако, если вы попадете в это состояние, у вас, вероятно, будет больше проблем, о которых стоит беспокоиться!