std::tuple<Types...>:: tuple

1) Constructeur par défaut. Initialise par valeur tous les éléments, s'il y en a. Le constructeur par défaut est trivial si sizeof... ( Types ) == 0 .

• Cette surcharge participe à la résolution de surcharge seulement si std:: is_default_constructible < Ti > :: value est true pour tout i .
• Le constructeur est explicit si et seulement si Ti n'est pas initialisable par liste de copie depuis { } pour au moins un i .

2) Constructeur direct. Initialise chaque élément du tuple avec le paramètre correspondant.

• Cette surcharge participe à la résolution de surcharge seulement si sizeof... ( Types ) >= 1 et std:: is_copy_constructible < Ti > :: value est true pour tous les i .
• Ce constructeur est explicit si et seulement si std:: is_convertible < const Ti & , Ti > :: value est false pour au moins un i .

3) Constructeur de conversion. Initialise chaque élément du tuple avec la valeur correspondante dans std:: forward < UTypes > ( args ) .

• Cette surcharge participe à la résolution de surcharge seulement si
  • sizeof... ( Types ) == sizeof... ( UTypes ) ,
  • sizeof... ( Types ) >= 1 ,
  • std:: is_constructible < Ti, Ui > :: value est true pour tous les i , et
  • soit D défini comme std:: decay < U0 > :: type (jusqu'à C++20) std:: remove_cvref_t < U0 > (depuis C++20) ,
    • si sizeof... ( Types ) == 1 , alors D n'est pas std::tuple , sinon,
    • si sizeof... ( Types ) == 2 ou sizeof... ( Types ) == 3 , alors soit D n'est pas std::allocator_arg_t , soit T0 est std::allocator_arg_t .
• Le constructeur est explicit si et seulement si std:: is_convertible < Ui, Ti > :: value est false pour au moins un i .

Ce constructeur est défini comme supprimé si l'initialisation d'un élément qui est une référence le lierait à un objet temporaire .

(depuis C++23)

4-7) Constructeur de conversion. Initialise chaque élément du tuple avec l'élément correspondant de other .

Formellement, soit FWD ( other ) représentant std:: forward < decltype ( other ) > ( other ) , pour tout i , initialise le i -ième élément du tuple avec std :: get < i > ( FWD ( other ) ) .

• Cette surcharge participe à la résolution de surcharge seulement si
  • sizeof... ( Types ) == sizeof... ( UTypes ) ,
  • std:: is_constructible_v < Ti, decltype ( std :: get < i > ( FWD ( other ) ) ) > est true pour tout i , et
  • soit
    • sizeof... ( Types ) n'est pas 1 , soit
    • (lorsque Types... se développe en T et UTypes... se développe en U ) std:: is_convertible_v < decltype ( other ) , T > , std:: is_constructible_v < T, decltype ( other ) > , et std:: is_same_v < T, U > sont tous false .
• Ces constructeurs sont explicit si et seulement si std:: is_convertible_v < decltype ( std :: get < i > ( FWD ( other ) ) ) , Ti > est false pour au moins un i .

Ces constructeurs sont définis comme supprimés si l'initialisation d'un élément qui est une référence le lierait à un objet temporaire.

(since C++23)

8-11) Constructeur de paire. Construit un tuple à 2 éléments avec chaque élément construit à partir de l'élément correspondant de p .

Formellement, soit FWD ( p ) comme std:: forward < decltype ( p ) > ( p ) , initialise le premier élément avec std :: get < 0 > ( FWD ( p ) ) et le second élément avec std :: get < 1 > ( FWD ( p ) ) .

• Cette surcharge participe à la résolution de surcharge seulement si
  • sizeof... ( Types ) == 2 ,
  • std:: is_constructible_v < T0, decltype ( std :: get < 0 > ( FWD ( p ) ) ) > est true , et
  • std:: is_constructible_v < T1, decltype ( std :: get < 1 > ( FWD ( p ) ) ) > est true .
• Le constructeur est explicit si et seulement si std:: is_convertible_v < decltype ( std :: get < 0 > ( FWD ( p ) ) ) , T0 > ou std:: is_convertible_v < decltype ( std :: get < 1 > ( FWD ( p ) ) ) , T1 > est false .

Ces constructeurs sont définis comme supprimés si l'initialisation d'un élément qui est une référence le lierait à un objet temporaire.

(depuis C++23)

12) tuple-like constructeur. Construit un tuple avec chaque élément construit à partir de l'élément correspondant de u .

Formellement, pour tout i , initialise le i -ième élément du tuple avec std :: get < i > ( std:: forward < UTuple > ( u ) ) .

• Cette surcharge participe à la résolution de surcharge seulement si
  • std:: same_as < std:: remove_cvref_t < UTuple > , std:: tuple > est false ,
  • std:: remove_cvref_t < UTuple > n'est pas une spécialisation de std::ranges::subrange ,
  • sizeof... ( Types ) est égal à std:: tuple_size_v < std:: remove_cvref_t < UTuple >> ,
  • std:: is_constructible_v < Ti, decltype ( std :: get < i > ( std:: forward < UTuple > ( u ) ) ) > est true pour tout i , et
  • soit
    • sizeof... ( Types ) n'est pas 1 , soit
    • (lorsque Types... se développe en T ) std:: is_convertible_v < UTuple, T > et std:: is_constructible_v < T, UTuple > sont tous deux false .
• Ce constructeur est défini comme supprimé si l'initialisation d'un élément qui est une référence le lierait à un objet temporaire.

13) Constructeur de copie implicitement défini. Initialise chaque élément du tuple avec l'élément correspondant de other .

• Ce constructeur est constexpr si chaque opération qu'il effectue est constexpr . Pour le tuple vide std:: tuple <> , il est constexpr .
• std:: is_copy_constructible < Ti > :: value doit être true pour tout i , sinon le comportement est indéfini (jusqu'à C++20) le programme est mal formé (depuis C++20) .

14) Constructeur de déplacement implicitement défini. Pour chaque i , initialise le i -ième élément du tuple avec std:: forward < Ui > ( std :: get < i > ( other ) ) .

• Ce constructeur est constexpr si chaque opération qu'il effectue est constexpr . Pour le tuple vide std:: tuple <> , il est constexpr .
• std:: is_move_constructible < Ti > :: value doit être true pour tout i , sinon le comportement est indéfini (jusqu'à C++20) cette surcharge ne participe pas à la résolution de surcharge (depuis C++20) .

15-28) Identique à (1-14) sauf que chaque élément est créé par construction uses-allocator , c'est-à-dire que l'objet Allocator a est passé comme argument supplémentaire au constructeur de chaque élément pour lequel std:: uses_allocator < Ui, Alloc > :: value est true .

std::tuple<int, int> foo_tuple() 
{
    // return {1, -1};             // Erreur avant N4387
    return std::make_tuple(1, -1); // Fonctionne toujours
}

using namespace std::chrono;
void launch_rocket_at(std::tuple<hours, minutes, seconds>);
launch_rocket_at({hours(1), minutes(2), seconds(3)}); // OK
launch_rocket_at({1, 2, 3}); // Erreur : int n'est pas implicitement convertible en duration
launch_rocket_at(std::tuple<hours, minutes, seconds>{1, 2, 3}); // OK

#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <vector>
// fonction auxiliaire pour afficher un vecteur vers un flux
template<class Os, class T>
Os& operator<<(Os& os, std::vector<T> const& v)
{
    os << '{';
    for (auto i{v.size()}; const T& e : v)
        os << e << (--i ? "," : "");
    return os << '}';
}
template<class T>
void print_single(T const& v)
{
    if constexpr (std::is_same_v<T, std::decay_t<std::string>>)
        std::cout << std::quoted(v);
    else if constexpr (std::is_same_v<std::decay_t<T>, char>)
        std::cout << "'" << v << "'";
    else
        std::cout << v;
}
// fonction d'assistance pour afficher un tuple de n'importe quelle taille
template<class Tuple, std::size_t N>
struct TuplePrinter
{
    static void print(const Tuple& t)
    {
        TuplePrinter<Tuple, N - 1>::print(t);
        std::cout << ", ";
        print_single(std::obtenir<N - 1>(t));
    }
};
template<class Tuple>
struct TuplePrinter<Tuple, 1>
{
    static void print(const Tuple& t)
    {
        print_single(std::obtenir<0>(t));
    }
};
template<class... Args>
void print(std::string_view message, const std::tuple<Args...>& t)
{
    std::cout << message << " (";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// fin de la fonction d'assistance
int main()
{
    std::tuple<int, std::string, double> t1;
    print("Initialisé par valeur, t1:", t1);
    std::tuple<int, std::string, double> t2{42, "Test", -3.14};
    print("Initialisé avec des valeurs, t2:", t2);
    std::tuple<char, std::string, int> t3{t2};
    print("Converti implicitement, t3:", t3);
    std::tuple<int, double> t4{std::make_pair(42, 3.14)};
    print("Construit à partir d'une paire, t4:", t4);
    // étant donné Allocator my_alloc avec un constructeur à un seul argument
    // my_alloc(int); utilisez my_alloc(1) pour allouer 5 entiers dans un vecteur
    using my_alloc = std::allocator<int>;
    std::vector<int, my_alloc> v{5, 1, my_alloc{/* 1 */}};
    // utiliser my_alloc(2) pour allouer 5 entiers dans un vecteur dans un tuple
    std::tuple<int, std::vector<int, my_alloc>, double> t5
        {std::allocator_arg, my_alloc{/* 2 */}, 42, v, -3.14};
    print("Construit avec allocateur, t5:", t5);
}

Initialisé par valeur, t1: (0, "", 0)
Initialisé avec des valeurs, t2: (42, "Test", -3.14)
Conversion implicite, t3: ('*', "Test", -3)
Construit à partir d'une paire, t4: (42, 3.14)
Construit avec un allocateur, t5: (42, {1,1,1,1,1}, -3.14)