Namespaces
Variants

std:: make_from_tuple

From cppreference.net
C++
Utilities library
Definiert im 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)

Konstruieren Sie ein Objekt vom Typ T , indem Sie die Elemente des Tupels t als Argumente für den Konstruktor verwenden.

Gegeben die nur zur Darstellung dienende Funktion /*make-from-tuple-impl*/ definiert wie folgt:
template < class T, tuple-like Tuple, std:: size_t ... I > // keine Einschränkung für Tuple vor 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 >>> { }
) ; .

Wenn

(seit C++23)

das Programm ist fehlerhaft.

Inhaltsverzeichnis

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)