Pourquoi utiliser un iterator sur des containers ?

Salut à tous, je me pose une petite question depuis quelques temps, pourquoi utiliser des iterators pour itérer sur des containers ?

Admettons qu'on ait ce vector:

Code:

---

1 2 3

vector<int> myvector; myvector.resize(10); fill (myvector.begin(),myvector.end(),5);

---

Pour itérer je fais toujours ça:

Code:

---

1 2 3

for(int i = 0; i < (int) myvector.size(); i++) { cout << myvector.at(i) << endl; }

---

En quoi est-ce mieux de faire ça ?

Code:

---

1 2	for (vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it) cout << " " << *it;

---

Je trouve ça beaucoup plus contraignant à écrire ^^

Pouvez-vous m'éclairer ? Merci d'avance :)

Salut

Dans ton exemple ça a l'air plus contraignant, parce que tu n'utilises qu'une seule fois "it", mais si tu l'utilises plusieurs fois, comme quelques dizaines de fois ? De plus, tu dis que ça paraît contraignant car ton for est "lourd", mais tu peux l'alléger avec un typedef sur" vector<int>::iterator" par exemple.

L'avantage de l'itérateur est que son fonctionnement est unifié entre différents containers, mais aussi que tu t'abstrais de la structure en tableau. En utilisant l'indice, tu utilises malgré toi une information structurelle supplémentaire.

Enfin, je pense qu'il doit aussi y avoir une histoire de perfo, mais je vais laisser les vrais spécialistes répondre.

Ok, merci du renseignement =)

Il doit me manquer certaines notions, car dans certains cas je n'arrive pas à utiliser d'iterator.
Par exemple:

Code:

---

1 2 3 4 5 6

template<typename T> static void display(vector<T> myVector) { vector<T>::const_iterator it; // ne compile pas for(it = myVector.begin(); it != myVector.end(); it++) cout << *it << endl; }

---

Je suis obligé d'utiliser:

Code:

---

1 2 3 4 5 6 7 8 9 10

template<typename T> static void display(vector<T> myVector) { try { for(int i = 0; i < (int) myVector.size(); i++) cout << myVector.at(i) << endl; } catch(exception &e) { cout << "you didn't pass a valid vector in parameter" << endl; cout << e.what() << endl; } }

---

J'ai essayé de faire comme dans cet exemple:

Code:

---

1 2 3 4 5

template <typename T> void ecrire(const std::vector<int> & v){ typename std::vector<T>::const_iterator vit(v.begin(),vend(v.end()); for(;vit!=vend;++vit) std::cout << *vit << ' '; }

---

Mais mon compilateur me dit qu'il ne connaît pas la méthode "vend"

Salut,

Effectivement, l'énorme avantage des itérateurs est qu'ils présentent une interface unifiée, quelle que soit la collection réellement utilisée.

L'opérateur [] n'est en effet utilisable que pour le std::vector (et pour la std::map, que j'ai en horreur, à cause de son mode de fonctionnement :P)

Par contre, le problème auquel tu es confronté avec le code que tu présente:

Code:

---

1 2 3 4 5 6

template<typename T> static void display(vector<T> myVector) { vector<T>::const_iterator it; // ne compile pas for(it = myVector.begin(); it != myVector.end(); it++) cout << *it << endl; }

---

c'est que tu travailles avec une fonction template.

Le fait est que le langage n'arrive pas à déduire le type de std::vector<T>::const_iterator.

Pour résoudre ce problème, il faut "simplement" préciser que tu sais que std::vector<T>::const_iterator représente bel et bien un type, et que le compilateur peut donc te faire confiance.

Il "suffit" donc de modifier la fonction pour qu'elle prenne la forme de

Code:

---

1 2 3 4 5 6

template<typename T> static void display(vector<T> myVector) { typename vector<T>::const_iterator it; // ne compile pas for(it = myVector.begin(); it != myVector.end(); it++) cout << *it << endl; }

---

C'est fou, comme la présence d'un seul mot peut changer les choses, non ?

Merci de ta réponse :)

Pour le code, le typename signifie au compilateur qu'il doit me faire confiance ?

Ou il ya autre chose que je ne vois pas ?^^

Citation:

---

Envoyé par scheme

Merci de ta réponse :)

Pour le code, le typename signifie au compilateur qu'il doit me faire confiance ?

Ou il ya autre chose que je ne vois pas ?^^

---

C'est à vrai dire un peu plus complexe que cela, et je l'avais dit plus par "joke".

En fait, il faut, effectivement, préciser que const_iterator est un type qui est déclaré dans la classe std::vector (dans ton exemple).

Et c'est le rôle du mot clé typename ;)

Mais, si tu veux savoir quelles sont les raisons pour lesquelles la présence de ce mot clé est nécessaire à cet endroit, il faudra attendre un peu ;)

Ok, merci de ces précisions :ccool:

En fait le typename définit un type, donc it sera bien de type vector<T>::const_iterator, et T sera remplacé à l'éxécution :P

Je suis presque fier d'avoir compris^^

Merci à vous de m'avoir donné vos précieux conseils ;)

Il me paraît utile de dire simplement que le mot clé typename sert à lever une ambiguité. En effet, si tu lis ceci :

Code:

---

vector<T>::const_iterator

---

const_iterator peut être un type mais aussi un membre statiques de la classe vector<T>. En ajoutant typename, tu dis au compilo "t'inquiète mon pote, c'est bien un type et non un membre". En revanche, tu ne définis pas le type, c'est bien vector<T> qui le définit.

Voir ici.

Les itérateurs permettent comme cela été dit une approche + générique. Et même on peut carrément penser en terme de Range (couple it début/it fin).

En reprenant ta fonction :

Code:

---

1 2 3 4 5

template<typename iterator_t_> static void display(iterator_t_ debut_, iterator_t_ fin_) { for(; debut_ != fin_; ++debut_) cout << *it << endl; }

---

fonctionne pour autre chose que des vecteurs.

Et en allant plus loin pas besoin de display car la STL propose des iterateurs pour les flux :

Code:

---

std::copy(my_bag.begin(),my_bag.end(),std::ostream_iterator<TYPE>(std::cout,"\n"));

---