vector de pointeurs sur des objet

Bonjour,

je veux stocker des objets dans un vecteur :

Code:

---

1 2 3 4 5 6

class Object; vector<Object*> * myVector = vector<Object*>();   Object *o = new Object(); vector->push_back(o);

---

le problème est qu'après le push_back, le vecteur ne contient pas l'objet mais une référence invalide sur mon object.

quelqu'un aurait-il une idée du problème?
Merci

Salut,
Je reprends ton code avec int que tu peux remplacer par Objet.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <vector> using namespace std; int main() { vector< int* > * myVector = new vector< int* >; int* p = new int; myVector->push_back(p); delete myVector; delete p; }

---

Salut

Première remarque : utiliser un vector alloué dynamiquement c'est du contre-emploi et ça a très peu d'intêret, le but est justement de ne pas se soucier de ce genre de manipulations de mémoire.

Deuxième remarque : si tu souhaites stocker des objets dans ton vecteur, ne passe pas par des trucs alloués dynamiquement et des pointeurs. Là tu vas seulement stocker un pointeur, pas un objet.

Bon si finalement c'était bien ce que tu voulais faire, alors... ton code a l'air correct, qu'est-ce qui cloche exactement ? Peut-être une mauvaise gestion de l'objet pointé ?

Ah oui et euh... Dernière remarque : essaie de poster un code qui compile (relis-toi un coup avant de valider !) :D

En fait, je veux construire une liste d'objet et la passer à un autre objet. J'ai donc besoin de faire des allocations dynamiques pour que mes objet et ma liste ne soient pas supprimés à la fin de mon bloc d'instructions construisant la liste. J'aurais pu déclarer un vector<Object> au lieu d'un vector<Object*> mais ça compile pas... Le compilo (mingw et visualc++) n'arrive pas à instancier l'opérateur = du template.... (po compris)

Citation:

---

qu'est-ce qui cloche exactement ?

---

En débuggant pas à pas voici ce que je vois:
- instanciation du vecteur -> j'obiens bien un vecteur vide
- instanciation de l'object -> les champs sont correctement initialisés
- push_back de l'object -> le vecteur semble contenir un référence sur un Object mais cet object en question n'est pas initialisé (le débugger ne parvient pas à m'afficher le contenu des champs). De plus la référence sur l'objet dans le vecteur est différentte de celle de mon objet initial.

voila... J'essayerai d'y voir plus clair demain

Donne nous un exemple d'éxecution, par exemple

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <vector> #include <iostream> using namespace std; int main() { vector< int* > * myVector = new vector< int* >; int* p = new int;   myVector->push_back(p); cout<<"Adresse pointeur:"<<p<<endl; cout<<"Element du vecteur:"<<(*myVector)[0]<<endl; delete myVector; delete p; }

---

Code:

---

1 2 3 4

E:\home>a.exe Adresse pointeur:0x3d2448 Element du vecteur:0x3d2448

---

Les éléments correspondent bien dans mon cas. J'ai essayé d'utiliser un autre type que int avec un structure

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include <vector> #include <iostream> using namespace std;   struct test{int i;float f;double d;};   int main() { vector< test* > * myVector = new vector< test* >; test* p = new test;   myVector->push_back(p); cout<<"Adresse pointeur:"<<p<<endl; cout<<"Element du vecteur:"<<(*myVector)[0]<<endl; delete myVector; delete p; }

---

Code:

---

1 2 3 4

E:\home>a.exe Adresse pointeur:0x3d24c0 Element du vecteur:0x3d24c0

---

Ce qui fonctionne aussi. A toi de nous montrer ce qui se passe concrètement.

En général, on peut toujours se débrouiller pour se passer de l'allocation dynamique d'un conteneur de la STL. Tu peux passer celui-ci par référence à ta fonction, et le remplir comme il faut, ou bien le mettre comme valeur de retour (en payant une recopie en +, mais si les perfs ne sont pas importantes tu peux le faire).

Pour ce qui est des éléments, ce sont des copies qui sont stockées, donc effectivement il te faut un constructeur par copie, un destructeur, et un opérateur d'affectation corrects. Si ta classe n'est pas faite pour être copiée il faut donc bien passer par des pointeurs.

Et euh... je comprends pas ton problème. Si tu instancies un objet dynamiquement et que tu copies ton pointeur dans un vector, tant que tu ne touches pas à cet objet rien ne devrait partir en couille. Le pointeur stocké n'est quand même pas différent de l'adresse de ton objet :?:

Je viens d'avoir une idée qui peut etre la réponse a ton problème:
Si tu instancies un objet dans un bloc (fonction par exemple) et que tu ajoutes l'adresse pointant vers cette objet à ce moment, lorsque tu quittes la fonction l'adresse n'a plus aucun sens car l'objet est détruit a la sortie du bloc.
Pour illustrer voici un exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#include <vector> #include <iostream> using namespace std;   vector<int *> * myVector= new vector<int*>;     void func() { int i=5; myVector->push_back(&i); cout<<"Adresse de i :"<<&i<<endl; cout<<"Element du vecteur :"<<(*myVector)[0]<<endl; cout<<"Element pointé dans func:"<<*(*myVector)[0]<<endl; }   int main() {   func(); cout<<"Element du vecteur :"<<(*myVector)[0]<<endl; cout<<"Element pointé hors de func:"<<*(*myVector)[0]<<endl;   }

---

Code:

---

1 2 3 4 5 6 7 8 9

$>a.exe Adresse de i :0x22ff74 Element du vecteur :0x22ff74 Element pointÚ dans func:5 Element du vecteur :0x22ff74 Element pointÚ hors de func:4396112   $>

---

Dans son code l'objet est alloué sur le tas avec new, donc je pense pas que ce soit ça. Enfin son premier code devait pas venir de son appli vu les fautes d'étourderies qu'il contenait :wink:

D'abord merci à tous.
Ensuite, ça y est, j'ai trouvé. J'avais juste les yeux pas en face des trous :
la construction de ma liste de pointeurs se faisaient correctement. Lorsque je débuggais pas à pas, je voyais un nouvel object dans le vecteur mais différent de celui créé. En fait c'est juste le débugger qui n'arrive pas à m'afficher le contenu du pointeur contenu dans le vecteur sous forme de référence...
En fait l'errreur était plus loin mais voyant ce comportement dans le débugger, je l'ai mal localisée. Il s'agissait d'un étourderie pourtant facilement remarquable : à un moment dans l'objet auquel j'ai passé le vecteur, je faisais :

Code:

---

1 2 3 4 5 6

vector<Object*>::const_iterator it = myVector->begin(); while( it != myVector->end() ) { faire quelque chose avec *it; }

---

Vous voyez l'erreur : j'avais oublié d'incrémenter l'itérateur, d'où boucle infinie...

Voilà, désolé d'avoir utiliser le forum pour une erreur aussi bête. Je devrais peut être priviligier le parcours de liste avec un for( it = ...; it!= ..; it++) ...

Merci encore, salut

Citation:

---

Envoyé par Loulou24

Dans son code l'objet est alloué sur le tas avec new, donc je pense pas que ce soit ça. Enfin son premier code devait pas venir de son appli vu les fautes d'étourderies qu'il contenait :wink:

---

C'est vrai que le code qu'il nous a montré dans le premier message n'est pas à mon avis à considérer étant donné le nombre d'erreurs s'y trouvant.
Autrement, pour ajouter une précision dans ton sens, l'objet alloué sur le tas sera désalloué lors de l'appel au destructeur et non a la fin du bloc comme un objet alloué dans la pile.
En voici l'illustration

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <iostream> #include <vector> using namespace std;   vector< int* > * myVector= new vector< int*>;   int main() {   int* p=new int(2); myVector->push_back(p); cout<<"Adresse du pointeur :"<<p<<endl; cout<<"Element du vecteur :"<<(*myVector)[0]<<endl; cout<<"Element pointé :"<<*p<<endl; delete p;   cout<<"Element du vecteur :"<<(*myVector)[0]<<endl; cout<<"Element pointé :"<<*(*myVector)[0]<<endl; delete myVector; }

---

Code:

---

1 2 3 4 5 6 7 8 9

$>a.exe Adresse du pointeur :0x3d23c0 Element du vecteur :0x3d23c0 Element pointÚ :2 Element du vecteur :0x3d23c0 Element pointÚ :4007296   $>

---

peut-être utiliser un pointeur intelligent pour ne pas se soucier de la destruction de l'objet ?

boost::shared_ptr serait approprié dans ce cas je pense

Code:

---

1 2	std::vector<boost::shared_ptr<ta_classe> > v;

---

Citation:

---

Envoyé par BlackGoddess

peut-être utiliser un pointeur intelligent pour ne pas se soucier de la destruction de l'objet ?

boost::shared_ptr serait approprié dans ce cas je pense

Code:

---

1 2	std::vector<boost::shared_ptr<ta_classe> > v;

---

---

Je ne connais pas , a quoi ca sert stp ?

Compter les références.
Rendre automatique une variable qui ne l'est pas.
Ici, cela permet de partager des objets pointés. Effet de bord, intercepte des fuites de mémoire

Code:

---

1 2 3 4

std::vector<boost:shared_ptr<object>> v; v.push_back(new object(1)); v.push_back(new object(2)); throw "une exception";

---

Avec des pointeurs bruts, on perdait de la mémoire.
(J'ai explicité la levée d'exception, mais il ne faut pas oublier que new est autorisé à en lever)


D'ailleurs, mais pourquoi diable un pointeur sur un vecteur ? Un vecteur, c'est déjà un pointeur, mais enveloppé dans un objet automatique => que des avantages.

Citation:

---

D'ailleurs, mais pourquoi diable un pointeur sur un vecteur ? Un vecteur, c'est déjà un pointeur, mais enveloppé dans un objet automatique => que des avantages.

---

pour donner le vecteur à un autre objet. Si je fais pas un new vector, mon vecteur sera perdu à la fin de mon bloc d'instructions.

Renvoie-le. Avec RVO plus swap, il est tout à fait possible selon les compilo de ne payer aucune copie.

Ou alors passe le par paramètre (sortant) -> référence.

RVO plus swap.... c'est quoi?

Je pourrai très bien le passer par référence mais j'ai quand même besoin de faire un new non?
Après c'est juste une convention de codage à moi : pour les objets qui ont une relation de composition (la destruction du conteneur entraine celle du contenu) avec d'autres d'objets, je déclare les champs de la classe conteneur comme des pointeurs. Ca permet de faire delete monChamp plutot que delete &monChamp.
De cette façon, si dans un bout de code j'ai une référence, je sais que je n'ai pas à me soucier de la destruction de l'objet référencé (il est pointé quelque part ailleurs par un conteneur).

Dans mon exemple précédent, je crée et initialise un vecteur pour le donner ensuite à un objet responsable de sa destruction.

RVO : Return Value Optimization. Certains compilos savent ne pas recopier les choses renvoyées. Avec le swap, dans le pire des cas (propre à chaque compilo) on n'aurait qu'une recopie.

Code:

---

1 2 3 4 5

typedef std::vector<T> vecteur; vecteur f() { .... return fv; }   vecteur v; v.swap(f());

---

Pas besoin de new si on optimize via les références.

Code:

---

1 2 3 4 5 6 7

void f(vecteur & out_v) ' out_v.clear(); out_v.push_back(T(...)); } ... vecteur v; f(v);

---

Citation:

---

Ca permet de faire delete monChamp plutot que delete &monChamp.

---

Tu ne viendrais pas du Java ?
En C++, on a variables de n'importe quel type, et pointeurs sur n'importe quel type (qui sont des variables aussi). Et un objet composé d'autres objets automatiques détruits ceux-ci automatiquement.

De fait, je n'écrirai jamais ceci :

Code:

---

1 2 3 4 5 6

struct S { S() : v_(0) { ... } ~S() { delete v_; } private: vecteur * v_; };

---

mais ceci:

Code:

---

1 2 3 4 5 6

struct S { S() : { ... } ~S() {} private: vecteur v_; };

---

Dans la mesure du possible on enveloppe tous les pointeurs dans des objets automatiques. C'est la meilleure façon d'avoir un code non seulement clair et simple, mais en plus robuste ; cette approche remplace avantageusement le dispose pattern qui est obligatoire en Java et autres langages ne supportant pas l'idiome RAII (Ressource Acquisition is Initialization). Les pointeurs brtuts se marient mal avec les exceptions. Et justement les vecteurs sont une encapsulation de pointeurs bruts.

EDIT: le dernier paragraphe

oui oui tout à fait, j'ai dit un peu n'importe quoi (je viens effectivement du monde java) mais...
comment tu fais dans ta structure S pour initialiser le vecteur par un autre objet via un setter?

Code:

---

1 2 3 4 5 6 7 8

struct S { S() : { ... } ~S() {} void setVecteur( vecteur &); private: vecteur v_; };

---

si tu déclares le champ vecteur v_ alors la méthode set devra recopier le vecteur donné non?

Je ne défini pas de mutateur (set) quand cela n'a pas de sens. Et cela en a justement rarement.
Si j'ai un objet qui en interne manipule un vecteur, et bien c'est en interne justement, et ce vecteur ne doit pas être exposé. L'exposer c'est cesser de garantir l'intégrité de cet objet. Si cela n'a rien d'interne, alors inutile de le cacher dans la zone privée.

Et si je devais en proposer un, il s'écrirait tout simplement :

Code:

---

1 2 3 4 5 6

void S::set_v(vecteur const & v) { SMART_ASSERT(S::est_acceptable(v)) .error("Le vecteur reçu dans S::set_v() n'est pas acceptable"); v_ = v; }

---

groumf, comprend plus là...

dans le set tu fais v_ = v. Y'a pas de recopie la?

Tu écrivais là un mutateur (chose rarement utile je trouve ...). Obligatoirement il y a une recopie.
En interne dans les fonctions de S, si v_ doit être initialisé depuis une autre fonction (externe à S cette fois) qui renvoie un vecteur, j'utiliserais directement swap() sur v_.

Il est difficile de parler de manière générale. Suivant le problème, soit la copie n'est pas grave, soit on a directement ou indirectement (via un back_inserter p.ex.) accès à v_.

Ce qui est certain, c'est que l'on va éviter d'avoir des std::vector<>*, au pire des cas on aurait des boost::shared_ptr<vector<> >. Mais quand on a des design avec un vecteur partagé entre plein d'objets, et qu'on ne peut pas vraiment décider d'un propriétaire, et que l'on a des fonctions qui renvoient des vecteurs entiers plutôt que de venir remplir directement le vecteur destinataire.

j'ai parlé de pointeurs intelligents parce que j'ai pensé que tu voulais garder un lien vers tes objets créés, ou eviter des eventuels copies de ces objets ...

si c'est ton vecteur entier que tu ne veux pas copier, quel est alors l'interet de faire un vecteur de pointeurs ?

edit : désolé, avait pas vu la 2eme page ...

si c'est seulement la copie de retour qui tennuie, std::auto_ptr est fait pour ca

Finalement en lisant toutes ces réponses intéressantes, j'ai revu ma conception et suis arrivé à m'en sortir en faisant qq chose de beaucoup plus simple. Plus de pointeur sur des vecteurs de pointeurs (qui eux mêmes pointaient sur des objets contenant des pointeurs sur des listes de pointeurs...). En fait ces choix bizarres avaient pour origine une précédente conception où j'avais besoin de faire çà. Je voulais créer des objets qui contiennent des listes ou des vecteurs mais obliger la création et initialisation de la liste avant la création du conteneur. Je voulais absolument éviter des recopies car les objets contenus dans les listes peuvent être assez volumineux (images par exemple) et mon application a des contraintes de perfs (temps réel).
Maintenant, je m'embête plus : les conteneurs ont un vecteur par valeur et proposent une simple méthode add. Je garde quand même le vecteur de pointeur parce que je ne veux pas faire de copie ni supprimer les objets contenus dans le vecteur.

Merci pour vos réponses, ça m'a permis de prendre du recul sur mon code et de le revoir.
Mais en fait il reste tout de même un petit problème : quand je demande à mes conteneurs d'initialiser leur vecteur avec une certaine capacité, il semble que je n'arrive plus à remplir le vecteur.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

class Objet { public: void foo(); }   class Conteneur { std::vector<Objet*> m_Objets; Objet *m_ObjetCourant; public: int m_IndexObjet;   Conteneur() : m_IndexObjet(0){ m_ObjetCourant = NULL; } Conteneur( int taille ): m_IndexObjet(0), m_Objets( taille ) { m_ObjetCourant = NULL; } void addObject(Objet *objet){ m_Objets.push_back(objet); if (m_ObjetCourant == NULL) m_ObjetCourant = m_Objets[0]; } void bar() { if (m_IndexObjet > 0 && m_IndexObjet < m_Objets.size()) { m_ObjetCourant = m_Objets[m_IndexObjet]; m_ObjetCourant->foo(); } } };     Conteneur * creerConteneur() { Conteneur *conteneur = new Conteneur(3); Objet *o1 = new Objet(); Objet *o2 = new Objet(); return conteneur; }     void main() { Conteneur *conteneur = creerConteneur(); while(1) { conteneur->m_IndexObjet = (conteneur->m_IndexObjet + 1) %2; conteneur->bar(); } }

---

Quand je crée un Conteneur sans initialiser la taille de son vecteur, tout se passe bien. Quand je donne la taille alors j'arrive bien à exécuter la méthode foo() du premier objet contenu mais dès que je veux passer au suivant je récupère un pointeur NULL.
Voyez vous une erreur dans ma façon de faire?

Conteneur() : m_IndexObjet(0){
m_ObjetCourant = NULL;
}

=> tu peux ecrire

Conteneur() : m_IndexObjet(0), m_ObjetCourant(NULL){
}

push_back ajoute un élément a la fin de ton vecteur ...

si tu as réservé trois éléments, ils existent mais ne sont pas initialisés.
un push_back en rajouter un 4eme (et les 3 premiers ns sont toujours pas initialisés)

Merci!

Il faut utiliser reserve() et pas resize() (que tu as utilisé indirectement avec le constructeur auquel tu as passé une taille)


Sinon, il n'y aucun intérêt à avoir des pointeurs dans ton main.
Quelques lectures pour te faire méditer pourquoi en C++ on fuit les pointeurs bruts :
- http://www.gamedev.net/reference/art...article953.asp
- http://www.relisoft.com/book/tech/index.htm
- http://www.gotw.ca/gotw/ (items qui traitent des exceptions -> ^F)
- Pour les autres ressources (autres que pointeurs), il y a ça : http://www.cuj.com/documents/s=8000/...r/alexandr.htm

EDIT: des références en plus.

Nickel, y'a tout qui marche!!
Initialisation d'un vecteur, reserve puis après un série de push_back et ça roule.
Merci à tous!