¿Cuál es la diferencia entre std :: move y std :: forward

Vi esto aquí: Move Constructor llamando a clase base Move Constructor

Podría alguien explicar:

1. la diferencia entre std::movey std::forward, preferiblemente con algunos ejemplos de código?
2. Cómo pensarlo fácilmente y cuándo usar qué

std::movetoma un objeto y le permite tratarlo como temporal (un valor r). Aunque no es un requisito semántico, normalmente una función que acepta una referencia a un valor r lo invalidará. Cuando vea std::move, indica que el valor del objeto no debe usarse después, pero aún puede asignar un nuevo valor y continuar usándolo.

std::forwardtiene un solo caso de uso: para convertir un parámetro de función con plantilla (dentro de la función) a la categoría de valor (lvalue o rvalue) que la persona que llama usó para pasarlo. Esto permite que los argumentos de valor se transmitan como valores, y los valores se transmitan como valores, un esquema llamado "reenvío perfecto".

Para ilustrar :

void overloaded( int const &arg ) { std::cout << "by lvalue\n"; }
void overloaded( int && arg ) { std::cout << "by rvalue\n"; }

template< typename t >
/* "t &&" with "t" being template param is special, and  adjusts "t" to be
   (for example) "int &" or non-ref "int" so std::forward knows what to do. */
void forwarding( t && arg ) {
    std::cout << "via std::forward: ";
    overloaded( std::forward< t >( arg ) );
    std::cout << "via std::move: ";
    overloaded( std::move( arg ) ); // conceptually this would invalidate arg
    std::cout << "by simple passing: ";
    overloaded( arg );
}

int main() {
    std::cout << "initial caller passes rvalue:\n";
    forwarding( 5 );
    std::cout << "initial caller passes lvalue:\n";
    int x = 5;
    forwarding( x );
}

Como Howard menciona, también hay similitudes ya que ambas funciones simplemente se convierten al tipo de referencia. Pero fuera de estos casos de uso específicos (que cubren el 99.9% de la utilidad de los moldes de referencia de valor), debe usar static_castdirectamente y escribir una buena explicación de lo que está haciendo.

Ambos std::forwardy std::moveno son más que moldes.

X x;
std::move(x);

Lo anterior xconvierte la expresión lvalue de tipo X en una expresión rvalue de tipo X (un valor x para ser exactos). moveTambién puede aceptar un valor r:

std::move(make_X());

y en este caso es una función de identidad: toma un valor de tipo X y devuelve un valor de tipo X.

Con std::forwardusted puede seleccionar el destino hasta cierto punto:

X x;
std::forward<Y>(x);

Convierte la expresión lvalue xde tipo X en una expresión de tipo Y. Existen restricciones sobre lo que Y puede ser.

Y puede ser una Base de X accesible, o una referencia a una Base de X. Y puede ser X, o una referencia a X. No se pueden descartar los calificadores cv forward, pero se pueden agregar calificadores cv. Y no puede ser un tipo que sea simplemente convertible de X, excepto a través de una conversión de Base accesible.

Si Y es una referencia de valor, el resultado será una expresión de valor. Si Y no es una referencia de lvalue, el resultado será una expresión de rvalue (xvalue para ser precisos).

forwardpuede tomar un argumento rvalue solo si Y no es una referencia lvalue. Es decir, no puede emitir un valor r a lvalue. Esto se debe a razones de seguridad, ya que esto generalmente lleva a referencias colgantes. Pero emitir un rvalue a rvalue está bien y está permitido.

Si intenta especificar Y a algo que no está permitido, el error se detectará en tiempo de compilación, no en tiempo de ejecución.

std::forwardse usa para reenviar un parámetro exactamente de la forma en que se pasó a una función. Justo como se muestra aquí:

¿Cuándo usar std :: forward para reenviar argumentos?

El uso std::moveofrece un objeto como un valor r, para posiblemente hacer coincidir un constructor de movimiento o una función que acepte valores. Lo hace std::move(x)incluso si xno es un valor por sí mismo.