Crear nueva excepción en C++

Question

tengo una clase de C++ y estoy tratando de ejecutarlo en Ubuntu:

#ifndef WRONGPARAMETEREXCEPTION_H_ 
#define WRONGPARAMETEREXCEPTION_H_ 

#include <iostream> 
#include <exception> 
#include <string> 

using namespace std; 

#pragma once 

class WrongParameterException: public exception 
{ 
    public: 
     WrongParameterException(char* message): exception(message) {}; 
     virtual ~WrongParameterException() throw() {}; 
}; 

#endif 

cuando intento compilar, el compilador me da este error:

WrongParameterException.h: In constructor ‘WrongParameterException::WrongParameterException(char*)’: 
WrongParameterException.h:14: error: no matching function for call to ‘std::exception::exception(char*&)’ 
/usr/include/c++/4.3/exception:59: note: candidates are: std::exception::exception() 
/usr/include/c++/4.3/exception:57: note: std::exception::exception(const std::exception&) 

¿Alguien puede decirme qué estoy haciendo mal? Traté de cambiar la variable del mensaje a string o const string o const string&, pero no sirvió de nada.

Aquí es cómo utilizar la nueva excepción de que he creado a partir principal:

std :: excepción no tiene un constructor que toma cualquier tipo de cadena, es sólo un método

try 
{ 
    if ((strToInt1 == -1) || (parameters[1] == NULL) || (strToInt3 == -1) || (parameters[3] != NULL)) 
    { 
      throw WrongParameterException("Error in the config or commands file"); 
    } 
} 
catch(WrongParameterException e) 
{ 
    log.addMsg(e.what()); 
} 

Answer 1

En primer lugar, #pragma once es la forma incorrecta de hacerlo, aprenda acerca de las protecciones incluidas en el encabezado. Related question on SO explica por qué usar #pragma once es la forma incorrecta de hacerlo. Wikipedia explica cómo usar include guards que sirven para el mismo propósito sin ninguno de los inconvenientes.

En segundo lugar, llama al constructor de std :: exception con un parámetro que desconoce, en este caso un puntero a una matriz de caracteres.

#include <stdexcept> 
#include <string> 

class WrongParameterException : public std::runtime_error { 
public: 
    WrongParameterException(const std::string& message) 
     : std::runtime_error(message) { }; 
}; 

Probablemente sea lo que quieras. Para obtener más información sobre excepciones, consulte C++ FAQ Lite article on Exceptions y exceptions article en cplusplus.com.

¡Buena suerte!

Answer 2

virtual de lo que() que devuelve la descripción de la excepción.

Tendrá que guardar la cadena usted mismo y devolverla desde allí.

Answer 3

std :: el constructor de excepción no toma un argumento de cadena. Está intentando darle uno, que es lo que causa el error de compilación.

Necesita almacenar su cadena, que sería mejor manejar como std :: cadena en lugar de un puntero sin formato, y devolverla desde el método what().

Answer 4

En cuanto a la declaración de la clase de excepción en la EM VS2K5, el constructor desea es:

exception (const char *const&); 

así que intenta cambiar su constructor para:

WrongParameterException (const char *const message) 

y ver si eso ayuda. De lo contrario, guarde el puntero en su propia clase e implemente todos los métodos relevantes.

Answer 5

Una solución simple es diseñar su excepción de manera diferente. Aquí hay un ejemplo simple:

class MyException : public Exception 
{ 
public: 
    MyException(CString strError) { m_strError = strError; } 

    CString m_strError; 
}; 

Luego puede simplemente usar su mensaje de excepción como lo desee. Esto se debe a que Exception no tiene un contructor que exceptúe un String, por lo que debe restringirlo por su cuenta.

Answer 6

Mi consejo sería:

1. Heredar del std::runtime_error. Según lo recomendado por X-Istence arriba. Conceptualmente es un error de tiempo de ejecución, y también el constructor std::runtime_error acepta un std::string como argumento que describe lo que sucedió.
2. Acerca de la captura de la excepción. Yo usaría catch(WrongParameterException const& e) (observe la referencia constante) en lugar de catch(WrongParameterException e), porque primero, la excepción es normalmente constante en su caso, y, también, usando la referencia, puede detectar cualquier subclase de WrongParameterException en caso de que su código evolucione con algunos más refinados manejo de excepciones.