c++ - tiene - tipo de relaciones entre clases uml

Forma correcta de heredar de std:: exception

Question

Acabo de crear la 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 me permita 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 texto a la clase derivada de una std::exception para pasar información con mi clase de excepción, por lo que puedo decir en algún lugar del código:

throw My_Exception("Something bad happened.");

Answer 1

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

Answer 2

Qué tal esto:

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

O crea un constructor que acepte la descripción si te gusta ...

Answer 3

Si desea utilizar el 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.

Entonces 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 4

Si su objetivo es crear una excepción para que no arroje una excepción genérica ( cpp:S112 ), es posible que desee exponer la excepción de la que hereda ( C++11 ) con una declaración de uso.

Aquí hay un ejemplo mínimo para eso:

#include <exception>
#include <iostream>

struct myException : std::exception
{
    using std::exception::exception;
};

int main(int, char*[])
{
    try
    {
        throw myException{ "Something Happened" };
    }
    catch (myException &e)
    {
        std::cout << e.what() << std::endl;
    }
    return{ 0 };
}

Answer 5

Utilizo la siguiente clase para mis excepciones y funciona 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_;
};