Pointeur C++ de la classe

Quelqu'un peut me dire quelle est la différence entre:

Display *disp = new Display();

Display *disp;
disp = new Display();

Display* disp = new Display();

Display* disp(new Display());

Mais pourquoi "nouvel Affichage" dans le premier cas et "nouvelle GzDisplay" dans la seconde?
aussi est-il une différence dans "Affichage* disp = new Display();"
Non, votre question n'est pas de "puant". Continuez à poser vos questions et nous allons continuer à y répondre. 🙂

OriginalL'auteur Zeeshan Rang | 2009-09-03

c++initialization

17

Le premier cas:
```
Display *disp = new Display();
```
Fait trois choses:
1. Il crée une nouvelle variable disp, avec le type Display*, qui est un pointeur vers un objet de type Display, puis
2. Il alloue un nouveau Display objet sur le tas, et
3. Il définit la disp variable pour pointer vers le nouveau Display objet.
Dans le deuxième cas:
```
Display *disp; disp = new GzDisplay();
```
Vous créez une variable disp avec le type Display*, et ensuite créer un objet de un autre type, GzDisplay, sur le tas, et d'attribuer son pointeur de la disp variable.

Cela ne fonctionnera que si GzDisplay est une sous-classe de l'Affichage. Dans ce cas, il ressemble à un exemple de le polymorphisme.

Aussi, pour répondre à votre commentaire, il n'y a pas de différence entre les déclarations:
```
Display* disp;
```
et
```
Display *disp;
```
Toutefois, en raison de la façon dont C les règles de type de travail, il y a une différence entre:
```
Display *disp1;
Display* disp2;
```
et
```
Display *disp1, disp2;
```
Parce que, dans ce dernier cas disp1 est un pointeur à un Display objet, probablement alloués sur le tas, tandis que disp2 est un objet réel, probablement alloué sur la pile. C'est, alors que le pointeur est sans doute en partie le type, l'analyseur va l'associer à la place de la variable.

Il a changé la question. GzDisplay n'existe plus.
Je pense que vous êtes confus; DONC n'affiche que l'auteur de la plus récente édition; vous devez cliquer sur le "17 minutes ago" (ou quel que soit le moment de son affichage pour vous) pour voir toutes les révisions, et qui les a faites. Lorsque vous faites cela, vous découvrirez que l'affiche originale changé la question. Commentaire meta.stackoverflow.com si vous vous sentez l'INTERFACE est déroutante.
Toutes mes excuses. J'ai supprimé mes commentaires.

OriginalL'auteur Daniel Pryden

//implicit form
//1) creates Display instance on the heap (allocates memory and call constructor with no arguments)
//2) creates disp variable on the stack initialized with pointer to Display's instance
Display *disp = new Display();

//explicit form
//1) creates Display instance on the heap (allocates memory and call constructor with no arguments)
//2) creates disp variable on the stack initialized with pointer to Display's instance
Display* disp(new Display());

//1) creates uninitialized disp variable on the stack
//2) creates Display instance on the heap (allocates memory and call constructor with no arguments)
//3) assigns disp with pointer to Display's instance
Display *disp;
disp = new Display();

Différence entre explicite et implicite des formes d'initialisation ne sera visible que pour les types complexes avec des constructeurs. Pour le type de pointeur d'Affichage (*) il n'y a pas de différence.

Pour voir la différence entre explicite et implicite des formes découvrez l'exemple suivant:

#include <iostream>

class sss
{
public:
  explicit sss( int ) { std::cout << "int" << std::endl; };
  sss( double ) { std::cout << "double" << std::endl; };
  //Do not write such classes. It is here only for teaching purposes.
};

int main()
{
 sss ddd( 7 ); //prints int
 sss xxx = 7;  //prints double, because constructor with int is not accessible in implicit form

 return 0;
}

OriginalL'auteur Kirill V. Lyadvinsky

1
```
Display *disp = new Display();
```
Cette ligne de code créer une variable de type d'Affichage* et l'initialise avec l'adresse d'un objet nouvellement créé.
```
Display *disp;        //(1)
disp = new Display(); //(2)
```
Première ligne de code tout simplement déclare une variable de type d'Affichage*. En fonction de vos paramètres de compilateur (le pointeur peut ou ne peut pas être initialisé. Fondamentalement, il devrait être traité comme un pointeur non valide, qui n'a pas de point nécessaire à NULL.

Deuxième ligne assigne l'adresse d'un objet nouvellement créé à l'aide du pointeur.

Le résultat de ces deux extraits de code sera le même.

Avec les optimisations activées, quel que soit le compilateur doit générer la même assemblée pour deux d'entre eux. Avec les optimisations désactivé, et avec un peu de débogage de génération de code - deux extraits de code susceptible de générer totalement différente de code dans le second cas, le pointeur devrait d'abord être initialisé avec une valeur utilisée par le compilateur pour les pointeurs non initialisés (quelque chose comme 0xDEADBEEF, ou 0xEFEFEFEF et facilement reconnaissable modèle). Dans le premier extrait (le pointeur doit toujours être initialisé à l'adresse de l'objet, quels que soient les paramètres. Notez que c'est le compilateur dépendant de certains compilateurs peuvent le faire comme je l'ai dit, certains peuvent faire quelque chose de complètement différent.

OriginalL'auteur Paulius
1

Vous avez trouvé quatre façons d'écrire la même chose.

Exemples 1 (Display *disp…) et 3 (Display* disp…) sont identiques; l'espacement autour de * n'a pas d'importance. Cependant, le style 1 est souvent préférable, car:
```
Display* disp1, disp2;
```
signifie en réalité:
```
Display *disp1, disp2;
```
c'est à dire, disp2 n'est pas un pointeur.

Exemple deux (fractionnement sur deux lignes) a le même effet, et sera probablement compilé pour le même code. Le quatrième exemple, à l'aide de la syntaxe d'initialiseur, fait la même chose.

Noter que si ces classes ont été, pas des pointeurs, il pourrait y avoir une différence dans le comportement et la vitesse.

Je n'ai pas une telle chose. stackoverflow.com/revisions/1371608/list, révision 4, montre que l'OP changements à sa propre question. Je viens de fixe sa mise en forme pour lui.
Rétracté, mes excuses. Comme je n'ai pas assez de représentants de modifier les questions des autres, je n'étais pas au courant de la façon de rechercher les révisions précédentes de la question. J'ai également supprimé mon downvote.

OriginalL'auteur derobert
0

On crée un objet de type Display et du type GzDisplay, est-ce fait exprès ou est-ce une faute de frappe?

Si c'est une faute de frappe alors il n'y a pas de différence en ce qui concerne le code généré, mais la première méthode est préférable car il n'y a pas de temps dans lequel la variable disp est dans l'étendue et non initialisée.

OriginalL'auteur Motti
0

1) Instance de GzDisplay est créé dans la 2e variante, alors que dans la 1ère variante, instance créée est de type d'Affichage (je suppose GzDisplay est sous-classe de l'Écran, à droite?);
2) en Outre que le 1er est plus courte, 2e disp ont pas défini la valeur jusqu'à ce que affectées avec de nouveaux GzDisplay(). 2e variante vous donne une chance de accidentellement oublier que et insérer un code qui utilise disp avant initialisé.

OriginalL'auteur Victor Sorokin

Vous devez vous connecter pour publier un commentaire.