c++11 Optimisation ou déplacement de la valeur de retour ?

Question

Je ne comprends pas quand je dois utiliser std::move et quand je dois laisser le compilateur optimiser... par exemple :

using SerialBuffer = vector< unsigned char >;

// let compiler optimize it
SerialBuffer read( size_t size ) const
{
    SerialBuffer buffer( size );
    read( begin( buffer ), end( buffer ) );
    // Return Value Optimization
    return buffer;
}

// explicit move
SerialBuffer read( size_t size ) const
{
    SerialBuffer buffer( size );
    read( begin( buffer ), end( buffer ) );
    return move( buffer );
}

Lequel dois-je utiliser ?

Answer 1

Utilisez exclusivement la première méthode :

Foo f()
{
  Foo result;
  mangle(result);
  return result;
}

Cela permettra déjà permettre l'utilisation du constructeur de déplacement, s'il en existe un. En fait, une variable locale peut se lier à une référence rvalue dans une fonction return précisément quand l'élision de copie est autorisée.

Votre deuxième version interdit activement l'élision de la copie. La première version est universellement meilleure.

Answer 2

Toutes les valeurs de retour sont soit déjà moved ou optimisé, il n'est donc pas nécessaire de se déplacer explicitement avec les valeurs de retour.

Les compilateurs sont autorisés à déplacer automatiquement la valeur de retour (pour optimiser la copie), et même à optimiser le déplacement !

Section 12.8 du projet de norme n3337 (C++11) :

Lorsque certains critères sont remplis, une implémentation est autorisée à omettre la construction de copie/déplacement d'un objet de classe, même si la construction de copie/déplacement et/ou le destructeur de l'objet ont des effets secondaires. Dans Dans de tels cas, l'implémentation traite la source et la cible de l'objet de classe comme des effets secondaires. l'opération de copier/déplacer omise comme étant simplement deux façons différentes de se référer à au même objet, et la destruction de cet objet se produit à la dernière destruction de cet objet a lieu au dernier moment où les deux objets auraient été détruits sans l'optimisation. Cette élision des opérations de copie/déplacement, appelée élision de la copie est autorisé dans les circonstances suivantes (qui peuvent être combinés pour éliminer les copies multiples) :

[...]

Ejemplo :

class Thing {
public:
Thing();
   ~Thing();
   Thing(const Thing&);
};

Thing f() {
   Thing t;
   return t;
}

Thing t2 = f();

Ici, les critères d'élision peuvent être combinés pour éliminer deux appels au constructeur de copie de la classe Thing : la copie de l'objet automatique local t dans l'objet temporaire pour la valeur de retour de la fonction f() et la copie de cet objet temporaire dans l'objet t2 . En effet, la construction de l'objet local t peut être vu comme initialisant directement l'objet global t2 et la destruction de cet objet aura lieu au moment du programme du programme. L'ajout d'un constructeur de déplacement à Thing a le même effet, mais il s'agit de la construction du mouvement à partir de l'élément objet temporaire vers t2 qui est élidée. - exemple de fin ]

Lorsque les critères d'exclusion d'une opération de copie sont remplis ou le seraient si ce n'était que la source est un paramètre de fonction, et que l'objet à copier est désigné par une lvalue, la résolution de surcharge pour sélectionner le constructeur de la copie est d'abord effectuée comme si l'objet était désigné par une rvalue. pour sélectionner le constructeur de la copie est d'abord effectuée comme si l'objet était désigné par une rvalue. Si la résolution de surcharge échoue, ou si le type du premier paramètre du constructeur sélectionné n'est pas une référence rvalue à la fonction référence rvalue au type de l'objet (éventuellement qualifiée cv), la résolution de surcharge est à nouveau effectuée, en considérant l'objet comme une lvalue. lvalue.

Answer 3

C'est très simple.

return buffer;

Si vous faites cela, alors soit la NRVO se produira, soit elle ne se produira pas. Si elle ne se produit pas, alors buffer sera déplacé.

return std::move( buffer );

Si vous faites cela, alors NVRO ne sera pas se produisent, et buffer sera déplacée.

Il n'y a donc rien à gagner à utiliser std::move ici, et beaucoup à perdre.

---

Il y a une exception* à la règle ci-dessus :

Buffer read(Buffer&& buffer) {
    //...
    return std::move( buffer );
}

Si buffer est une référence rvalue, alors vous devriez utiliser std::move . Cela s'explique par le fait que les références ne sont pas éligibles pour le NRVO, donc sans std::move il en résulterait une copie à partir d'une lvalue.

Il s'agit juste d'un exemple de la règle "toujours move Références aux valeurs r et forward références universelles", qui prévaut sur la règle règle "ne jamais move une valeur de retour".

* À partir de C++20, cette exception peut être oubliée. Les références Rvalue dans return Les déclarations sont implicitement déplacées, maintenant.

Answer 4

Si vous retournez une variable locale, n'utilisez pas move() . Cela permettra au compilateur d'utiliser NRVO, et à défaut, le compilateur sera toujours autorisé à effectuer un déplacement (les variables locales deviennent des valeurs R au sein d'une return ). Utilisation de move() dans ce contexte inhiberait simplement NRVO et forcerait le compilateur à utiliser un déplacement (ou une copie si le déplacement n'est pas disponible). Si vous retournez quelque chose d'autre qu'une variable locale, NRVO n'est de toute façon pas une option et vous devriez utiliser la fonction move() si (et seulement si) vous avez l'intention de chaparder l'objet.