Namespaces
Variants

std:: make_from_tuple

From cppreference.net
C++
Utilities library
Definido en el encabezado <tuple>
template < class T, class Tuple >
constexpr T make_from_tuple ( Tuple && t ) ;
(desde C++17)
(hasta C++23)
template < class T, tuple - like Tuple >
constexpr T make_from_tuple ( Tuple && t ) ;
(desde C++23)

Construya un objeto de tipo T , utilizando los elementos de la tupla t como los argumentos para el constructor.

Dada la función de solo exposición /*make-from-tuple-impl*/ definida de la siguiente manera:
template < class T, tuple-like Tuple, std:: size_t ... I > // no hay restricción en Tuple antes de C++23
constexpr T /*make-from-tuple-impl*/ ( Tuple && t, std:: index_sequence < I... > )
{
return T ( std :: get < I > ( std:: forward < Tuple > ( t ) ) ... ) ;
}

El efecto es equivalente a:
return /*make-from-tuple-impl*/ < T > (
std:: forward < Tuple > ( t ) ,
std:: make_index_sequence < std:: tuple_size_v < std:: remove_reference_t < Tuple >>> { }
) ; .

Si

(desde C++23)

el programa está mal formado.

Contenidos

Parámetros

t - tupla cuyos elementos se utilizarán como argumentos para el constructor de T

Valor de retorno

El objeto o referencia T construido.

Notas

Tuple no necesita ser std::tuple , y en su lugar puede ser cualquier cosa que admita std::get y std::tuple_size ; en particular, std::array y std::pair pueden usarse.

(hasta C++23)

Tuple está restringido a ser tuple-like, es decir, cada tipo en él debe ser una especialización de std::tuple u otro tipo (como std::array y std::pair ) que modele tuple-like .

(desde C++23)

Debido a la eliminación de copia garantizada , T no necesita ser movible.

Macro de prueba de características Valor Std Característica
__cpp_lib_make_from_tuple 201606L (C++17) std::make_from_tuple

Ejemplo

Ejecutar este código 
#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));
}

Salida: 

42, 3.14, 0

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3528 C++17 se permitía el cast que contenía reinterpret_cast etc. en el caso de tuple de 1 elemento prohibido

Véase también

(C++11)
crea un objeto tuple del tipo definido por los tipos de argumentos
(plantilla de función)
(C++11)
crea un tuple de referencias de reenvío
(plantilla de función)
(C++17)
llama a una función con una tupla de argumentos
(plantilla de función)