Die Implementierung von std::forward

Das problem mit dem ersten ist, dass Sie schreiben können std::forward(x), die nicht tun, was Sie wollen, da es immer eine lvalue-Referenzen.

Das argument im zweiten Fall ist eine nicht-abgeleitet Kontext, verhindern der automatischen Abzug der template-argument. Dies zwingt Sie zu schreiben std::forward<T>(x), welche ist die richtige Sache zu tun.

Auch, das argument-Typ für die zweite überladung sollte typename identity<T>::type& weil der Eingang zur idiomatischen Verwendung von std::forward ist immer ein lvalue.

Edit: Der standard tatsächlich Mandate eine Signatur entspricht (die, nebenbei bemerkt, ist genau das, was die libc++ hat):

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;

Ersten Fall als Sebastian Redl sagte immer geben Sie eine lvalue-Referenz. Der Grund dafür ist, dass eine rvalue-Referenz im parameter übergeben werden würde, als eine lvalue-Referenz und parameter - T&& Typ ist ein universal-Referenz eher als eine rvalue-Referenz.

Eigentlich, wenn der erste Fall ist richtig, wir brauchen noch nicht einmal forward mehr. Hier ist ein experiment, um zu demonstrieren, wie universal-Referenz-Parameter übergeben werden

template <typename T, typename U>
void g(T&& t, U&& u)
{
    std::cout << "t is lvalue ref: "
              << std::is_lvalue_reference<decltype(t)>::value << std::endl; //1
    std::cout << "t is rvalue ref: "
              << std::is_rvalue_reference<decltype(t)>::value << std::endl; //0
    std::cout << "u is lvalue ref: "
              << std::is_lvalue_reference<decltype(u)>::value << std::endl; //1
    std::cout << "u is rvalue ref: "
              << std::is_rvalue_reference<decltype(u)>::value << std::endl; //0
}

template <typename T, typename U>
void f(T&& t, U&& u)
{
    std::cout << "t is lvalue ref: "
              << std::is_lvalue_reference<decltype(t)>::value << std::endl; //1
    std::cout << "t is rvalue ref: "
              << std::is_rvalue_reference<decltype(t)>::value << std::endl; //0
    std::cout << "u is lvalue ref: "
              << std::is_lvalue_reference<decltype(u)>::value << std::endl; //0
    std::cout << "u is rvalue ref: "
              << std::is_rvalue_reference<decltype(u)>::value << std::endl; //1

    g(t, u);
}

int main()
{
    std::unique_ptr<int> t;
    f(t, std::unique_ptr<int>());
    return 0;
}

Das Programm stellt sich heraus, dass beide t und u bestanden aus f zu g ist lvalue Referenzen, trotz, dass u ist eine rvalue-Referenz in f. Also im ersten Fall werden die parameter von forward einfach nicht haben eine chance auf eine rvalue-Referenz.

Den identity zum ändern der parameter-Typ von universal Verweis auf eine rvalue Referenz (wie erwähnt von Redl, es ist präziser zu benutzen std::remove_reference). Aber diese änderung ist die Vorlage geben Abzug nicht mehr möglich, so dass der Typ-parameter für forward ist zwingend erforderlich, da ein Ergebnis, das wir schreiben soll forward<T>(t).

Aber der zweite Fall in Ihre Frage ist nicht korrekt, wie auch erwähnt Redl, der richtige Ansatz ist eine überlastung, deren parameter ist ein lvalue-Referenz.

Die einfachste Implementierung, die ich finden kann, ist diese

template <typename T>
T&& forward(typename identity<T>::type& param)
{
    return static_cast<T&&>(param);
}

Er arbeitet für universal-Referenzen, zum Beispiel

template <typename T, typename U>
void f(T&& t, U&& u)
{
    ::forward<T>(t);
    ::forward<U>(u);
}

std::unique_ptr<int> t;
f(t, std::unique_ptr<int>());
//deduction in f:
//  T = unique_ptr&, decltype(t) = unique_ptr&
//  U = unique_ptr, decltype(u) = unique_ptr&& (but treated as an lvalue reference)
//specialization of forward:
//  forward<T> = forward<unique_ptr&>, param type = unique_ptr&
//                                     return type = unique_ptr&
//  forward<U> = forward<unique_ptr>,  param type = unique_ptr&
//                                     return type = unique_ptr&&