dois-je supprimer smart pointeur manuellement?

Cela peut être une question stupide mais je ne suis pas sûr de la réponse. Le code suivant lire un fichier, et pour chaque ligne du fichier, un pointeur intelligent est créé par "nouveau". Si le pointeur intelligent sera utilisé dans l'avenir, il est stocké dans une liste, sinon il n'est pas stocké.

Ma question est que: si le pointeur intelligent n'est pas stocké, que cela va provoquer risque de fuite de mémoire? Merci.

int main(){
    .....;
    std::list<SomeClass> aList;
    while(inFile >> ss){
         std::tr1::shared_ptr<SomeClass> aPtr(new SomeClass());
         //do something in foo(aPtr) to aPtr, 
         //if aPtr will be used later, then it's stored in aList
         //otherwise, it's not stored
         foo(aPtr);
    }
    .....;
}
Le terme de "supprimer" est malheureux, en tout cas. Pour les pointeurs intelligents, l'opération est appelée reset. I. e. dans ce cas, vous pourriez écrire aPtr.reset();. Mais vous aurez rarement besoin de cela, généralement vous l'utilisez lorsque le pointeur intelligent doit faire référence à un autre objet: aPtr.reset(new SomeClass("Another Object"));

OriginalL'auteur EXP0 | 2011-07-13

  1. 6

    Aussi longtemps que vous êtes à la stocker une copie du pointeur intelligent, ce ne sera pas une fuite de mémoire. Lorsque le aPtr objet tombe de la pile (à la fin de chacun, alors que l'exécution de la boucle), il sera détruit. Si c'est le seul titulaire de l'allocation d'un objet, il va le supprimer. Mais si vous avez conservé une copie de aPtr ailleurs, il n'est pas le seul détenteur de l'objet alloué, et il ne sera pas le supprimer.

    OriginalL'auteur Nicol Bolas

  2. 3

    Pas de fuites de mémoire doit s'ensuivre!

    pourquoi? parce que les pointeurs intelligents sont... intelligents, ils ont le automatique de la fonction de nettoyage qui est excellent, car il empêche l'insaisissable bugs comme des fuites de mémoire.

    Donc pour les pointeurs intelligents, vous ne devez pas explicitement supprimer le pointeur.

    OriginalL'auteur rrazd

  3. 0

    Pas de fuite de mémoire peut être causé, parce que le shared_ptr va libérer l'allocation d'un objet lorsqu'il est hors de portée.

    OriginalL'auteur BЈовић

  4. 0

    Lorsqu'un pointeur est affecté à un pointeur intelligent, un compteur de références liées à l'pointeur est augmenté de un (le compteur de référence est de 0 lorsque le pointeur n'a pas été affecté à un pointeur intelligent).
    Lorsqu'un pointeur intelligent est hors de portée et est supprimé, le compteur de référence pour le pointeur suivis par le sp est décrémenté de un: finalement, la mémoire référencée par le pointeur est supprimé lorsque le compteur de référence revient à 0.

    Dans votre cas, si l'objet SomeClass est attribué qu'à un seul aPtr, alors peut-être un pointeur automatique sera de faire le travail avec un peu moins de frais généraux.
    Toutefois, si vous déclarez la liste std::list<std::tr1::shared_ptr<SomeClass> > alors vous pourriez éviter de copier SomeClass (seul le compteur de référence de l'objet va être augmenté) et de profiter pleinement de pointeur intelligent.

    OriginalL'auteur Paolo Brandoli