C++ vecteur d'objets vs. vecteur de pointeurs sur des objets

Ma question est simple: pourquoi l'aide d'un
vecteur de pointeurs de travail, et quand
voulez-vous créer un vecteur d'objets
par rapport à un vecteur de pointeurs sur ces
objets?

std::vector est comme une brute tableau alloué avec new et réaffecté lorsque vous essayez de pousser en plus d'éléments que sa taille actuelle.

Donc, si elle contient A pointeurs, c'est comme si vous étiez la manipulation d'un tableau de A*.
Lorsqu'il a besoin de redimensionner (vous push_back() un élément alors qu'il est déjà rempli à sa capacité actuelle), il va créer un autre A* tableau et la copier dans le tableau de A* de la précédente vecteur.

Si elle contient A objets, alors c'est comme si vous étiez à la manipulation d'un tableau de A, donc A doit être par défaut constructible si il y a automatique des réaffectations de se produire. Dans ce cas, l'ensemble de la A des objets copiés aussi dans un autre tableau.

Voir la différence? La A objets dans std::vector<A> pouvez changer d'adresse si vous faites quelques manipulations que nécessite le redimensionnement du tableau interne. C'est là que la plupart des problèmes contenant des objets dans std::vector vient de.

Un moyen d'utiliser std::vector sans avoir de tels problèmes est d'allouer un assez grand tableau à partir du début. Le mot clé ici est "en capacité". Le std::vector la capacité est le réel taille de la mémoire tampon dans lequel on va mettre les objets. Donc, pour l'installation de la capacité, vous avez deux choix:

1) la taille de votre std::vector de la construction pour construire l'objet depuis le début , avec le nombre maximal d'objets - qui appellent des constructeurs de chacun des objets.

2) une fois le std::vector est construit (mais n'a rien en elle), utiliser ses reserve() fonction : le vecteur sera alors d'allouer un tampon assez grand (vous offrir le maximum de la taille du vecteur). Le vecteur permettra de définir la capacité. Si vous push_back() objets de ce vecteur ou resize() - dessous de la limite de la taille que vous avez fournies dans le reserve() appel, il ne sera jamais à réallouer de la mémoire tampon interne, et vos objets pas de changement de l'emplacement dans la mémoire, en faisant des pointeurs vers ces objets toujours valide (certaines affirmations de vérifier que le changement de capacité ne se produit jamais est une excellente pratique).

Si vous allouez de la mémoire pour les objets à l'aide de new, vous êtes de l'allocation sur le tas. Dans ce cas, vous devez utiliser des pointeurs. Toutefois, en C++, la convention est généralement de créer tous les objets sur la pile et de transmettre des copies de ces objets au lieu de passer des pointeurs vers des objets sur le tas.

Pourquoi est-ce mieux? C'est parce que le C++ n'a pas de collecte des ordures, afin de la mémoire pour les objets sur le tas ne sera récupéré sauf si vous delete l'objet. Toutefois, les objets sur la pile sont toujours détruits lorsqu'ils quittent la portée. Si vous créez des objets sur la pile au lieu de le tas, vous pouvez réduire votre risque de fuites de mémoire.

Si vous utilisez la pile au lieu de le tas, vous aurez besoin d'écrire une bonne copie des constructeurs et des destructeurs. Mal écrit copier les constructeurs ou destructeurs peuvent conduire à des fuites de mémoire ou double libère.

Si vos objets sont trop volumineux pour être efficace copié, alors il est acceptable d'utiliser des pointeurs. Cependant, vous devez utiliser de comptage de références pointeurs intelligents (soit le C++0x auto_ptr ou un la bibliothèque Boost pointeurs) pour éviter les fuites de mémoire.

Je n'ai pas de magasin de classes directement dans std::vector. La raison en est simple: vous ne savez pas si la classe est dérivée ou pas.

E. g.:

Dans les en-têtes:

class base
{
public:
  virtual base * clone() { new base(*this); };
  virtual ~base(){};
};
class derived : public base
{
public:
  virtual base * clone() { new derived(*this); };
};
void some_code(void);
void work_on_some_class( base &_arg );

Dans la source:

void some_code(void)
{
  ...
  derived instance;
  work_on_some_class(derived instance);
  ...
}

void work_on_some_class( base &_arg )
{
  vector<base> store;
  ...
  store.push_back(*_arg.clone());
  //Issue!
  //get derived * from clone -> the size of the object would greater than size of base
}

Donc je préfère utiliser shared_ptr:

void work_on_some_class( base &_arg )
{
  vector<shared_ptr<base> > store;
  ...
  store.push_back(_arg.clone());
  //no issue :)
}