Vérifier pointeur definedness en C++

Pourquoi s'inquiéter sur la vérification de la valeur des pointeurs? Juste l'initialiser à une valeur de pointeur null et puis il suffit d'appeler le supprimer. delete sur un pointeur null ne fait rien (le standard des garanties).

class MyClass {  
public:

    MyClass():pointer(0) { }

    ~MyClass() {
        delete pointer;
        pointer = 0;
    }

    initializePointer() {
        pointer = new OtherClass();
    }

private:

    OtherClass* pointer;

};

Et à chaque fois que vous appelez le supprimer, vous devez définir le pointeur null, la valeur du pointeur. Alors vous êtes tous très bien.

OriginalL'auteur Johannes Schaub - litb

En plus de vérifier la 0 (NULL), une solution serait de restructurer le code de sorte que vous force le pointeur d'être toujours valide. Ce n'est pas toujours possible, mais dans la plupart des cas, c'est la meilleure solution.

Dans votre cas (comme dans la plupart des autres cas), cela signifie que l'initialisation du pointeur dans le constructeur (c'est à dire dès que sa durée de vie commence) et de le détruire à la fin de sa durée de vie. Faire de la variable private et ne permettent pas directement l'accès en écriture pour s'assurer qu'elle restera toujours valide.

C'est souvent utilisée motif en C++ et efficacement les limites de la durée de vie des objets de la pointee à la durée de vie de votre classe. Parfois, il pourrait également être une solution viable pour assurer une sorte de reset qui supprime le pointeur et immédiatement ré-initialise. Si c'est écrit dans une exception, en toute sécurité, vous avez également veillé à ce que le pointeur de la souris ne sera jamais nulle.

Ne pas créer un boolean drapeau de garder une trace de votre pointeur de validité. Cette solution n'a aucun avantage, et de nombreux inconvénients, pour paramètre le pointeur de 0.

OriginalL'auteur Konrad Rudolph

Vous devriez toujours initialiser les pointeurs à NULL dans votre constructeur; de cette façon, vous pouvez vérifier dans le destructeur, si elle a été initialisé. Aussi, il est plus efficace de le faire dans le constructeur de la liste des arguments comme:

MyClass::MyClass() : pointer(NULL)
{
}

MyClass::~MyClass()
{
    if(pointer != NULL) { delete pointer; }
}

De même, vous devez également définir la valeur NULL lorsque vous la supprimer et d'en vérifier la valeur par rapport à null lors de l'attribution, si l'objet va être ré-initialisé à de nombreuses reprises au cours de la durée de vie de votre programme. Cependant, la définition de la valeur NULL dans le destructeur ne fera aucune différence, puisque l'objet est de toute évidence va être détruit de toute façon.

L'avantage de cette façon de faire (au lieu de dire "pointeur = NULL;" explicitement dans le constructeur), c'est que le compilateur est déjà implicitement faire une mission de ce genre pour vous. Faire une attribution manuelle fait arriver deux fois, ce qui normalement n'est pas une grosse affaire, sauf si vous effectuez un grand nombre d'instances de ta classe dans une grande boucle ou de quelque chose.

OriginalL'auteur Nik Reiman

Une réponse supplémentaire que personne d'autre n'a encore mentionné est d'utiliser un pointeur intelligent objet au lieu d'un pointeur brut. Selon la façon dont le pointeur est utilisé par la suite, std::auto_ptr, boost::shared_ptr, ou un certain nombre d'autres pointeur intelligent classes pourrait être approprié ici. boost::scoped_ptr peut également fonctionner si vous modifiez la façon dont initializePointer() travaille un peu.

De cette façon, le smart pointeur prend soin de se souvenir si elle est valide ou pas et supprimer lui-même lorsque l'objet est détruit:

class MyClass {  
public:

    MyClass();

    ~MyClass() {
    }

    initializePointer() {
        pointer.reset( new OtherClass());
    }

private:

    std::auto_ptr<OtherClass> pointer;

};

OriginalL'auteur Michael Burr