È possibile eliminare un oggetto in C++ senza chiamare il distruttore?

Question

Ho un oggetto con alcuni puntatori al suo interno. Il distruttore chiama delete su questi puntatori. Ma a volte voglio eliminarli, ea volte no. Quindi mi piacerebbe poter eliminare l'oggetto senza chiamando il distruttore. È possibile?

Modifica: Mi rendo conto che questa è una idea VEDUTA che nessuno dovrebbe mai fare. Tuttavia, voglio farlo perché renderà alcune funzioni interne molto più facili da scrivere.

Answer 1

È possibile impostare i puntatori su NULL, quindi il distruttore non li eliminerà.

struct WithPointers 
{ 
    int* ptr1; 
    int* ptr2; 

    WithPointers(): ptr1(NULL), ptr2(NULL) {} 

    ~WithPointers() 
    { 
     delete ptr1; 
     delete ptr2; 
    } 
} 

... 
WithPointers* object1 = new WithPointers; 
WithPointers* object2 = new WithPointers; 
object1->ptr1 = new int(11); 
object1->ptr2 = new int(12); 
object2->ptr1 = new int(999); 
object2->ptr2 = new int(22); 
... 
int* pointer_to_999 = object2->ptr1; 
object2->ptr1 = NULL; 
delete object1; 
delete object2; // the number 999 is not deleted now! 
// Work with the number 999 
delete pointer_to_999; // please remember to delete it at the end! 

Answer 2

Eww! Sì, è possibile, no non lo farei. È necessario controllare gli oggetti che richiedono una durata variabile tramite un puntatore condiviso o un altro oggetto con conteggio di riferimento. Cleaner funziona con C++ piuttosto che rompere alcuni dei suoi inquilini interni ...

Answer 3

Qualsiasi cosa tu stia effettivamente cercando di fare, c'è un problema con il tuo codice. Se non si desidera eliminare gli oggetti secondari, utilizzare solo un flag booleano che verrà impostato prima di eliminare l'oggetto e che verrà considerato dal distruttore.

Ma sinceramente, dovresti usare puntatori intelligenti invece di puntatori nudi (e nel tuo caso, sembra che i puntatori condivisi siano ciò di cui hai bisogno).

Answer 4

Come altri hanno suggerito, il modo corretto per risolvere questo problema non è NON chiamare il distruttore [è sufficiente aggiungere qualcosa come std::string o std::vector al proprio oggetto e all'improvviso si ha una perdita di memoria] . Il modo corretto è quello di non lasciare che il proprio oggetto possieda tutti gli altri oggetti (ad esempio cancellarli separatamente prima/dopo che l'oggetto sia stato eliminato), o avere un metodo con cui l'oggetto sa se eliminare i puntatori o meno.

Answer 5

Scrivere un metodo che è possibile chiamare prima di chiamare il distruttore. Il metodo capovolgerà un membro booleano. Quando viene chiamato il destuctor, controllerà quel membro booleano e distruggerà il puntatore se è vero, e lo manterrà se è falso.

Non consiglierei di farlo. Meglio che la classe non si assuma la responsabilità dell'eliminazione del puntatore.

Answer 6

Sì, questo è possibile. std::vector fa questo, in quanto assegna i buffer con lo spazio per gli oggetti, quindi li costruisce condizionalmente (sul posto) e li distrugge, gestendo la memoria indipendentemente dalla durata dell'oggetto.

In C++ 11, utilizzerei un union del tipo e un tipo piccolo con costruttori/distruttori banali per indicare un percorso di memoria che può adattarsi al tipo, ma non deve avere quel tipo in esso . Esterno a quello che devi tracciare se l'oggetto è effettivamente lì. La creazione dell'articolo consiste nell'utilizzare il posizionamento new e distruggerlo consiste nel chiamare manualmente il distruttore.

Il buffer degli oggetti union, sia N oggetti o 1, sarebbe gestito in modo completamente indipendente. Il costruttore predefinito di union non costruisce nulla, o costruisce il tipo banale (nel qual caso potresti voler distruggere quel tipo banale).

Tuttavia, le probabilità sono che la vera risposta alla tua domanda è "non farlo". E se lo fai, avvolgi i puntatori in un class il cui lavoro solo sta gestendo il pasticcio di cui sopra.Classi di quel tipo (il cui compito è gestire la durata del puntatore e le proprietà del puntatore) sono chiamate "puntatori intelligenti".

Answer 7

L'operatore delete fa due cose per l'oggetto si passa:

• chiama il distruttore appropriata.
• chiama la funzione di deallocazione, operator delete.

Quindi l'eliminazione di un oggetto senza chiamare un distruttore significa che si desidera chiamare semplicemente operator delete sull'oggetto:

Foo *f = new Foo; 
operator delete(f); 

operator delete è una normale chiamata di funzione e la risoluzione solita ricerca del nome e il sovraccarico è fatto. Tuttavia l'operatore delete ha le sue regole per trovare il corretto operator delete. Ad esempio, l'operatore delete cercherà le funzioni membro operator delete che la solita ricerca del nome e la risoluzione di sovraccarico non trovano. Ciò significa che devi assicurarti di chiamare la funzione corretta quando usi manualmente lo operator delete.

Come dici tu, utilizzando operator delete è direttamente un'idea terribile. Non riuscendo a chiamare il distruttore si interrompe RAII, con conseguente perdita di risorse. Può anche portare a comportamenti indefiniti. Inoltre, dovrai assumerti la responsabilità di scrivere codice eccezionalmente sicuro senza RAII, che è eccezionalmente difficile. Sei quasi sicuro di sbagliare.