Namespaces
Variants

    std::make_from_tuple

    Von de.cppreference.net
     
    C++
     
    Hilfsmittelbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Feature-Test-Makros der Bibliothek (C++20)
    Programm-Hilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreigliedriger Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsmittel
    Relationale Operatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabulartypen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Definiert in Header <tuple> 
    template< class T, class Tuple >
constexpr T make_from_tuple( Tuple&& t );
    		(seit C++17)
    (bis C++23)    		 
    template< class T, tuple-like Tuple >
constexpr T make_from_tuple( Tuple&& t );
    		(seit C++23)

    Erstellt ein Objekt des Typs T unter Verwendung der Elemente des Tupels t als Argumente für den Konstruktor.

    Gegeben die nur zur Darstellung dienende Funktion /*make-from-tuple-impl*/, die wie folgt definiert ist:
    template<class T, tuple-ähnlich Tuple, std::size_t... I> // no constraint on Tuple before C++23
    constexpr T /*make-from-tuple-impl*/(Tuple&& t, std::index_sequence<I...>)
    {
        return T(std::get<I>(std::forward<Tuple>(t))...);
    }

    Der Effekt ist äquivalent zu:
    return /*make-from-tuple-impl*/<T>(
    std::forward<Tuple>(t),
    std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>{}
    );    .

    Falls

    • std::tuple_size_v<std::remove_reference_t<Tuple>> gleich 1 und std::reference_constructs_from_temporary_v<
      T, decltype(std::get<0>(std::declval<Tuple>()))>       gleich true ist, oder
    		 (seit C++23)
    • std::is_constructible_v<T, decltype(std::get<I>(std::declval<Tuple>()))...> gleich false ist,

    ist das Programm fehlerhaft.

    Parameter

    t - Tupel, dessen Elemente als Argumente für den Konstruktor von T verwendet werden sollen

    Rückgabewert

    Das konstruierte T Objekt oder die Referenz.

    Hinweise

    Tuple muss kein std::tuple sein, sondern kann alles sein, was std::get und std::tuple_size unterstützt; insbesondere können std::array und std::pair verwendet werden.

    		(bis C++23)

    Tuple ist auf tuple-ähnliche Typen beschränkt, d.h. jeder darin enthaltene Typ muss eine Spezialisierung von std::tuple oder ein anderer Typ (wie std::array und std::pair ) sein, der tuple-like modelliert.

    		(seit C++23)

    Aufgrund der garantierten Copy Elision muss T nicht beweglich sein.

    Feature-Test Makro Wert Std Feature
    __cpp_lib_make_from_tuple 201606L (C++17) std::make_from_tuple

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <tuple>
struct Foo
{
    Foo(int first, float second, int third)
    {
        std::cout << first << ", " << second << ", " << third << '\n';
    }
};
int main()
{
    auto tuple = std::make_tuple(42, 3.14f, 0);
    std::make_from_tuple<Foo>(std::move(tuple));
}

    Ausgabe: 

    42, 3.14, 0

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 3528 C++17 Cast mit reinterpret_cast etc. war im Fall von 1-Tupel erlaubt verboten

    Siehe auch

    (C++11)
    		erstellt ein tuple -Objekt des durch die Argumenttypen definierten Typs
    (Funktions-Template)
    (C++11)
    		erstellt ein tuple aus Forwarding-Referenzen
    (Funktions-Template)
    (C++17)
    		ruft eine Funktion mit einem Tupel von Argumenten auf
    (Funktions-Template)