Discussion :

[deubelte]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[deubelte]

oui, mais quand on fait quelque chose comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

p.operator++();

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

[bruno_pages]

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

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

que voulez-vous dire ?

[deubelte]

que voulez-vous dire ?

Vous avez répondu à ma question.

[Arzar]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[deubelte]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
int f(int &&a){
return a;
}

Comment appeler cette fonction f?


Merci

[koala01]

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

[deubelte]

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).

[koala01]

Sauf erreur, le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 )

[Davidbrcz]

Sauf erreur, le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 )

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.

[Invité]

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 ?)

[Arzar]

Oui Joe, le premier code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Davidbrcz]

Oui Joe, le premier code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ^^