Automatische xValue Optimierung

Question

Etwas überraschend (für mich), die folgenden zwei Programme zu unterschiedlichen Ausgängen kompilieren, wobei letztere eine viel bessere Leistung aufweisen (mit gcc und Klirren getestet):

#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); 
    } 
} 

Könnte mir jemand erklären, warum der Compiler tut (oder können) nicht automatisch b ein xValue in der letzten Zuweisung betrachten und zu bewegen Semantik ohne ausdrückliche std::move Guss anwenden?

bearbeiten: Zusammengestellt mit (g++|clang++) -std=c++11 -O3 -o test test.cpp

Answer 1

Compilers can't break the as-if rule

Als §1.9/1 heißt es:

Die semantischen Beschreibungen in dieser Internationalen Norm eine parametrisierte nondeterministic abstrakte Maschine definieren. Dieser internationale Standard stellt keine Anforderung an die Struktur von übereinstimmenden Implementierungen. Insbesondere müssen sie die Struktur der abstrakten Maschine nicht kopieren oder emulieren. Vielmehr sind konforme Implementierungen erforderlich (nur) das beobachtbare Verhalten der abstrakten Maschine zu emulieren, wie unten

erklärt

heißt ein Compiler kann nicht das beobachtbare Verhalten des Programms ändern. Die Konvertierung einer Zuweisung in eine Zugzuweisung würde diese Anweisung automatisch (auch ohne Rückwirkungen) brechen.

Kopierfehler können dieses Verhalten leicht ändern, aber dies wird durch §12.8/31 geregelt.

Wenn Sie die move-Version verwenden möchten, müssen Sie wie im letzten Beispiel explizit danach fragen.

Answer 2

die bei der nächsten Probe Werfen wir einen Blick (ignorieren Sie bitte void Rückgabetyp von 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(); 
} 

Das operator= anderes Verhalten hat auf seine Argumente abhängig. Der Compiler darf den Code nur dann optimieren, wenn er das beobachtbare Verhalten gleich halten kann.

Anbetracht b von fun ein xvalue, während es keine xvalue im Moment des Anrufs ist, wird es das beobachtbare Verhalten des Programms ändern und dies wird nicht noch von der Norm erlaubt gewünscht.