Automatyczne xvalue optymalizacja

Question

Nieco zaskakująco (do mnie), następujące dwa programy kompilować do różnych wyjść, z tym drugim związkiem mającym znacznie lepsze osiągi (testowane z gcc i brzękiem):

#include <vector> 
int main() 
{ 
    std::vector<int> a(2<<20); 
    for(std::size_t i = 0; i != 1000; ++i) { 
     std::vector<int> b(2<<20); 
     a = b; 
    } 
} 

vs.

#include <vector> 
int main() 
{ 
    std::vector<int> a(2<<20); 
    for(std::size_t i = 0; i != 1000; ++i) { 
     std::vector<int> b(2<<20); 
     a = std::move(b); 
    } 
} 

Czy ktoś mógłby mi wyjaśnić, dlaczego kompilator robi (lub nie może) automatycznie rozważyć b xvalue w ostatnim zadaniu i zastosować semantykę ruchu bez jawnego rzutowania std::move?

Edit: Zestawione z (g++|clang++) -std=c++11 -O3 -o test test.cpp

Answer 1

Compilers can't break the as-if rule

Jako §1.9/1 stanowi:

semantyczne opisy w niniejszej normie międzynarodowej zdefiniować parametryczne niedeterministycznych abstrakcyjnej maszyny. Ten międzynarodowy standard nie nakłada wymagań na strukturę zgodnych implementacji. W szczególności nie muszą kopiować ani emulować struktury abstrakcyjnej maszyny. Przeciwnie, zgodne implementacje muszą współzawodniczyć (tylko) zaobserwowania zachowania abstrakcyjnej urządzenia jak opisano poniżej

to kompilator nie może zmienić zaobserwowania zachowania programu. Automatycznie (nawet bez żadnych reperkusji) konwersja przypisania do przypisania przeniesienia przerwałaby to stwierdzenie.

Kopiowanie elekcje może nieznacznie zmienić to zachowanie, ale jest to regulowane przez § 12.8/31.

Jeśli chcesz użyć wersji przeniesienia, musisz jawnie poprosić o nią, tak jak w tym ostatnim przykładzie.

Answer 2

Spójrzmy na kolejnej próbki (proszę ignorować void typ zwracany z operator=):

#include <iostream> 

struct helper 
{ 
    void operator=(helper&&){std::cout<<"move"<<std::endl;} 
    void operator=(const helper&){std::cout<<"copy"<<std::endl;} 
}; 

void fun() 
{ 
    helper a; 
    { 
     helper b; 
     a = b; 
    } 
} 

void gun() 
{ 
    helper a; 
    { 
     helper b; 
     a = std::move(b); 
    } 
} 
int main() 
{ 
    fun(); 
    gun(); 
} 

operator= ma różne zachowanie w zależności od jego argumentów. Kompilator może zoptymalizować kod tylko wtedy, gdy jest w stanie utrzymać obserwowalne zachowanie tak samo.

Zważywszy b z funxvalue, podczas gdy nie jest to xvalue w momencie wywołania Spowoduje to zmianę zaobserwowania zachowanie programu, a to nie jest pożądane ani dopuszczone przez standard.