Namespaces
Variants

    std::make_from_tuple

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Autonome et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support linguistique
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et d'heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilitaires
    Support linguistique
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (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)

    Utilitaires généraux
    Opérateurs relationnels (obsolète en C++20)
     
    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)

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

    Étant donné la fonction d'exposition seule /*make-from-tuple-impl*/ définie comme suit :
    template<class T, tuple-like 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))...);
    }

    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

    • std::tuple_size_v<std::remove_reference_t<Tuple>> est 1 et std::reference_constructs_from_temporary_v<
      T, decltype(std::get<0>(std::declval<Tuple>()))>       est true, ou
    		 (depuis C++23)
    • std::is_constructible_v<T, decltype(std::get<I>(std::declval<Tuple>()))...> est false,

    le programme est mal formé.

    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)