¿Por qué se debe modelar una función de reenvío perfecta?

Question

¿Por qué el siguiente código válido:

template<typename T1> 
void foo(T1 &&arg) { bar(std::forward<T1>(arg)); } 

std::string str = "Hello World"; 
foo(str); // Valid even though str is an lvalue 
foo(std::string("Hello World")); // Valid because literal is rvalue 

Pero no:

void foo(std::string &&arg) { bar(std::forward<std::string>(arg)); } 

std::string str = "Hello World"; 
foo(str); // Invalid, str is not convertible to an rvalue 
foo(std::string("Hello World")); // Valid 

¿Por qué el valor-I en el ejemplo 2 se resuelven de la misma manera que lo hace en el ejemplo 1?

Además, ¿por qué la norma considera importante proporcionar el tipo de argumento en std :: forward frente a simple deducción? Simplemente llamar hacia adelante muestra intención, independientemente del tipo.

Si esto no es una cosa estándar y solo mi compilador, estoy usando msvc10, lo que explicaría el mal soporte de C++ 11.

Gracias

Edición 1: Se ha cambiado el literal "Hola Mundo" a ser std :: string ("Hola mundo") para hacer una rvalue.

Answer 1

Antes que nada, read this para tener una idea completa del reenvío. (Sí, estoy delegando la mayor parte de esta respuesta en otro lugar.)

En resumen, el reenvío significa que los valores l permanecen lvalues ​​y los valores rvalues ​​permanecen. No puede hacer eso con un solo tipo, por lo que necesita dos. Por lo tanto, para cada argumento reenviado, necesita dos versiones para ese argumento, que requiere 2 ^N combinaciones totales para la función. Usted podría codificar todas las combinaciones de la función, pero si usa plantillas, esas diversas combinaciones se generarán para usted según sea necesario.

---

Si usted está tratando de optimizar las copias y se mueve, como en:

struct foo 
{ 
    foo(const T& pX, const U& pY, const V& pZ) : 
    x(pX), 
    y(pY), 
    z(pZ) 
    {} 

    foo(T&& pX, const U& pY, const V& pZ) : 
    x(std::move(pX)), 
    y(pY), 
    z(pZ) 
    {} 

    // etc.? :(

    T x; 
    U y; 
    V z; 
}; 

Entonces usted debe parar y hacerlo de esta manera:

struct foo 
{ 
    // these are either copy-constructed or move-constructed, 
    // but after that they're all yours to move to wherever 
    // (that is, either: copy->move, or move->move) 
    foo(T pX, U pY, V pZ) : 
    x(std::move(pX)), 
    y(std::move(pY)), 
    z(std::move(pZ)) 
    {} 

    T x; 
    U y; 
    V z; 
}; 

Sólo se necesita una constructor. Directriz: si necesita su propia copia de los datos, haga esa copia en la lista de parámetros; esto permite la decisión de copiar o pasar a la persona que llama y al compilador.