directa perfecta

Question

Si tenemos el siguiente:

template <class T> 
struct B{ 
    T data; 
} 

struct A{ 
    int data_array[100]; 
} 

int main() 
{ 
    A x; 
    const A x_const; 

    auto y1 = f(A()); 
    auto y2 = f(x); 
    auto y3 = f(x_const); 
    auto y4 = f(std::move(x)); 
} 

Quiero saber un f (preferentemente la función, pero macro está bien también) tal que:

decltype(y1) == B<A> 
decltype(y2) == B<A&> 
decltype(y3) == B<const A&> 
decltype(y4) == B<A&&> 

Es decir, f perfectamente hacia delante x en un objeto de B.

Answer 1

template <typename T> 
auto f(T&& t) -> B<decltype(std::forward<T>(t))> 
{ 
    return B<decltype(std::forward<T>(t))>{std::forward<T>(t)}; 
} 

Esto hace casi lo que quiere. La única diferencia es que para el primero el tipo es B<A&&> en lugar de B<A>.

Answer 2

Esto es imposible. Para y1 y y4, ambos toman rvalues ​​de tipo A, pero desea que devuelvan tipos diferentes. ¿Cómo debe saber f qué devolver?

Answer 3

auto y1 = f(A()); 
auto y4 = f(std::move(x)); 

no será distinguible, como A() producen un temporal que se unirá a A&&.