std::forward

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Definiert in der Header-Datei <utility>
	(1)
template< class T > T&& forward( typename std::remove_reference<T>::type& t ) noexcept;			(seit C++11) (bis C++14)
template< class T > constexpr T&& forward( std::remove_reference_t<T>& t ) noexcept;			(seit C++14)
		(2)
template< class T > T&& forward( typename std::remove_reference<T>::type&& t ) noexcept;				(seit C++11) (bis C++14)
template< class T > constexpr T&& forward( std::remove_reference_t<T>&& t ) noexcept;				(seit C++14)

1) Leitet Lvalues als Lvalues oder als Rvalues weiter, abhängig von T.

Wenn t ein Weiterleitungsreferenz ist (ein Funktionsargument, das als Rvalue-Referenz auf einen cv-unqualifizierten Funktionsvorlagenparameter deklariert ist), leitet diese Überladung das Argument mit der Wertkategorie, die es bei der Übergabe an die aufrufende Funktion hatte, an eine andere Funktion weiter.

Wenn es beispielsweise in einem Wrapper wie dem folgenden verwendet wird, verhält sich die Vorlage wie unten beschrieben

template<class T>
void wrapper(T&& arg)
{
    // arg is always lvalue
    foo(std::forward<T>(arg)); // Forward as lvalue or as rvalue, depending on T
}

• Wenn ein Aufruf von wrapper() einen Rvalue std::string übergibt, wird T zu std::string abgeleitet (nicht std::string&, const std::string& oder std::string&&), und std::forward stellt sicher, dass eine Rvalue-Referenz an foo übergeben wird.
• Wenn ein Aufruf von wrapper() einen const lvalue std::string übergibt, wird T zu const std::string& abgeleitet, und std::forward stellt sicher, dass eine const lvalue-Referenz an foo übergeben wird.
• Wenn ein Aufruf von wrapper() einen non-const lvalue std::string übergibt, wird T zu std::string& abgeleitet, und std::forward stellt sicher, dass eine non-const lvalue-Referenz an foo übergeben wird.

2) Leitet Rvalues als Rvalues weiter und verbietet die Weiterleitung von Rvalues als Lvalues.

Diese Überladung ermöglicht die Weiterleitung eines Ausdrucksergebnisses (wie z. B. eines Funktionsaufrufs), das ein Rvalue oder Lvalue sein kann, als ursprüngliche Wertkategorie eines Weiterleitungsreferenzarguments.

Wenn ein Wrapper beispielsweise nicht nur sein Argument weiterleitet, sondern eine Memberfunktion für das Argument aufruft und dessen Ergebnis weiterleitet

// transforming wrapper
template<class T>
void wrapper(T&& arg)
{
    foo(forward<decltype(forward<T>(arg).get())>(forward<T>(arg).get()));
}

wobei der Typ von arg sein kann

struct Arg
{
    int i = 1;
    int  get() && { return i; } // call to this overload is rvalue
    int& get() &  { return i; } // call to this overload is lvalue
};

Der Versuch, einen Rvalue als Lvalue weiterzuleiten, z. B. durch Instanziierung der Form (2) mit einem Lvalue-Referenztyp T, ist ein Kompilierungsfehler.

Anmerkungen

Siehe Template-Argument-Ableitung für die besonderen Regeln hinter Weiterleitungsreferenzen (T&& als Funktionsparameter verwendet) und Weiterleitungsreferenzen für weitere Details.

Parameter

t

-

Das weiterzuleitende Objekt

Rückgabewert

static_cast<T&&>(t)

Komplexität

Konstant.

Beispiel

Dieses Beispiel demonstriert die perfekte Weiterleitung der Parameter an das Argument des Konstruktors der Klasse T. Außerdem wird die perfekte Weiterleitung von Parameterpaketen demonstriert.

Führen Sie diesen Code aus

#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'; }
};
 
class B
{
public:
    template<class T1, class T2, class T3>
    B(T1&& t1, T2&& t2, T3&& t3) :
        a1_{std::forward<T1>(t1)},
        a2_{std::forward<T2>(t2)},
        a3_{std::forward<T3>(t3)}
    {}
 
private:
    A a1_, a2_, a3_;
};
 
template<class T, class U>
std::unique_ptr<T> make_unique1(U&& u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)));
}
 
template<class T, class... U>
std::unique_ptr<T> make_unique2(U&&... u)
{
    return std::unique_ptr<T>(new T(std::forward<U>(u)...));
}
 
auto make_B(auto&&... args) // since C++20
{
    return B(std::forward<decltype(args)>(args)...);
}
 
int main()
{
    auto p1 = make_unique1<A>(2); // rvalue
    int i = 1;
    auto p2 = make_unique1<A>(i); // lvalue
 
    std::cout << "B\n";
    auto t = make_unique2<B>(2, i, 3);
 
    std::cout << "make_B\n";
    [[maybe_unused]] B b = make_B(4, i, 5);
}

Ausgabe

rvalue overload, n=2
lvalue overload, n=1
B
rvalue overload, n=2
lvalue overload, n=1
rvalue overload, n=3
make_B
rvalue overload, n=4
lvalue overload, n=1
rvalue overload, n=5

Siehe auch

move (C++11)	konvertiert das Argument in ein xvalue (Funktionsvorlage)
move_if_noexcept (C++11)	konvertiert das Argument in ein xvalue, wenn der Move-Konstruktor nicht wirft (Funktionsvorlage)