จะโยนข้อยกเว้น std :: ด้วยข้อความตัวแปรได้อย่างไร

นี่คือตัวอย่างของสิ่งที่ฉันมักจะทำเมื่อต้องการเพิ่มข้อมูลบางอย่างในข้อยกเว้น:

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

หรือกำหนดของคุณเองถ้าอยู่ใน C ++ 11 ตัวอย่างเช่น

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

จากนั้นคำสั่งโยนของคุณจะมีลักษณะเช่นนี้

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ข้อยกเว้นสามารถโยนก่อนที่คุณต้องการจริงๆ

ดังนั้นบัฟเฟอร์ที่จัดสรรบนสแต็ก (เช่นในคำตอบของ Maxim) จึงเป็นวิธีที่ปลอดภัยกว่า

มีการอธิบายไว้เป็นอย่างดีที่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
     }
}

สิ่งนี้จะแยกตรรกะในการสร้างข้อความ เดิมทีฉันเคยคิดที่จะลบล้างสิ่งที่ () แต่คุณต้องจับข้อความของคุณที่ไหนสักแห่ง std :: runtime_error มีบัฟเฟอร์ภายในอยู่แล้ว

อาจจะเป็นแบบนี้?

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

สร้าง ostringstream ชั่วคราวเรียกตัวดำเนินการ << ตามความจำเป็นจากนั้นคุณห่อสิ่งนั้นในวงเล็บกลมและเรียกใช้ฟังก์ชัน. str () บนผลลัพธ์ที่ประเมิน (ซึ่งเป็น ostringstream) เพื่อส่งสตริง std :: ชั่วคราวไปยังตัวสร้าง ของ runtime_error

หมายเหตุ: ostringstream และสตริงเป็นค่า r-value tempo ไลบรารีดังนั้นจึงควรออกนอกขอบเขตหลังจากสิ้นสุดบรรทัดนี้ ตัวสร้างออบเจ็กต์ข้อยกเว้นของคุณต้องใช้สตริงอินพุตโดยใช้สำเนาหรือ (ดีกว่า) ย้ายความหมาย

เพิ่มเติม: ฉันไม่จำเป็นต้องคิดว่าแนวทางนี้เป็น "แนวทางปฏิบัติที่ดีที่สุด" แต่ก็ใช้ได้ผลและสามารถใช้ได้ในระยะสั้น ๆ ปัญหาที่ใหญ่ที่สุดอย่างหนึ่งคือวิธีนี้ต้องมีการจัดสรรฮีปดังนั้นตัวดำเนินการ << จึงสามารถโยนได้ คุณอาจไม่ต้องการให้เกิดขึ้น อย่างไรก็ตามหากคุณเข้าสู่สถานะนั้นคุณอาจมีปัญหาที่ต้องกังวลมากขึ้น!