question sur la surcharge d'opérateur ++

J'ai une question concernant la surdéfinition des opérateur pour les itérateurs.
Dans le code du header <iterator> de la STL, à la ligne 46, on a:

Code:

---

1 2 3 4 5 6 7 8 9

_Myt& operator++() { // pretend to preincrement return (*this); }   _Myt operator++(int) { // pretend to postincrement return (*this); }

---

Je ne comprends pas du tout le fonctionnement du deuxième opérateur. Surtout, a quoi correspond et sert le (int)? il s'agit d'une fonction, mais elle ne possède pas d'argument. Il y a juste la déclaration du type.

Enfin, pourquoi la préincrémentation renvoie une référence, alors que la posteincrémentation renvoie une valeur?



Merci

Bonjour,
En C et C++,il n'est pas obligatoire de nommer les arguments que l'on n'utilise(on doit juste donner leur type). L'argument int sert (au compilateur) à differencier post- et pre- incrementation. Enfin le renvoi d'une reference et d'une valeur est,ici, une question de sémantique : la préincremntation incremente l'objet et le renvoie, alors que la postincrementation incremente l'objet et renvoie une copie de l'objet avant l'incrementation. Par exemple:

Code:

---

1 2 3 4

int i = 0; ++(++i) // i == 2 (i++)++ // i == 3 equivalent de int tmp = i; i+=1; tmp++;

---

Mais là, vu que ce sont sans doute de faux iterateur(dans le sens ou ils n'itèrent) comme back_inserter, la difference n'est pas très visible.

oui, mais quand on fait quelque chose comme ceci:

Code:

---

1 2 3 4 5 6

std::vector<double> T; T.push_back(1);T.push_back(2);T.push_back(3);T.push_back(4); std::back_insert_iterator<std::vector<double>> p(T),q(T); p++; ++p;

---

on est d'accord que dans l'appel p++, on fait appel à la post-incrémentation.
En fait, cela revient à faire:

Code:

---

p.operator++();

---

Mais dans ce cas, comment faire la différence entre la post incrémentation, et la pré-incrémentation.

p.operator++() : préincrément
p.operator++(0) : postincrément

Citation:

---

Envoyé par deubelte

Mais dans ce cas, comment faire la différence entre la post incrémentation, et la pré-incrémentation.

---

que voulez-vous dire ?

Citation:

---

que voulez-vous dire ?

---

Vous avez répondu à ma question.

En fait, dans le meilleur des mondes, on aurait probablement :

Code:

---

1 2 3

T& ++operator(); T operator++();

---

Mais j'imagine que ça n'a pas été retenue par le comité car cela compliquerait horriblement le boulot des parseurs uniquement pour supporter le cas particulier de la préincrémentation.

Donc il a été choisi de différencier les deux opérateurs uniquement par la signature, avec aucun argument pour la préincrémentation et un int pour la postincrémentation.

Pour continuer sur les itérateurs, je voudrais savoir quelle est la différence entre ces deux opérateurs.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

_Myt& operator=(const _Valty& _Val) { // push value into container container->push_back(_Val); return (*this); }   _Myt& operator=(_Valty&& _Val) { // push value into container container->push_back(_STD forward<_Valty>(_Val)); return (*this); }

---

Dans quel cas on appelle le second?

Surtout, je pensais que les && (références sur références étaient illégales).
Alors je ne vois pas trop comment appeler une fonction qui a comme type de paramètres qqch comme &&.

Prenons une fonction tout simple:

Code:

---

1 2 3 4

int f(int &&a){ return a; }

---

Comment appeler cette fonction f?


Merci

Le second opérateur ( type & operator=(type &&) ) a été rajouté en C++11 (la nouvelle norme) et utilise ce que l'on appelle les rvalue reference.

Elles peuvent être utilisées dans le cas où il est préférable de recourir à la move semantic plutôt qu'à la copie de l'objet passé en paramètre.

Tu trouvera quelque informations sympa à ce sujet par exemple ici

Si tu regarde autour du code du deuxième opérateur que tu présente, tu devrais avoir un ifdef ou un if defined quelconque permettant de s'assurer que l'on travaille en C++11 ;)

j'ai récupéré cela de visual studio C++ 2010. Je pense que la version 2008 n'avait pas ce genre de code.


Mais sinon, comment appeler la fonction f (c'était ma dernière question).

Sauf erreur, le code

Code:

---

1 2	Type obj(/* paramètres */); foo(obj);

---

appellera la version prenant une référence constante alors que le code

Code:

---

foo(Type(/*paramètres */));

---

appellera la version prenant une rvalue reference... Mais c'est à vérifier ;) (il me semble que les rvalue references et la move semantic ont déjà été abordées sur le forum... mais il faudra chercher ou :P)

Citation:

---

Envoyé par koala01

Sauf erreur, le code

Code:

---

1 2	Type obj(/* paramètres */); foo(obj);

---

appellera la version prenant une référence constante alors que le code

Code:

---

foo(Type(/*paramètres */));

---

appellera la version prenant une rvalue reference... Mais c'est à vérifier ;) (il me semble que les rvalue references et la move semantic ont déjà été abordées sur le forum... mais il faudra chercher ou :P)

---

Dans les deux, c'est la fonction prenant la r-value reference qui est appelée.
Pour s'en rappeler, il suffit de se dire que r-value reference = variable anonyme.

Si je ne me trompe pas, dans le premier cas la variable n'est pas anonyme(ou alors je n'ai rien compris à l'anonymat ?)

Oui Joe, le premier code :

Code:

---

1 2	Type obj(/* paramètres */); foo(obj);

---

appelle la version par const ref, car on passe à foo() une l-value, c'est à dire une variable nommée (son nom est "obj") dont on peut prendre l'adresse.
Le deuxième code :

Code:

---

foo(Type(/*paramètres */));

---

appelle la version par ref ref, car on passe à foo() une r-value, c'est une dire une variable anonyme, temporaire, dont on ne peut pas prendre l'adresse.

Citation:

---

Envoyé par Arzar

Oui Joe, le premier code :

Code:

---

1 2	Type obj(/* paramètres */); foo(obj);

---

appelle la version par const ref, car on passe à foo() une l-value, c'est à dire une variable nommée (son nom est "obj") dont on peut prendre l'adresse.
Le deuxième code :

Code:

---

foo(Type(/*paramètres */));

---

appelle la version par ref ref, car on passe à foo() une r-value, c'est une dire une variable anonyme, temporaire, dont on ne peut pas prendre l'adresse.

---

OMG, j'ai lu trop vite, j'ai cru que obj était une fonction renvoyant un objet du type Type. Dans ce cas, mes posts sont à supprimer ^^