Deaktivieren der Vorlagenargumentableitung mit std::forward, um eine korrekte Weiterleitung sicherzustellen

Bedenken Sie die Definition von std::forward in VS2010:

template inline
_Ty&& forward(typename identity<_Ty>::type& _Arg)
{   // forward _Arg, given explicitly specified type parameter
    return ((_Ty&&)_Arg);
}

Der Zweck der Identitätsvorlage besteht darin, die Ableitung von Vorlagenargumenten zu deaktivieren. Warum ist dies in diesem Szenario von entscheidender Bedeutung?

Der Abzug von Vorlagenargumenten würde zu einem falschen Typabzug führen. Wenn ein R-Wert-Verweis auf ein Objekt vom Typ Für eine perfekte Weiterleitung ist der Parameter jedoch ein L-Wert, da er einen Namen hat. Daher würde die Verwendung der Vorlagenargumentableitung in std::forward dazu führen, dass der abgeleitete Parametertyp eine L-Wert-Referenz oder eine konstante L-Wert-Referenz ist.

template
T&& forward_with_deduction(T&& obj)
{
    return static_cast
Betrachten Sie das folgende Beispiel:
void test(int&){}
void test(const int&){}
void test(int&&){}

template
void perfect_forwarder(T&& obj)
{
    test(forward_with_deduction(obj));
}

int main()
{
    int x;
    const int& y(x);
    int&& z = std::move(x);

    test(forward_with_deduction(7));    //  7 is an int&&, correctly calls test(int&&)
    test(forward_with_deduction(z));    //  z is treated as an int&, calls test(int&)

    //  All the below call test(int&) or test(const int&) because in perfect_forwarder 'obj' is treated as
    //  an int& or const int& (because it is named) so T in forward_with_deduction is deduced as int& 
    //  or const int&. The T&& in static_cast<T&&>(obj) then collapses to int& or const int& - which is not what 
    //  we want in the bottom two cases.
    perfect_forwarder(x);           
    perfect_forwarder(y);           
    perfect_forwarder(std::move(x));
    perfect_forwarder(std::move(y));
}
In diesem Beispiel schlägt die perfekte Weiterleitung fehl, da der Parameter in perfect_forwarder aufgrund seines Namens als lvalue- oder const lvalue-Referenz behandelt wird. Dies führt zu einer falschen Typableitung in „forward_with_deduction“, was zu einer unerwünschten static_cast-Semantik führt.
Das Deaktivieren der Vorlagenargumentableitung mit der Identitätsvorlage in „std::forward“ stellt sicher, dass „std::forward“ immer eine R-Wert-Referenz zurückgibt, was für wichtig ist Korrekte, perfekte Weiterleitung von L-Werten sowie R-Werten.