Warum verwendet std::forward die Identitätsvorlage, um den Abzug von Vorlagenargumenten zu deaktivieren?

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

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

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

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.

<code class="cpp">template<typename t>
T&& forward_with_deduction(T&& obj)
{
    return static_cast<t>(obj);
}</t></typename></code>

Betrachten Sie das folgende Beispiel:

<code class="cpp">void test(int&){}
void test(const int&){}
void test(int&&){}

template<typename t>
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));
}</t></typename></code>

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 und R-Werten.

Das obige ist der detaillierte Inhalt vonWarum verwendet std::forward die Identitätsvorlage, um den Abzug von Vorlagenargumenten zu deaktivieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!