Değişken mesajlarla std :: istisnaları nasıl atılır?

Bu, bir istisnaya bazı bilgiler eklemek istediğimde sıklıkla yaptığım şeyin bir örneğidir:

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

Bunu yapmanın daha güzel bir yolu var mı?

İşte benim çözümüm:

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

Misal:

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

Standart istisnalar şunlardan oluşturulabilir 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);

Temel sınıf Not std::exceptionolabilir olup bu şekilde inşa edilmesi; somut, türetilmiş sınıflardan birini kullanmanız gerekir.

Gibi farklı istisnalar vardır runtime_error, range_error, overflow_error, logic_error, vb .. Bunu yapıcı içine dize geçmesi gerekiyor ve size mesajınıza istediğini arada kullanabilirsiniz. Bu sadece bir dizi işlemi.

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

Ayrıca şu şekilde kullanabilirsiniz boost::format:

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

Aşağıdaki sınıf oldukça kullanışlı olabilir:

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

Kullanım örneği:

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

C ++ 14 ( operator ""s) ise dize değişmez işleci kullanın

using namespace std::string_literals;

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

veya C ++ 11'de ise kendiniz tanımlayın. Örneğin

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

Atma ifadeniz daha sonra böyle görünecek

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

güzel ve temiz görünüyor.

Gerçekten daha hoş bir yol, istisnalar için bir sınıf (veya sınıflar) oluşturmaktır.

Gibi bir şey:

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

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

Bunun nedeni, istisnaların sadece bir dizeyi transfer etmekten çok daha fazla tercih edilmesidir. Hatalar için farklı sınıflar sağlayarak, geliştiricilere belirli bir hatayı karşılık gelen bir şekilde ele alma şansı verirsiniz (sadece bir hata mesajı göstermez). Bir hiyerarşi kullanıyorsanız, istisnanızı yakalayan kişiler ihtiyaç duydukları kadar spesifik olabilir.

a) Kişinin belirli nedeni bilmesi gerekebilir

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

a) başkası ayrıntıları bilmek istemiyor

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

Bu konuyla ilgili bazı ilhamları https://books.google.ru/books?id=6tjfmnKhT24C adresinde bulabilirsiniz. Bölüm 9'da bulabilirsiniz.

Ayrıca, çok özel bir mesaj sağlamak, ancak dikkatli olun - bir ileti oluşturmak için güvenli değil ya std::stringya std::stringstreamya da bir istisna neden olabilir başka bir yolu .

Genel olarak, istisnanın yapıcısına bellek ayırmanız (C ++ tarzında dizelerle çalışın) veya atmadan hemen önce fark yoktur - std::bad_allocistisna, gerçekten istediğiniz olandan önce atılabilir.

Bu nedenle, yığına ayrılan bir tampon (Maxim'in cevabında olduğu gibi) daha güvenli bir yoldur.

Http://www.boost.org/community/error_handling.html adresinde çok iyi açıklanmıştır.

Bu nedenle, daha güzel yol, özel bir istisna türü olabilir ve biçimlendirilmiş dizeyi oluşturmaktan kaçınmaktır (en azından atarken).

Benzer bir sorunla karşılaştım, çünkü benim özel istisnalarım için özel hata mesajları oluşturmanın çirkin kodlar oluşturması. Bu benim çözümümdü:

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

Bu, mesajları oluşturma mantığını ayırır. Başlangıçta neyi () geçersiz kılmayı düşünmüştüm, ama sonra mesajınızı bir yerde yakalamanız gerekiyor. std :: runtime_error zaten dahili bir arabelleğe sahip.

Belki bu?

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

Geçici bir ostringstream oluşturur, << işleçlerini gerektiği gibi çağırır ve sonra bunu yuvarlak parantez içine alırsınız ve kurucuya geçici bir std :: string iletmek için değerlendirilen sonuçta (bir ostringstream) .str () işlevini çağırırsınız. of runtime_error.

Not: ostringstream ve string, r-değeri geçicileridir ve bu nedenle bu satır bittikten sonra kapsam dışına çıkar. İstisna nesnenizin kurucusunun girdi dizesini kopyalama veya (daha iyi) taşıma semantiğini kullanarak alması ZORUNLUdur.

Ek: Bu yaklaşımı mutlaka "en iyi uygulama" olarak düşünmüyorum, ancak işe yarıyor ve bir çimdikle kullanılabilir. En büyük sorunlardan biri, bu yöntemin yığın ayırmaları gerektirmesi ve bu nedenle << operatörünün atabilmesidir. Muhtemelen bunun olmasını istemezsiniz; ancak, bu duruma girerseniz muhtemelen endişelenmeniz gereken daha çok sorun vardır!