Quando si crea un nuovo oggetto in C++ che vive in pila, (il modo in cui ho per lo più visto) si esegue questa operazione:C++ sovrapporre le variabili e le variabili mucchio
CDPlayer player;
Quando si crea un oggetto su mucchio si chiama new:
CDPlayer* player = new CDPlayer();
Ma quando si esegue questa operazione:
CDPlayer player=CDPlayer();
crea uno stack basato oggetto, b ut qual è la differenza tra questo e l'esempio in alto?
La differenza è importante POD (in pratica, tutti incorporati tipi come int, bool, double struct ecc più C-like sindacali e costruiti unicamente da altre POD), per i quali esiste una differenza tra inizializzazione predefinito e inizializzazione valore. Per POD, un semplice
T obj;
lascerà obj non inizializzato, mentre T() default-inizializza l'oggetto. Quindi
T obj = T();
è un buon modo per garantire che un oggetto sia inizializzato correttamente.
Ciò è particolarmente utile nel codice modello, dove T potrebbe essere un POD o un tipo non POD. Quando sai che T non è un tipo POD, è sufficiente T obj;.
addendum: Si può anche scrivere
T* ptr = new T; // note the missing()
(ed evitare inizializzazione dell'oggetto allocato se T è un POD).
I tipi definiti dall'utente possono anche essere POD, nel qual caso si comportano come built-in quando non viene eseguita l'inizializzazione esplicita. –
@Konrad: hai ragione, la distinzione è tra POD e non-POD! Grazie per averlo indicato, ho cambiato la mia risposta di conseguenza. – sbi
In C++ 0x, è possibile garantire l'inizializzazione corretta con 'T obj {};'. – fredoverflow
Quando si crea un nuovo oggetto in C++ che vive in pila, (...) si esegue questa operazione:
CDPlayer player;
Non necessariamente sullo stack: variabili dichiarate in questo modo hanno automatica deposito. Dove effettivamente vanno dipende. Potrebbe essere in pila (in particolare quando la dichiarazione è all'interno di un metodo) ma potrebbe anche essere altrove.
Si consideri il caso in cui la dichiarazione è all'interno di una classe:
class foo {
int x;
};
Ora lo stoccaggio di x è dove mai l'istanza della classe viene memorizzato. Se è memorizzato sul mucchio, allora lo è x:
foo* pf = new foo(); // pf.x lives on the heap.
foo f; // f.x lives where f lives, which has (once again) automatic storage.
@Tony: questo risponde veramente alla domanda? Era piuttosto inteso come un commento supplementare .... Non tocca affatto la differenza tra il tuo primo e il terzo codice, dal momento che altre risposte lo hanno già fatto. –
CDPlayer* player = new CDPlayer();
Quello che fa in realtà è creare un puntatore nello stack e fa puntare ad un oggetto CDPlayer allocato sul mucchio.
possibile duplicato di [Le parentesi dopo il nome del tipo fanno la differenza con il nuovo?] (Http://stackoverflow.com/questions/620137/do-the-parentheses-after-the-type-name-make- a-difference-with-new) – fredoverflow