Discussion :

[Florian Goo]

Bonjour à tous,

La situation est très simple : j'ai un objet que je souhaite non-copiable, comment faire pour faire retourner un tel objet par une fonction ?
Évidemment, je souhaite que cet objet soit alloué sur la pile, sinon ce serait trop simple

Dans la pratique, pour peu que le compilateur utilise la NRVO, il ne se produit aucune opération de copie. Comment expliciter ce mécanisme ?

Je pensais à un truc comme ça :

Code :

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

1
2
3
 
void
function(a_class& object_to_be_returned);

mais c'est un peu moche et pas très expressif. En tout cas j'ai jamais rien vu de tel dans Boost (par exemple).

Si vous avez une idée à base de rvalue references (ou toute autre nouveauté C++0x), je suis également preneur .

[Luc Hermitte]

Si tu peux rendre ton objet déplaçable, mais non copiable, alors effectivement, les rvalue references me paraissent être la solution.
Ne connaissant pas encore la syntaxe exacte, je laisse à d'autres le soin de la fournir.

Sinon, il te faudra allouer par défaut ton objet dans un état valide, mais non exploitable, dans le code appelant et la passer en référence à la fonction qui va alors le modifier.

Sinon, il te reste la sémantique bâtarde du COW, et autres auto_ptr<> (qui vont impliquer une allocation sur le tas)

[nikko34]

ben j'utilise ça tout le temps si je ne veux pas de copie. Genre pour remplir un vector.

[Florian Goo]

Si tu peux rendre ton objet déplaçable, mais non copiable, alors effectivement, les rvalue references me paraissent être la solution.
Ne connaissant pas encore la syntaxe exacte, je laisse à d'autres le soin de la fournir.

Justement, j'ai lu plein de fois « il parait que c'est possible », mais je n'ai jamais vu le code qui était censé le faire

Sinon, il te faudra allouer par défaut ton objet dans un état valide, mais non exploitable, dans le code appelant et la passer en référence à la fonction qui va alors le modifier.

Sinon, il te reste la sémantique bâtarde du COW, et autres auto_ptr<> (qui vont impliquer une allocation sur le tas)

Pour ces solutions là, ce qui m'embête c'est que j'aimerais avoir une syntaxe expressive et intuitive (donc pas bâtarde). C'est que ces fameuses fonctions feront partie de l'API de ma lib…
EDIT : D'autant plus qu'auto_ptr est déprécié dans C++0x.


Pour l'instant, je vais creuser encore un peu la piste rvalue reference.

[Arzar]

Si vous avez une idée à base de rvalue references (ou toute autre nouveauté C++0x), je suis également preneur .

Alors là, je suis perplexe. Il y a quelques temps dans le thread sur les rvalue reference c'est toi-même, florian qui avait posté une des réponses les plus pertinentes sur ce sujet

Donc, oui, avec les rvalue reference c'est assez simple, il faut rajouter un constructeur par déplacement et un opérateur d'affectation par déplacement (faudrait vraiment qu'on est une traduction "officielle" un jour ).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class NonCopyable
{
    public:
   NonCopyable(){cout << "Default Constructor\n";}
   ~NonCopyable(){cout << "Destructor\n";}
   NonCopyable(const NonCopyable& ) = delete;
   NonCopyable& operator=(const NonCopyable& ) =  delete;
   NonCopyable(NonCopyable&&){cout << "Move Constructor\n";}
   NonCopyable& operator=(NonCopyable&&){ cout << "Move assignment\n"; return *this;}
};
 
NonCopyable foo()
{
    NonCopyable localncp; // alloué dans la pile
    return localncp;
}
 
int main()
{
    NonCopyable ncp = foo();
    return 0;
}

Affichage avec NRVO :
DefaultConstructor

Affichage sans NRVO
Default Constructor (création de localncp dans la pile de foo())
Move Constructor (création du temporaire retourné par foo(), par déplacement de localncp)
Destructor (destruction de localncp en sortant de foo())
Move Constructor (creation de ncp dans main() par déplacement du temporaire)
Destructor (destruction du temporaire)
Destructor (destruction de ncp, en sortant du main())

[Luc Hermitte]

Ce ne sera pas plutôt

Code :

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

1
2
3
4
5
NonCopyable && foo()
{
    NonCopyable localncp; // alloué dans la pile
    return std::move(localncp);
}

la syntaxe ?

Après je n'ai pas suivi l'affaire au sujet du RVO/NRVO au milieu de tout ça.

[Arzar]

Justement non !
J'ai fait exactement la même erreur en essayant la première fois. Pour comprendre d'où vient le problème il faut en fait désactiver la NRVO et détailler ce qui se passe dans le cas normal.

Avec un objet classique copiable, le retour d'une fonction se fait comme suit:
(1) création de localcp
(2) création d'un Copyable temporaire par copie qui va faire le lien entre foo() et main()
(3) on sort de la portée de foo(), le destructeur de localcp est appelé.
(4) création de cp par copie du temporaire.
(5) Le destructeur du temporaire est appelé.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Copyalbe foo()
{
  Copyable localcp; // (1)
  return localcp; // (2)
} // (3)
 
int main()
{
   Copyable cp = foo(); (4)
  ; // (5)
}

Affichage NRVO
Default constructor // une seule construction. L'optimisation a fait complètement sauter le temporaire.

Affichage sans NRVO
Default Constructor
Copy Constructor // (2)
Destructor // (3)
Copy Constructor // (4)
Destructor // (5)

Et si l'on décortique le code faux, avec le move:
(1) création de localncp
(2) c'est ici l'erreur. move(localncp) convertit localncp en rvalue reference, c'est à dire en temporaire et donc le return ne va pas créer de temporaire car il considère que localcp en est déjà un.
EDIT: Correction, l'erreur ne vient pas du move mais du type de retour NonCopyable&&. C'est à cause de lui qu'il n'y a pas création de temporaire.
(3) localncp est détruit en sortant de la portée comme d'habitude.
(4) boom.

Code :

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

1
2
3
4
5
6
7
8
9
10
NonCopyable&& foo()
{
  NonCopyable localncp; // (1)
  return move(localncp); // (2)
} // (3)
 
int main()
{
   NonCopyable ncp = foo(); // (4)
}

[Florian Goo]

Alors là, je suis perplexe. Il y a quelques temps dans le thread sur les rvalue reference c'est toi-même, florian qui avait posté une des réponses les plus pertinentes sur ce sujet

Ouais, je me souviens de ce topic, mais là pour le coup ça m'aurait arrangé qu'on me contredise, que quelqu'un me sorte une solution tout droit sortie d'un chapeau magique .

C'est tout de même une limitation du langage assez gênante que voici .

[Arzar]

Quelle limitation ? Je ne comprends pas. L'ajout d'un move constructeur comme décrit plus haut semble être une réponse élégante au problème initial non ?

J'ai un objet que je souhaite non-copiable, comment faire pour faire retourner un tel objet par une fonction ?
Évidemment, je souhaite que cet objet soit alloué sur la pile, sinon ce serait trop simple

[Florian Goo]

Toutes mes excuses, j'avais lu ton post tellement vite que je suis complètement passé à côté de son contenu

Malgré mon apparente maitrise du sujet, je n'avais absolument pas saisi le principe du move constructor qui intervient à la place du copy constructor lorsque ce dernier est delete (ou private) dans le contexte d'un retour de fonction.

Effectivement, c'est en effet très bien fichu
Je viens de tester et ça m'a l'air de fonctionner à merveille.

Merci de mettre ça sur le compte de la fatigue

Merci beaucoup

[loufoque]

Les astuces d'émulation de sémantiques de mouvement en C++03 se basent d'ailleurs sur la NRVO.
Voir Boost.Move.

[Trunks]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
class NonCopyable
{
    public:
   NonCopyable(){cout << "Default Constructor\n";}
   ~NonCopyable(){cout << "Destructor\n";}
   NonCopyable(const NonCopyable& ) = delete;
   NonCopyable& operator=(const NonCopyable& ) =  delete;
   NonCopyable(NonCopyable&&){cout << "Move Constructor\n";}
   NonCopyable& operator=(NonCopyable&&){ cout << "Move assignment\n"; return *this;}
};
 
NonCopyable foo()
{
    NonCopyable localncp; // alloué dans la pile
    return localncp;
}
 
int main()
{
    NonCopyable ncp = foo();
    return 0;
}

C'est du C++0x je suppose, je n'ai jamais vu cette synthaxe

Code :

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

 = delete

[Florian Goo]

Tout à fait !