Forma correcta de heredar de std :: exception

Question

Acabo de crear una jerarquía de excepciones y quería pasar char* al constructor de una de mis clases derivadas con un mensaje que decía lo que estaba mal, pero aparentemente std::exception no tiene constructor que permitiera yo para hacerlo Sin embargo, hay un miembro de la clase llamado what() que sugeriría que se puede pasar cierta información.
¿Cómo puedo (puedo?) Pasar de texto a clase derivada de un std::exception el fin de pasar información con mi clase de excepción, por lo que puedo decir en alguna parte del código:

throw My_Exception("Something bad happened."); 

Answer 1

Si desea hacer uso del constructor de cadenas, debe heredar de std::runtime_error o std::logic_error, que implementa un constructor de cadenas e implementa el método std :: exception :: what.

Luego, es solo una cuestión de llamar al constructor runtime_error/logic_error de su nueva clase heredada, o si está usando C++ 11 puede usar la herencia del constructor.

Answer 2

El método what es virtual, y el significado es que debe sobrescribirlo para devolver el mensaje que desea devolver.

Answer 3

¿Qué tal esto:

class My_Exception : public std::exception 
{ 
public: 
virtual char const * what() const { return "Something bad happend."; } 
}; 

O bien, crear un constructor de aceptar la descripción si lo desea ...

Answer 4

utilizo la siguiente clase para mis excepciones y trabaja muy bien:

class Exception: public std::exception 
{ 
public: 
    /** Constructor (C strings). 
    * @param message C-style string error message. 
    *     The string contents are copied upon construction. 
    *     Hence, responsibility for deleting the char* lies 
    *     with the caller. 
    */ 
    explicit Exception(const char* message): 
     msg_(message) 
     { 
     } 

    /** Constructor (C++ STL strings). 
    * @param message The error message. 
    */ 
    explicit Exception(const std::string& message): 
     msg_(message) 
     {} 

    /** Destructor. 
    * Virtual to allow for subclassing. 
    */ 
    virtual ~Exception() throw(){} 

    /** Returns a pointer to the (constant) error description. 
    * @return A pointer to a const char*. The underlying memory 
    *   is in posession of the Exception object. Callers must 
    *   not attempt to free the memory. 
    */ 
    virtual const char* what() const throw(){ 
     return msg_.c_str(); 
    } 

protected: 
    /** Error message. 
    */ 
    std::string msg_; 
};