C++ Std :: Umzug ist hier schlecht?

Question

Nehmen wir an, ich habe struct Foo mit Bewegung constructor und operator=(Foo&&), und ich benutzte es als Daten Mitglied:

Foo f() 
{ 
    Foo foo; 
    //code 
    return foo; 
} 
struct Boo { 
Foo foo; 
Boo() { 
    foo = f();//1 
    foo = std::move(f());//2 
} 
}; 

Bei (2) ich nicht wirklich std::move brauchen, aber was ist, wenn ich es benutzt hier macht dies etwas schlechtes, wie verhindern Optimierung?

Ich lese diese: Why does std::move prevent RVO?

und finden Sie heraus, dass return foo;-return std::move(foo); Ursache Sperrung des RVO ändern, aber was (2) es eine ähnliche Situation verursacht? Und wenn ja, warum?

Answer 1

Es ist redundant und verwirrend. Nur weil ich std::add_pointer_t<void> anstelle von void* schreiben kann, oder std::add_lvalue_reference_t<Foo> (oder Foo bitand) anstelle von Foo&, bedeutet das nicht, dass ich sollte.

Es kommt auch in anderen Zusammenhängen:

auto&& a = f(); // OK, reference binding to a temporary extends its lifetime 
auto&& b = std::move(f()); // dangling 

und so, wenn Foo ist etwas, das über laufen werden kann,

for(const auto& p : f()) {} // OK 
for(const auto& p : std::move(f())) {} // UB 

Und in Ihrem Beispiel, wenn der Zuweisungsoperator implementiert, wie copy-and-swap (operator=(Foo)), dann foo = std::move(f()) erzwingt eine nicht elimierbare Bewegung, während foo = f() kann die Bewegung von f() Rückgabewert an das Argument operator=.