Instanciation De L'Objet C++

bien qu'avoir des choses sur la pile pourrait être un avantage en termes d'allocation et de libération automatique, il a certains inconvénients.

1. vous pourriez ne pas vouloir allouer des objets énormes sur la pile.

2. répartition Dynamique! Considérez ce code:

#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;
}

"B". Voyons maintenant ce qui se passe quand on utilise Stack:

int main(void) {
  A a = B();
  a.f();
  return 0;
}

cela affichera" A", ce qui pourrait ne pas être intuitif pour ceux qui sont familiers avec Java ou d'autres langages orientés objet. La raison est que vous n'avez plus de pointeur vers une instance de B . Au lieu de cela, une instance de B est créée et copiée en a variable de type A .

certaines choses peuvent se produire de façon non intuitive, surtout quand vous êtes nouveau en C++. En C vous avez vos conseils et c'est tout. Vous savez comment les utiliser et ils font toujours la même chose. En C++, ce n'est pas le cas. Imaginez juste ce qui se passe, quand vous utilisez un dans cet exemple comme argument pour une méthode - les choses deviennent plus compliquées et cela fait une énorme différence si a est de type A ou A* ou même A& (appel par référence). De nombreuses combinaisons sont possibles et se comportent toutes différemment.

Eh bien, la raison d'utiliser le pointeur serait exactement la même que la raison d'utiliser les pointeurs en C alloués avec malloc: si vous voulez que votre objet de vivre plus longtemps que votre variable!

il est même fortement recommandé de ne pas utiliser le nouvel opérateur si vous pouvez l'éviter. Surtout si vous utilisez des exceptions. En général, il est beaucoup plus sûr de laisser le compilateur gratuitement vos objets.

j'ai vu cet anti-modèle de gens qui ne reçoivent pas tout à fait l'adresse de l'opérateur. Si ils ont besoin pour appeler une fonction avec un pointeur, ils vont toujours allouer sur le tas afin qu'ils obtiennent un pointeur.

void FeedTheDog(Dog* hungryDog);

Dog* badDog = new Dog;
FeedTheDog(badDog);
delete badDog;

Dog goodDog;
FeedTheDog(&goodDog);

traitez heap comme un bien immobilier très important et utilisez-le très judicieusement. La règle de base est d'utiliser la pile chaque fois que possible et d'utiliser heap chaque fois qu'il n'y a pas d'autre moyen. En attribuant les objets sur la pile vous pouvez obtenir de nombreux avantages tels que:

(1). Vous n'avez pas à vous soucier de stack unwinding en cas d'exception

(2). Vous n'avez pas à vous soucier de la fragmentation de la mémoire causée par l'attribution plus d'espace que nécessaire par votre gestionnaire de tas.

la seule raison pour laquelle je m'inquiétais est que le chien est maintenant alloué sur la pile, plutôt que le tas. Donc, si le Chien est mo, vous pouvez avoir un problème,

si vous devez suivre la nouvelle route/supprimer, méfiez-vous des exceptions. Et pour cette raison, vous devriez utiliser auto_ptr ou l'un des types de pointeur intelligent boost pour gérer la durée de vie de l'objet.

il n'y a pas de raison à nouveau (sur le tas) quand vous pouvez allouer sur la pile (à moins que pour une raison quelconque, vous avez une petite pile et que vous voulez utiliser le tas.

Vous pouvez envisager d'utiliser un shared_ptr (ou une de ses variantes) de la bibliothèque standard si vous ne souhaitez allouer sur le tas. Cela vous permettra de supprimer pour vous une fois que toutes les références à shared_ptr auront disparu.

il y a une raison supplémentaire, que personne d'autre n'a mentionnée, pour laquelle vous pourriez choisir de créer votre objet dynamiquement. Les objets Dynamic, heap vous permettent d'utiliser le polymorphisme .

J'ai eu le même problème dans Visual Studio. Vous devez utiliser:

yourClass- > classMethod ();

plutôt que:

votre classe.classemethod ();