Probleme avec parcours de stl::vector

Bonjour,

Voila, j essaye de parcourir un vecteur en utilisant un iterateur. Voici le code:

Code:

---

1 2 3 4 5 6

for(vector<unsigned int>::iterator it=p->getCode().begin();it !=p->getCode().end();it++) { ShowMessage(IntToStr(p->getCode()[0])); // affichage 1 ShowMessage(IntToStr(*it)); // affichage 2 ShowMessage(IntToStr(*(p->getCode().begin()))); //affichage 3 }

---

Mon probleme c est que affichage 1 et 3 sont corrects mais pas l affichage 2, qui me retourne une valeur du genre "98767867" alors que affichage 1 et 2 renvoie la valeur correcte 12.

Je ne comprends pas.

getCode() ne renverrait pas une copie ?

Je ne suis pas sur de comprendre ta question donc je te mets le code de getCode():
Quelques explications avant.
Une classe Trame qui n est qu une liste d objets de la classe Info qui eux contiennent une chaine, un vecteur d entier (ce dont on parle ici), ...

dans ma classe Info, il y a donc cette methode:

Code:

---

1 2 3 4 5

vector<unsigned int> Info::getCode() { return code; }

---

où code est un vector<unsigned int> . Est ce cela renvoyer une copie ?

Dans la boucle precedente, p est l iterateur de parcours de ma liste de la calsse Trame et pointe donc sur un objet de type Info.

Voila j espere que j ai ete assez clair ...

Citation:

---

Envoyé par MDiabolo

Est ce cela renvoyer une copie ?

---

oui.

pour renvoyer une référence

Code:

---

1 2 3 4 5

vector<unsigned int> & Info::getCode() { return code; }

---

Bon je peux pas tester ici mais des que je rentre ce soir je teste ca ...
Sinon il vaut donc toujours mieux renvoyer une reference qu une copie ?

Quelles sont les regles dans ce domaine ?

En tout cas merci beaucoup. Je vous tiens au courant.

Ben une copie déjà ça va prendre du temps pour des gros objets,
Si tu copie une std::vector de 1000000 éléments ça va prendre du temps.
Par contre si tu renvoie une référence, l'objet ne sera pas copié, tu passera l'objet lui même.
De plus si tu modifie la copie, ça ne modifiera pas l'objet initiale :

Code:

---

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

#include <iostream> void Substract(int i, int j) { std::cout << i << std::endl; i -= j; std::cout << i << std::endl; } int main(void) { int i = 10; std::cout << i << std::endl; Substract(i, 5); std::cout << i << std::endl; return 0; }

---

normalement ce code va te retourner :

Code:

---

1 2 3 4

10 10 5 10

---

car le i de la fonction substract va copier i et tu va travailler avec la copie de i, pas avec i.
par contre

Code:

---

1 2 3 4 5 6

void Substract(int& i, const int& j) { std::cout << i << std::endl; i -= j; std::cout << i << std::endl; }

---

va te retourner

Code:

---

1 2 3 4

10 10 5 5

---

car cette fois Substract travail sur i lui même, le i du main et le i de Substract ne font qu'un...

donc ta fonction GetCode qui retourne un std::vector<unsigned int> copie le std::vector<unsigned int> qui est dans ta class....
le fait de retourner un std::vector<unsigned int>& va retourner non pas une copie de l'élément de ta class mais l'élément lui même...
par conséquent, quand tu appel GetCode dans ta boucle for :

Code:

---

1 2 3 4

for (std::vector<unsigned int>::iterator pi = p->GetCode().begin(); pi != p->GetCode().end(); ++pi) { /**/ }

---

le premier appel à GetCode cré un vector et copie le vector de ta class dedans.
Le second égallement... Donc tu as des problèmes, car l'itérateur que tu fais varier n'est pas dans le même contener que la limite...
Je crois même qu'en debug, ton code va créer un vector, copier ton vector, pour faire le test != de end(), puis détruire ce vector à la fin du test, et ce pour chaque test, donc autant de fois que la taille de ton vector...
Les compilateurs optimisent cela en release, il stocke la valeur si elle ne change pas; j'ai testé.

Une petite remarque :
Pourquoi utilise tu le vector comme une liste ?
L'intérêt du vector c'est d'avoir accès à n'importe quel élément grâce à son index.
L'intérêt de la liste c'est de la parcourir en sautant d'un élément à son suivant...

Citation:

---

Envoyé par MDiabolo

Sinon il vaut donc toujours mieux renvoyer une reference qu une copie ?

Quelles sont les regles dans ce domaine ?

---

Quand je le peux, je renvoie des références constantes.
Des copies quand la donnée est générée dans la fonction. Mais là, il ne faut pas écrire ce que tu as écrit. Extraire (directement) des itérateurs d'un temporaire non nommé n'a aucun autre intérêt qu'être une source de bugs. Cf la réponse de Rafy.

@ Rafy, utiliser un vecteur n'implique pas nécessairement de ne pas itérer avec un itérateur. Il y a quantité d'autres intérêts à avoir des vecteurs (occupation mémoire, contiguité des éléments, ...) et pourtant ils se parcourrent très bien avec des itérateurs -- sauf cas particuliers.

Merci pour toutes vos reponses,

bon la parie qui posait probleme marche mais maintenant je suis confus avec ces references et ces pointeurs.

La premiere est pourquoi si je veux renvoyer une reference je dois ecrire ca:

Code:

---

1 2 3 4

vector<unsigned int> & Info::getCode() { return code; }

---

et pas ca

Code:

---

1 2 3 4

vector<unsigned int> & Info::getCode() { return &code; }

---

De plus quelle est la difference entre passer une reference (&) et passer un pointeur (*) en pratique ? Dans quel cas l un, dans quel cas l autre ?. Je sais c est dans la faq, mais apres l avoir lu plusieurs fois je fais toujours des erreurs en pratique (bon je me console en me disant que je suis surement pas le seul mais bon...)

Voire mieux:

Code:

---

1 2	std::vector<unsigned int> const& getCode() const {return m_code;}

---

Un accesseur qui renvoie une référence non constante est une faute de goût -- une rupture obscurantiste d'encapsulation en ce qui me concerne.

La question référence ou pointeur a été reposée il y a moins de 10 jours.

"&var" renvoie l'adresse à laquelle se trouve l'objet

Code:

---

type* ptr = &var

---

une référence c'est comme un pointeur mais c'est transparent pour le programmeur. tu continues de coder comme si tu manipulais l'objet lui-même

Code:

---

1 2 3 4 5

type & ref = var; ref.func(); // équivalent à var.func()   type * ptr = &var; ptr->func(); // équivalent à var.func(), notation différente

---

pour le reste, voir :faq: :D