Modo corretto per ereditare da std :: exception

Question

Ho appena creato la gerarchia delle eccezioni e volevo passare char* al costruttore di una delle mie classi derivate con un messaggio che diceva cosa non va, ma apparentemente std::exception non ha il costruttore che consentirebbe io per farlo. Eppure c'è un membro della classe chiamato what() che suggerirebbe che alcune informazioni possano essere passate.
Come posso (posso?) Passare il testo alla classe derivata di un std::exception per passare informazioni con la mia classe di eccezione, quindi posso dire che da qualche parte nel codice:

throw My_Exception("Something bad happened."); 

Answer 1

Se si desidera utilizzare del costruttore di stringhe, si dovrebbe ereditare da std::runtime_error o std::logic_error che implementa un costruttore di stringhe e implementa il metodo std :: exception :: what.

Quindi è solo un caso di chiamare il costruttore runtime_error/logic_error dalla nuova classe ereditata, oppure se si utilizza C++ 11 è possibile utilizzare l'ereditarietà del costruttore.

Answer 2

Il metodo what è virtuale e il significato è che è necessario sovrascriverlo per restituire qualsiasi messaggio che si desidera restituire.

Answer 3

ne dite di questo:

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

Oppure, creare un costruttore di accettare la descrizione se vuoi ...

Answer 4

Io uso la seguente classe per le mie eccezioni e funziona benissimo:

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