Quelle est la différence entre l'instanciation d'un objet en utilisant new vs without
En C++,
Mis à part l'allocation dynamique de mémoire, existe-t-il une différence fonctionnelle entre les deux lignes de code suivantes:
Time t (12, 0, 0); //t is a Time object
Time* t = new Time(12, 0, 0);//t is a pointer to a dynamically allocated Time object
Je suppose bien sûr qu'un ctor Time (int, int, int) a été défini. Je me rends également compte que dans le deuxième cas, t devra être supprimé car il a été alloué sur le tas. Y a-t-il une autre différence?
La ligne:
Time t (12, 0, 0);
... alloue une variable de type Time dans la portée locale, généralement sur la pile, qui sera détruite à la fin de sa portée.
Par contre:
Time* t = new Time(12, 0, 0);
... alloue un bloc de mémoire en appelant ::operator new() ou Time::operator new(), puis appelle Time::Time() avec this défini sur une adresse dans ce bloc de mémoire (et également retourné à la suite de new), qui est ensuite stocké dans t. Comme vous le savez, ceci est généralement fait sur le tas (par défaut) et nécessite que vous delete plus tard dans le programme, tandis que le pointeur dans t est - généralement stocké sur la pile.
Une différence plus évidente est lors de l'accès aux variables et aux méthodes de t.
Time t (12, 0, 0);
t.GetTime();
Time* t = new Time(12, 0, 0);
t->GetTime();
En ce qui concerne le constructeur, les deux formes sont fonctionnellement identiques: elles ne feront qu'appeler le constructeur sur une instance d'objet nouvellement allouée. Vous semblez déjà avoir une bonne compréhension des différences en termes de modes d'allocation et de durée de vie des objets.
Je pense que vous comprenez déjà toutes les différences. En supposant que vous êtes bien conscient de la différence de syntaxe d'accès à un membre de t via un pointeur et une variable (enfin, le pointeur est également une variable mais je suppose que vous comprenez ce que je veux dire). Et en supposant également que vous connaissez la différence d'appel par valeur et d'appel par référence lorsque vous passez t à une fonction. Et je pense que vous comprenez également ce qui se passera si vous affectez t à une autre variable et apportez des modifications à travers cette autre variable. Le résultat sera différent selon que t est pointeur ou non.
Non .. Il n'y a pas d'autre différence ..
Il n'y a pas d'autre différence avec ce que vous savez déjà.
En supposant que votre code utilise le service de l'opérateur par défaut new.
Il n'y a aucune différence fonctionnelle à l'objet entre l'allouer sur la pile et l'allouer sur le tas. Les deux invoqueront le constructeur de l'objet.
Par ailleurs, je vous recommande d'utiliser le shared_ptr ou scoped_ptr de boost qui est également fonctionnellement équivalent lors de l'allocation sur le tas (avec l'utilité supplémentaire de scoped_ptr vous contraignant de copier des pointeurs non copiables):
scoped_ptr<Time> t(new Time(12, 0, 0));
- Utiliser nouveau: appeler la nouvelle fonction de l'opérateur pour obtenir la mémoire dynamique, puis appeler la fonction de constucteur.
- Ne pas utiliser de nouveau: n'appellera pas la nouvelle fonction de l'opérateur, juste directement pour appeler la fonction de constructeur. La pile sera utilisée directement, inutile de malloc.