Déplacer le nom ou la Valeur de Retour d'Optimisation (NRVO)?

Permet de dire que nous avons le code suivant:

std::vector<int> f()
{
  std::vector<int> y;
  ...
  return y;
} 

std::vector<int> x = ...
x = f();

Il semble que le compilateur a deux approches:

(a) NRVO: la Destruction des x, puis de construire f() à la place de x.

(b) se Déplacer: la Construction f() dans la temp de l'espace, déplacez f() dans x, détruire f().

Est le compilateur libre d'utiliser l'une ou l'autre approche, conformément à la norme?

  • (a) n'est pas autorisé. Hormis le fait que l'opérateur d'affectation doit être appelé, il aurait le mauvais comportement lors d'une partie de la ... dans f déclenche une exception. x ne doit pas être modifié dans ce cas, donc si ça a déjà été détruite, c'est un problème.
  • C'est un problème avec vague des questions. J'ai pensé qu'il ne voulait pas dire ce qu'il a littéralement écrit. Apparemment certaines personnes à d'autres pensaient de même.
InformationsquelleAutor Clinton | 2011-06-04
  1. 37

    Le compilateur peut NRVO dans un temp de l'espace, ou de déplacer construire en un temp de l'espace. À partir de là, il va se déplacer attribuer x.

    Mise à jour:

    Toutes les fois que vous êtes tenté d'optimisation avec des références rvalue, et vous n'êtes pas positif des résultats, créez vous-même un exemple de classe qui assure le suivi de son état:

    • construit
    • par défaut construit
    • déplacé de
    • détruits

    Et exécuter cette classe par le biais de votre test. Par exemple:

    #include <iostream>
#include <cassert>
class A
{
int state_;
public:
enum {destructed = -2, moved_from, default_constructed};
A() : state_(default_constructed) {}
A(const A& a) : state_(a.state_) {}
A& operator=(const A& a) {state_ = a.state_; return *this;}
A(A&& a) : state_(a.state_) {a.state_ = moved_from;}
A& operator=(A&& a)
{state_ = a.state_; a.state_ = moved_from; return *this;}
~A() {state_ = destructed;}
explicit A(int s) : state_(s) {assert(state_ > default_constructed);}
friend
std::ostream&
operator<<(std::ostream& os, const A& a)
{
switch (a.state_)
{
case A::destructed:
os << "A is destructed\n";
break;
case A::moved_from:
os << "A is moved from\n";
break;
case A::default_constructed:
os << "A is default constructed\n";
break;
default:
os << "A = " << a.state_ << '\n';
break;
}
return os;
}
friend bool operator==(const A& x, const A& y)
{return x.state_ == y.state_;}
friend bool operator<(const A& x, const A& y)
{return x.state_ < y.state_;}
};
A&& f()
{
A y;
return std::move(y);
}
int main()
{
A a = f();
std::cout << a;
}

    Si cela peut aider, mettre imprimer des relevés dans les membres qui vous intéressent (par exemple, une copie constructeur, constructeur de déplacement, etc.).

    Btw, si cette segmentation sur vous, ne vous inquiétez pas. Il segmentation pour moi aussi. Ainsi, cette conception particulière (de retour d'une rvalue référence à une variable locale) n'est pas une bonne conception. Sur votre système, au lieu de segfaulting, il peut imprimer "Une est détruite". Ce serait un signe de plus que vous ne voulez pas le faire.

    • J'ai volontairement utilisé le cas des OP de la terminologie dans ma réponse. La norme s'efforce d'être précis, mais est moche tutoriel. Je n'ai pas (et toujours pas) de reconnaître que j'ai été vague. Bien sûr, ceci est une commune de la faute à qui, je ne suis pas à l'abri. Je serai heureux de clarifier si je savais que les parties de ma réponse ambiguë. Mon objectif est de diffuser les connaissances, de ne pas faire de confusion.
    InformationsquelleAutor Howard Hinnant