¿Por qué copiar elision no funciona con std :: move?

Question

uso el código de abajo a prueba de copia elisión:

class foo 
{ 
public: 
    foo() {cout<<"ctor"<<endl;}; 
    foo(const foo &rhs) {cout<<"copy ctor"<<endl;} 
}; 

int g(foo a) 
{ 
    return 0; 
} 

int main() 
{ 
    foo a; 
    g(std::move(a)); 
    return 0; 
} 

que esperaba sólo el constructor por defecto sería llamado porque el argumento de g() es un valor de lado derecho y de la copia se elide. Pero el resultado muestra que se llama tanto al constructor predeterminado como al constructor de copia. ¿Por qué?

Y si cambio la función llame al g(foo()), la copia será eliminada. ¿Cuál es la diferencia entre los tipos de devolución de foo() y std::move(a)? ¿Cómo puedo hacer que el compilador elite copie en un lvalue?

Answer 1

La elisión de copia para solo puede ocurrir en algunas situaciones específicas, la más común de las cuales es la copia de un temporal (los otros son locales que regresan y excepciones de lanzamiento/captura). Su código no produce ningún elemento temporal, por lo que no se elimina ninguna copia.

El constructor de copia está siendo llamado porque foo no tiene un constructor movimiento (constructores movimiento no se generan de forma implícita para las clases con constructores de copia explícitas), y así std::move(a) coincide con el foo(const foo &rhs) constructor (que se utiliza para construir el argumento de la función) .

Una copia de un valor-I se puede elided en las siguientes situaciones (aunque no hay manera de fuerza un compilador para realizar la elisión):

foo fn() { 
    foo localAutomaticVariable; 
    return localAutomaticVariable; //Copy to construct return value may be elided 
} 

int main() { 
    try { 
     foo localVariable; 
     throw localVariable; //The copy to construct the exception may be elided 
    } 
    catch(...) {} 
} 

Si se quiere evitar copias al pasar a la función argumentos, se puede utilizar un constructor de movimiento que hurta los recursos de los objetos dados a ella:

class bar { 
public: 
    bar() {cout<<"ctor"<<endl;}; 
    bar(const bar &rhs) {cout<<"copy ctor"<<endl;} 
    bar(bar &&rhs) {cout<<"move ctor"<<endl;} 
}; 

void fn(bar a) 
{ 
} 
//Prints: 
//"ctor" 
//"move ctor" 
int main() 
{ 
    bar b; 
    f(std::move(b)); 
} 

Además, cada vez que se permite la copia elisión, pero no se produce, se utiliza el movimiento del constructor si es disp le.

Answer 2

tiene que declarar como g:

int g(foo && a) //accept argument as rvalue reference 
{ 
    return 0; 
} 

Ahora se puede aceptar el argumento por valor p-referencia.

En su caso, aunque la expresión std::move(a) produce rvalue, no se enlaza a un parámetro que acepta el argumento por el valor. El extremo receptor debe ser rvalue-reference también.

En el caso de g(foo()), el compilador realiza la copia-elisión, que es una optimización. NO es un requisito por el idioma^{[until C++17]}. Puede deshabilitar esta optimización si lo desea: entonces g(foo()) y g(std::move(a)) se comportarán exactamente igual, como se esperaba.

Pero si cambia g como he sugerido anteriormente, la llamada g(foo()) no hará una copia porque es un requisito de la lengua para no hacer copia con & &. Ya no es una optimización del compilador.