Sono un programmatore C che cerca di capire il C ++. Molti tutorial dimostrano la creazione di istanze di oggetti utilizzando uno snippet come:
Dog* sparky = new Dog();il che implica che in seguito farai:
delete sparky;il che ha senso. Ora, nel caso in cui l'allocazione dinamica della memoria non sia necessaria, c'è qualche motivo per utilizzare quanto sopra invece di
Dog sparky;e lasciare che il distruttore venga chiamato una volta che Sparky esce dal campo di applicazione?
Grazie!
Risposte:
Al contrario, dovresti sempre preferire le allocazioni dello stack, nella misura in cui, come regola generale, non dovresti mai avere new / delete nel tuo codice utente.
Come dici tu, quando la variabile viene dichiarata nello stack, il suo distruttore viene chiamato automaticamente quando esce dall'ambito, che è il tuo strumento principale per tenere traccia della durata della risorsa ed evitare perdite.
Quindi, in generale, ogni volta che è necessario allocare una risorsa, sia che si tratti di memoria (chiamando new), handle di file, socket o qualsiasi altra cosa, racchiuderla in una classe in cui il costruttore acquisisce la risorsa e il distruttore la rilascia. Quindi puoi creare un oggetto di quel tipo nello stack e hai la garanzia che la tua risorsa venga liberata quando esce dall'ambito. In questo modo non devi tenere traccia delle tue nuove coppie / eliminare ovunque per assicurarti di evitare perdite di memoria.
Il nome più comune per questo idioma è RAII
Esamina anche le classi di puntatori intelligenti che vengono utilizzate per avvolgere i puntatori risultanti nei rari casi in cui devi allocare qualcosa con nuovo al di fuori di un oggetto RAII dedicato. Si passa invece il puntatore a un puntatore intelligente, che quindi tiene traccia della sua durata, ad esempio mediante il conteggio dei riferimenti, e chiama il distruttore quando l'ultimo riferimento esce dall'ambito. La libreria standard ha std::unique_ptruna semplice gestione basata sull'ambito e std::shared_ptrfa riferimento al conteggio per implementare la proprietà condivisa.
Molti tutorial dimostrano la creazione di istanze di oggetti utilizzando uno snippet come ...
Quindi quello che hai scoperto è che la maggior parte dei tutorial fa schifo. ;) La maggior parte dei tutorial ti insegna le pessime pratiche C ++, incluso chiamare new / delete per creare variabili quando non è necessario e darti difficoltà a tenere traccia della durata delle tue allocazioni.
Sebbene avere cose in pila possa essere un vantaggio in termini di allocazione e liberazione automatica, presenta alcuni svantaggi.
Potresti non voler allocare oggetti enormi nello Stack.
Spedizione dinamica! Considera questo codice:
#include <iostream>
class A {
public:
virtual void f();
virtual ~A() {}
};
class B : public A {
public:
virtual void f();
};
void A::f() {cout << "A";}
void B::f() {cout << "B";}
int main(void) {
A *a = new B();
a->f();
delete a;
return 0;
}Questo stamperà "B". Ora vediamo cosa succede quando si utilizza Stack:
int main(void) {
A a = B();
a.f();
return 0;
}In questo modo verrà stampata una "A", che potrebbe non essere intuitiva per coloro che hanno familiarità con Java o altri linguaggi orientati agli oggetti. Il motivo è che non hai più un puntatore a un'istanza di B. Viene invece Bcreata un'istanza di e copiata nella avariabile di tipo A.
Alcune cose potrebbero accadere in modo non intuitivo, specialmente quando sei nuovo in C ++. In C hai i tuoi suggerimenti e basta. Sai come usarli e fanno SEMPRE lo stesso. In C ++ questo non è il caso. Immagina solo cosa succede, quando usi un in questo esempio come argomento per un metodo: le cose si complicano e FA un'enorme differenza se aè di tipo Ao A*o addirittura A&(call-by-reference). Sono possibili molte combinazioni e tutte si comportano diversamente.
Ebbene, il motivo per utilizzare il puntatore sarebbe esattamente lo stesso del motivo per cui utilizzare i puntatori in C allocati con malloc: se vuoi che il tuo oggetto viva più a lungo della tua variabile!
Si consiglia vivamente di NON utilizzare il nuovo operatore se è possibile evitarlo. Soprattutto se usi le eccezioni. In generale è molto più sicuro lasciare che il compilatore liberi i tuoi oggetti.
Ho visto questo anti-pattern da persone che non ottengono abbastanza l'operatore & address-of. Se hanno bisogno di chiamare una funzione con un puntatore, lo allocano sempre sull'heap in modo da ottenere un puntatore.
void FeedTheDog(Dog* hungryDog);
Dog* badDog = new Dog;
FeedTheDog(badDog);
delete badDog;
Dog goodDog;
FeedTheDog(&goodDog);Tratta l'heap come un bene immobile molto importante e usalo con molta saggezza. La regola empirica di base è usare lo stack ogni volta che è possibile e utilizzare l'heap ogni volta che non c'è altro modo. Assegnando gli oggetti in pila puoi ottenere molti vantaggi come:
(1). Non devi preoccuparti dello svolgimento dello stack in caso di eccezioni
(2). Non è necessario preoccuparsi della frammentazione della memoria causata dall'allocazione di più spazio del necessario da parte del gestore di heap.
L'unico motivo di cui mi preoccuperei è che Dog ora è allocato nello stack, piuttosto che nell'heap. Quindi, se Dog ha una dimensione di megabyte, potresti avere un problema,
Se hai bisogno di seguire il percorso nuovo / elimina, fai attenzione alle eccezioni. E per questo motivo dovresti usare auto_ptr o uno dei tipi di puntatori intelligenti boost per gestire la durata dell'oggetto.
Non c'è motivo di nuovo (sull'heap) quando puoi allocare sullo stack (a meno che per qualche motivo tu abbia uno stack piccolo e desideri usare l'heap.
Potresti prendere in considerazione l'utilizzo di shared_ptr (o una delle sue varianti) dalla libreria standard se vuoi allocare sull'heap. Questo gestirà l'eliminazione per te una volta che tutti i riferimenti a shared_ptr saranno scomparsi.
C'è un motivo in più, che nessun altro ha menzionato, per cui potresti scegliere di creare il tuo oggetto dinamicamente. Gli oggetti dinamici basati su heap consentono di utilizzare il polimorfismo .
Ho avuto lo stesso problema in Visual Studio. Devi usare:
yourClass-> classmethod ();
piuttosto che:
yourClass.classMethod ();