Passage de std::pair en paramètre fail !

Bonjour,

encore une énigme comme le c++ en a le secret !

Suivant que je construise une pair (avec make_pair) dans une fonction ou au moment de la passer en paramètre, je n'ai pas la même chose !

Voilà un petit code minimaliste de démonstration :

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

#include <iostream> using namespace std ;   struct foo { foo ( int xx ) { x = xx ; y = xx+1 ; }   pair<const foo&,int> more () const { return make_pair<const foo&,int>( *this,7 ) ; }   int x,y ; };   ostream & operator<< ( ostream & o , std::pair<const foo&,int> p ) { o << p.first.x << "," << p.first.y << " + " << p.second ; return o ; }   int main () { foo f ( 123 ) ; cout << make_pair<const foo&,int>( f,11 ) << endl ; // affiche bien 123,124 + 11 cout << f.more() << endl ; // affiche n'importe quoi ! (ex : 1231321,6543213 + 7) return 0 ; }

---

Ça ressemble au bug du débutant qui renvoie une référence sur un objet de la pile, mais en toute logique non !
Et si c'est bien ça, comment faire ?

Merci d'avance

PS : Je compile sous Visual Studio 2010... au cas où il faille suspecter quelque lacune d'implémentation des stl.

Hello,

La seule façon de stocker une référence dans un conteneur (vector / pair / etc...) c'est de passer par std::reference_wrapper (ou équivalent).
Tu fais actuellement une copie dans ta fonction more.

Code:

---

1 2 3 4

pair<reference_wrapper<const foo>,int> more () const { return make_pair(reference_wrapper<const foo>(*this), 7) ; }

---

edit : Maintenant, j'aimerai savoir ce qu'il se passe exactement parce que je comprend pas tout. :aie:

Code:

---

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

pair<const foo&,int> more () const { pair<const foo&,int> a = make_pair(*this, 7); pair<const foo&,int> b = a; // pourquoi a et b sont valide ici ? return b; } int main () { foo f ( 123 ) ; // mais p invalide ici ? pair<const foo&,int> p = f.more(); }

---

Pour moi, a et b devraient être invalides, ou si a et b sont valides, p devrait l'être aussi.

Voila ce qu'il se passe (en reprenant l'exemple d'Iradrille) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

pair<const foo&,int> more () const { pair<const foo&,int> a = make_pair(*this, 7); // (1) make_pair copie *this (voir référence ci-dessous) // (2) a.first est une référence vers un objet local de make_pair, comme tout accès invalides à des références, ça peut planter ou pas... return a; } int main () { foo f ( 123 ) ; pair<const foo&,int> p = f.more(); // (3) p est toujours invalide vu que c'était déjà invalide en (2) }

---

ref make_pair : http://en.cppreference.com/w/cpp/utility/pair/make_pair

note qu'en utilisant le constructeur de std::pair, il ne doit pas y avoir de problème. Après je ne le conseillerais pas...

Si je comprend bien, une copie de l'objet est passée à std::make_pair, et une pair temporaire est créée (de type std::pair<foo, int>). Puis le constructeur par copie de pair prend une ref sur la copie de l'objet pour créer la pair "a", et enfin la paire temporaire est détruite.
Et donc la ref pointe sur un objet détruit, mais toujours présent sur la pile tant qu'on écrit pas par dessus. (-> d'ou a et b "valides")

Je savais qu'il fallait passer par std::ref / std::refence_wrapper, maintenant je saurai pourquoi. Merci :)

Citation:

---

Envoyé par Iradrille

Si je comprend bien, une copie de l'objet est passée à std::make_pair, et une pair temporaire est créée (de type std::pair<foo, int>).

---

Une paire temporaire n'est pas forcément créée, le point important est qu'on assigne une copie de l'objet (qui est local à la fonction make_pair) à pair.first de type const&, par conséquent la référence pointera sur un objet local à make_pair.