2010-09-17 5 views
8

Lorsque vous créez un nouvel objet en C++ qui vit sur la pile, (comme je l'ai souvent vu) vous faites ceci:C++ empiler les variables et les variables tas

CDPlayer player; 

Lorsque vous créez un objet le tas que vous appelez new:

CDPlayer* player = new CDPlayer(); 

Mais quand vous faites ceci:

CDPlayer player=CDPlayer(); 

il crée un objet basée sur la pile, b ut quelle est la différence entre cela et l'exemple le plus haut?

+1

duplication possible de [Les parenthèses après le nom du type font-elles une différence avec new?] (Http://stackoverflow.com/questions/620137/do-the-parentheses-after-the-type-name-make- a-difference-with-new) – fredoverflow

Répondre

20

La différence est importante avec PODs (essentiellement, tous les types intégrés comme int, bool, double etc., plus struct C-comme et les syndicats construits que d'autres PODs), pour lesquels il existe une différence entre initialisation par défaut et initialisation de valeur. Pour PODs, un simple

T obj; 

laissera obj non initialisée, alors que T() default-initialise l'objet. Donc

T obj = T(); 

est un bon moyen de s'assurer qu'un objet est correctement initialisé.

Ceci est particulièrement utile dans le code de modèle, où T peut être un type POD ou non-POD. Lorsque vous savez que T n'est pas un type POD, T obj; suffit.

Addendum: Vous pouvez également écrire

T* ptr = new T; // note the missing() 

(et éviter l'initialisation de l'objet alloué si T est un POD).

+2

Les types définis par l'utilisateur peuvent également être des POD, auquel cas ils se comportent comme des built-ins lorsqu'aucune initialisation explicite n'est effectuée. –

+0

@Konrad: Vous avez raison, la distinction est entre PODs et non-PODs! Merci d'avoir signalé cela, j'ai changé ma réponse en conséquence. – sbi

+0

En C++ 0x, vous pouvez assurer une initialisation correcte avec 'T obj {};'. – fredoverflow

8

Lorsque vous créez un nouvel objet en C++ qui vit sur la pile, (...) vous faites ceci:

CDPlayer player; 

Pas nécessairement sur la pile: les variables déclarées de cette manière ont automatique stockage. Où ils vont réellement dépend. Il peut être sur la pile (en particulier lorsque la déclaration est à l'intérieur d'une méthode) mais il peut aussi être ailleurs.

Prenons le cas où la déclaration est dans une classe:

class foo { 
    int x; 
}; 

Maintenant, le stockage de x est où que l'instance de classe est stockée. Si elle est stockée sur le tas, alors il en est 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. 
+4

@Tony: Est-ce que cela répond vraiment à la question? C'était plutôt comme un commentaire supplémentaire .... Cela ne touche en rien la différence entre votre premier et votre troisième code, puisque d'autres réponses l'ont déjà fait. –

0
CDPlayer* player = new CDPlayer(); 

Qu'est-ce que cela ne fait est de créer un pointeur sur la pile et fait pointer vers un objet CDPlayer alloué sur le tas.