Namespaces
Variants

std:: make_from_tuple

From cppreference.net
C++
Utilities library
Défini dans l'en-tête <tuple>
template < class T, class Tuple >
constexpr T make_from_tuple ( Tuple && t ) ;
(depuis C++17)
(jusqu'à C++23)
template < class T, tuple - like Tuple >
constexpr T make_from_tuple ( Tuple && t ) ;
(depuis C++23)

Construisez un objet de type T , en utilisant les éléments du tuple t comme arguments pour le constructeur.

Étant donné la fonction d'exposition uniquement /*make-from-tuple-impl*/ définie comme suit :
template < class T, tuple-like Tuple, std:: size_t ... I > // aucune contrainte sur Tuple avant C++23
constexpr T /*make-from-tuple-impl*/ ( Tuple && t, std:: index_sequence < I... > )
{
return T ( std :: get < I > ( std:: forward < Tuple > ( t ) ) ... ) ;
}

L'effet est équivalent à :
return /*make-from-tuple-impl*/ < T > (
std:: forward < Tuple > ( t ) ,
std:: make_index_sequence < std:: tuple_size_v < std:: remove_reference_t < Tuple >>> { }
) ; .

Si

(depuis C++23)

le programme est mal formé.

Table des matières

Paramètres

t - tuple dont les éléments doivent être utilisés comme arguments pour le constructeur de T

Valeur de retour

L'objet ou la référence T construit(e).

Notes

Tuple n'a pas besoin d'être std::tuple , et peut être à la place tout ce qui supporte std::get et std::tuple_size ; en particulier, std::array et std::pair peuvent être utilisés.

(jusqu'à C++23)

Tuple est contraint à être tuple-like, c'est-à-dire que chaque type doit être une spécialisation de std::tuple ou d'un autre type (tel que std::array et std::pair ) qui modélise tuple-like .

(depuis C++23)

En raison de la suppression de copie garantie , T n'a pas besoin d'être déplaçable.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_make_from_tuple 201606L (C++17) std::make_from_tuple

Exemple

Exécuter ce code 
#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));
}

Sortie : 

42, 3.14, 0

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3528 C++17 le cast contenant reinterpret_cast etc. était autorisé dans le cas du 1-tuple interdit

Voir aussi

(C++11)
crée un objet tuple du type défini par les types d'arguments
(modèle de fonction)
(C++11)
crée un tuple de références de transfert
(modèle de fonction)
(C++17)
appelle une fonction avec un tuple d'arguments
(modèle de fonction)