Namensräume
Varianten

    std::forward

    Aus cppreference.com
    See More

    This page has been machine-translated from the English version of the wiki using Google Translate.

    The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

    Click here for the English version of this page

    <metanoindex/>

     
    C++
     
    Utilities-Bibliothek
     
    <tbody> </tbody>
    definiert in Header <utility>
    template< class T > T&& forward( typename std::remove_reference<T>::type& t );
    		 (1) (seit C++11)
    template< class T > T&& forward( typename std::remove_reference<T>::type&& t );
    		 (2) (seit C++11)
    Wenn nach dem folgenden Rezept in einer Funktions-Template, leitet das Argument einer anderen Funktion genau wie an die aufrufende Funktion übergeben wurde verwendet .
    Original:
    When used according to the following recipe in a function template, forwards the argument to another function exactly as it was passed to the calling function.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    template<typename T>
wrapper(T&& arg) {
  foo(std::forward<T>(arg));
}


    • Wenn ein Aufruf an wrapper() übergibt ein rvalue std::string, dann T wird std::string (nicht std::string&, const std::string& oder std::string&&) abgeleitet und std::forward sichergestellt, dass ein R-Wert auf foo übergeben wird .
      Original:
      If a call to wrapper() passes an rvalue std::string, then T is deduced to std::string (not std::string&, const std::string&, or std::string&&), and std::forward ensures that an rvalue reference is passed to foo.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
    • Wenn ein Aufruf an wrapper() übergibt einen const lvalue std::string, dann T wird const std::string& abgeleitet und std::forward sichergestellt, dass ein const lvalue Verweis auf foo übergeben wird .
      Original:
      If a call to wrapper() passes a const lvalue std::string, then T is deduced to const std::string&, and std::forward ensures that a const lvalue reference is passed to foo.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
    • Wenn ein Aufruf an wrapper() übergibt eine nicht konstante Lvalue std::string, dann wird T std::string& abgeleitet und std::forward sichergestellt, dass ein nicht-const Lvalue Bezugnahme auf foo geleitet wird .
      Original:
      If a call to wrapper() passes a non-const lvalue std::string, then T is deduced to std::string&, and std::forward ensures that a non-const lvalue reference is passed to foo.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

    Notes

    Der Versuch, einen rvalue als Lvalue, wie durch Instanziieren der Form 2) mit lvalue Referenz-Typ T weiterzuleiten, ist ein Compiler-Fehler .
    Original:
    Attempting to forward an rvalue as an lvalue, such as by instantiating the form 2) with lvalue reference type T, is a compile-time error.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Parameter

    t -
    das Objekt weitergeleitet werden soll
    Original:
    the object to be forwarded
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Rückgabewert

    static_cast<T&&>(t)

    Ausnahmen

    noexcept specification:  
    <tbody> </tbody>
    noexcept
      (seit C++11)

    Beispiel

    Dieses Beispiel demonstriert perfekte Weiterleitung der Parameter der Funktion make_unique (), um das Argument des Konstruktors der Klasse T
    Original:
    This example demonstrates perfect forwarding of the parameter of the function make_unique() to the argument of the constructor of class T
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    #include <iostream>
#include <memory>
#include <utility>

struct A {
    A(int&& n) { std::cout << "rvalue overload, n=" << n << "\n"; }
    A(int& n)  { std::cout << "lvalue overload, n=" << n << "\n"; }
};

template<class T, class U>
std::unique_ptr<T> make_unique(U&& u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)));
}

int main()
{
    std::unique_ptr<A> p1 = make_unique<A>(2); // rvalue
    int i = 1;
    std::unique_ptr<A> p2 = make_unique<A>(i); // lvalue
}

    Output: 

    rvalue overload, n=2
lvalue overload, n=1

    Komplexität

    Constant
    Original:
    Constant
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Siehe auch

    (C++11)
    erhält einen rvalue Referenz
    Original:
    obtains an rvalue reference
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (Funktions-Template) [edit]
    (C++11)
    erhält eine rvalue Referenz, wenn der Umzug Konstruktor nicht werfen wird
    Original:
    obtains an rvalue reference if the move constructor does not throw
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (Funktions-Template) [edit]