J'ai une structure contenant des pointeurs: J'ai un vecteur de pointeurs partagés à ces structures: p> VEC code> est attribué sur la pile. Lorsqu'il passe hors de portée à la fin de la méthode, son destructeur sera appelé. (Droite?) Cela va à son tour appeler le destructeur de chaque élément du vecteur. (Droite?) Calling
Supprimer FOO CODE> Supprimer uniquement les pointeurs tels que
foo.f code> ou libérent-il réellement la mémoire du tas? P> p >
6 Réponses :
Il ne supprime que les pointeurs. P>
Vous n'appelez pas Puisque votre vecteur stocke les pointeurs intelligents, ils tomberont également hors de portée lorsque votre vecteur tombe hors de portée et que le destructeur Si les membres de Lorsqu'il passe hors de portée à la fin de la méthode, son destructeur sera appelé. (Droite?) P>
blockQuote>
Droite. P>
Cela appellera à son tour le destructeur de chaque élément du vecteur. (Droite?) P>
blockQuote>
droite. Le destructeur du pointeur intelligent. p>
ou fait-il effectivement libérer la mémoire du tas? p>
blockQuote>
Il appelle le destructeur du pointeur intelligent, s'il n'y a plus de références à ce pointeur, l'objet qu'il contient sera supprimé et sa mémoire sera libérée. P> supprimer f code> où f est un objet de type
foo code> si
f code> est une pile allouée. Vous n'appelez pas non plus
Supprimer F CODE> sur un objet de Type alloué de type
FOO code> Si cette adresse est stockée dans un pointeur partagé.
Shared_PTR CODE> Objets appellera
Supprimer code> pour vous lorsque la dernière référence est libérée. p>
FOO code> sera appelé et une mémoire associée libérée. La mémoire de
FOO code> n'est que la taille de 3 pointeurs cependant. Pas ce que ces pointeurs contiennent. P>
foo code> sont alloués, vous devrez alors
supprimer code> celles séparément. Par exemple, peut-être dans le FOO Destructor si la mémoire qu'ils indiquent ne sont pas partagées entre des objets. P>
delete foo; will delete the memory allocated to the foo structure, which includes the three pointers. But the memory pointed to by the pointers themselves will only be deleted if you implement a destructor that explicitly deletes them.
Ou alternativement, changez F, D et M pour utiliser des pointeurs auto ou partagés.
Il semble y avoir un mélange terminologique dans votre question. Destructeur du vecteur appellera des destructeurs pour appeler Destructeur de ce qui précède En fait, parce que partaged_ptr code>, ce qui permettra à son tour
Supprimer code> sur leurs pointeurs stockés (si nécessaire). P>
Supprimer foo code>, où
foo code> est un pointeur sur
struct foo code>, appellera le destructeur de
struct foo code > Ensuite, annouez la mémoire occupée par
* foo code>. p>
struct foo code> n'est absolument rien. C'est trivial. Si vous n'effectuez aucune tentative pour annouez la mémoire pointée par
struct foo :: f code> ou tout autre membre. Pourquoi serait-ce? Il ne peut pas savoir si cette mémoire devrait être traitée. P>
struct foo :: ~ FOO code> est trivial, les compilateurs ne tenteront normalement pas de l'appeler. P>
Si vous avez alloué de manière dynamique foo code>, par exemple:
foo* f = new foo;
appelle Supprimer FOO ... strong>
Correct
CORRECT, cela supprimera les éléments Shared_PTR dans le conteneur, et s'ils sont les derniers aussi les éléments dont ils partagent. P>
Vous ne pouvez pas supprimer foo, c'est une structure. Vous pouvez supprimer une instance de foo.
Appeler Supprimer appelle le destructeur et libère la mémoire de la FOO STRIT. P>
Cela dépend du destructo, dans ce cas, vous avez un destructeur par défaut et ...
Non, dans l'exemple de code suivant, vous pouvez voir certaines des raisons pour lesquelles le destructeur par défaut associé à FOO ne peut pas nettoyer automatiquement les éléments référencés du pointeur. P> {
char ca='a', *cb=new char;
int *i = (int*)malloc(sizeof(int));
foo a;
shared_ptr<foo> b = new foo();
a.f = &ca;
a.d = i;
b.f = cb;
}