Les Exceptions C++ avec le message

Je ne suis pas sûr que mon exception personnalisée approche est correcte. Ce que je veux faire est de lancer des exceptions avec des messages personnalisés, mais il semble que j'ai créé une fuite de mémoire...

class LoadException: public std::exception {
private:
    const char* message;
public:
    LoadException(const std::string message);
    virtual const char* what() const throw();
};


LoadException::LoadException(const std::string message) {
    char* characters = new char[message.size() + 1];
    std::copy(message.begin(), message.end(), characters);
    characters[message.size()] = '
class LoadException: public std::exception {
private:
const char* message;
public:
LoadException(const std::string message);
virtual const char* what() const throw();
};
LoadException::LoadException(const std::string message) {
char* characters = new char[message.size() + 1];
std::copy(message.begin(), message.end(), characters);
characters[message.size()] = '\0';
this->message = characters;
}
';
    this->message = characters;
}

Je l'utilise comme suit:

void array_type_guard(Local<Value> obj, const std::string path) {
    if (!obj->IsArray()) {
        throw LoadException(path + " is not an array");
    }
}

try {
    objects = load_objects();
} catch (std::exception& e) {
    ThrowException(Exception::TypeError(String::New(e.what())));
    return scope.Close(Undefined());
}

J'ai peur que le tableau créé dans le constructeur n'est jamais supprimé. Mais je ne suis pas sûr de la façon de le supprimer - dois-je ajouter destructeur ou peut-être utiliser l'approche complètement différente?

Mise à jour:

En fait, j'ai essayé d'utiliser la classe string comme suit:

class LoadException: public std::exception {
private:
    const char* msg;
public:
    LoadException(const std::string message);
    virtual const char* what() const throw();
};

LoadException::LoadException(const std::string message) {
    msg = message.c_str();
}

const char* LoadException::what() const throw() {
    return msg;
}

Mais ne peut pas obtenir le message d'erreur puis - hasard de sortie est affiché lorsque j'imprime le "what()".

utilisez simplement string pour stocker le message. Ou est-il une raison pour le char *?
Non, il n'y a aucune raison pour char*. J'ai changé le code pour la chaîne. Merci.
Ou tout simplement wite un destructeur deletes l'allocation d'un tableau de caractères.
connexes stackoverflow.com/questions/2715386/...

OriginalL'auteur Alex Netkachov | 2013-07-03

  1. 13

    Vous pouvez prendre avantage de std:string

    class LoadException: public std::exception {
private:
    std::string message_;
public:
    explicit LoadException(const std::string& message);
    virtual const char* what() const throw() {
        return message_.c_str();
    }
};


LoadException::LoadException(const std::string& message) : message_(message) {

}

    Puis le C++ portée prendra soin de nettoyer les choses pour vous

    Serait mieux de passer par des non-const valeur et passer de construire message_
    Merci. Il fonctionne de cette façon, mais je ne sais pas pourquoi... Il ressemble à la copie de la chaîne de l'objet de l'exception. Suis-je le droit?
    Cela fonctionne parce que string alloue et libère de la mémoire tampon sur son propre. C'est exactement le même que vous avez fait, mais en outre, il deletes de la mémoire allouée dans son destructeur.
    Lorsque l'exception est hors de portée, les membres de l'exception, ont leurs destructeur appelé. La classe string prend soin de la gestion de son propre tampon, de sorte qu'il nettoie après lui-même lorsque son destructeur est appelé, et cela se produit quand le LoadException est hors de portée.
    En fait vous devez également spécifier un remplacement LoadException::~LoadException() throw() {}, sinon vous avez un looser jeter spécificateur d'erreur.

    OriginalL'auteur NG.

  2. 18

    Comment

    throw std::runtime_error("My very own message");

    OriginalL'auteur MonoThreaded

  3. 1

    Dans le constructeur, j'ai

    Printer::Printer(boost::asio::io_service& io, unsigned int interval) {
    if (interval < 1) {
        throw std::runtime_error("Interval can't be less than one second");
    }
}

    Et lors de la création de l'objet

    try {
    Printer p{io, 0};
} catch (std::exception& e) {
    std::cerr << e.what() << std::endl;
}

    le programme se terminera avec le message levée.

    OriginalL'auteur kometen