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

constexpr tuple();

tuple( const Types&... args );

template< class... UTypes >
tuple( UTypes&&... args );

template< class... UTypes >
constexpr tuple( tuple<UTypes...>& other );

template< class... UTypes >
tuple( const tuple<UTypes...>& other );

template< class... UTypes >
tuple( tuple<UTypes...>&& other );

template< class... UTypes >
constexpr tuple( const tuple<UTypes...>&& other );

template< class U1, class U2 >
constexpr tuple( std::pair<U1, U2>& p );

template< class U1, class U2 >
tuple( const std::pair<U1, U2>& p );

template< class U1, class U2 >
tuple( std::pair<U1, U2>&& p );

template< class U1, class U2 >
constexpr tuple( const std::pair<U1, U2>&& p );

template< tuple-like UTuple >
constexpr tuple( UTuple&& u );

tuple( const tuple& other ) = default;

tuple( tuple&& other ) = default;

template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a );

template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a,
       const Types&... args );

template< class Alloc, class... UTypes >
tuple( std::allocator_arg_t, const Alloc& a,
       UTypes&&... args );

template< class Alloc, class... UTypes >
constexpr tuple( std::allocator_arg_t, const Alloc& a,
                 tuple<UTypes...>& other );

template< class Alloc, class... UTypes >
tuple( std::allocator_arg_t, const Alloc& a,
       const tuple<UTypes...>& other );

template< class Alloc, class... UTypes >
tuple( std::allocator_arg_t, const Alloc& a,
       tuple<UTypes...>&& other );

template< class Alloc, class... UTypes >
constexpr tuple( std::allocator_arg_t, const Alloc& a,
                 const tuple<UTypes...>&& other );

template< class Alloc, class U1, class U2 >
constexpr tuple( std::allocator_arg_t, const Alloc& a,
                 std::pair<U1, U2>& p );

template< class Alloc, class U1, class U2 >
tuple( std::allocator_arg_t, const Alloc& a,
       const std::pair<U1, U2>& p );

template< class Alloc, class U1, class U2 >
tuple( std::allocator_arg_t, const Alloc& a,
       std::pair<U1, U2>&& p );

template< class Alloc, class U1, class U2 >
constexpr tuple( std::allocator_arg_t, const Alloc& a,
                 const std::pair<U1, U2>&& p );

template< class Alloc, tuple-like UTuple >
constexpr tuple( std::allocator_arg_t, const Alloc& a, UTuple&& u );

template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a,
       const tuple& other );

template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a,
       tuple&& other );

1) Constructor por defecto. Inicializa por valor todos los elementos, si los hay. El constructor por defecto es trivial si sizeof...(Types) == 0.

• Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_default_constructible<Ti>::value es true para todo i.
• El constructor es explicit si y solo si Ti no es inicializable por lista de copia desde {} para al menos un i.

2) Constructor directo. Inicializa cada elemento de la tupla con el parámetro correspondiente.

• Esta sobrecarga participa en la resolución de sobrecarga solo si sizeof...(Types) >= 1 y std::is_copy_constructible<Ti>::value es true para todo i.
• Este constructor es explicit si y solo si std::is_convertible<const Ti&, Ti>::value es false para al menos un i.

3) Constructor de conversión. Inicializa cada elemento de la tupla con el valor correspondiente en std::forward<UTypes>(args).

• Esta sobrecarga participa en la resolución de sobrecarga solo si
  • sizeof...(Types) == sizeof...(UTypes),
  • sizeof...(Types) >= 1,
  • std::is_constructible<Ti, Ui>::value es true para todo i, y
  • sea D std::decay<U0>::type(hasta C++20)std::remove_cvref_t<U0>(desde C++20),
    • si sizeof...(Types) == 1, entonces D no es std::tuple, en caso contrario,
    • si sizeof...(Types) == 2 o sizeof...(Types) == 3, entonces o D no es std::allocator_arg_t, o T0 es std::allocator_arg_t.
• El constructor es explicit si y solo si std::is_convertible<Ui, Ti>::value es false para al menos un i.

Este constructor se define como eliminado si la inicialización de cualquier elemento que sea una referencia lo vinculara a un objeto temporal.

(desde C++23)

4-7) Constructor de conversión. Inicializa cada elemento de la tupla con el elemento correspondiente de other.

Formalmente, sea FWD(other) std::forward<decltype(other)>(other), para todo i, inicializa el iésimo elemento de la tupla con std::get<i>(FWD(other)).

• Esta sobrecarga participa en la resolución de sobrecarga solo si
  • sizeof...(Types) == sizeof...(UTypes),
  • std::is_constructible_v<Ti, decltype(std::get<i>(FWD(other)))> es true para todo i, y
  • o bien
    • sizeof...(Types) no es 1, o
    • (cuando Types... se expande a T y UTypes... se expande a U) std::is_convertible_v<decltype(other), T>, std::is_constructible_v<T, decltype(other)>, y std::is_same_v<T, U> son todos false.
• Estos constructores son explicit si y solo si std::is_convertible_v<decltype(std::get<i>(FWD(other))), Ti> es false para al menos un i.

Estos constructores se definen como eliminados si la inicialización de cualquier elemento que sea una referencia lo vinculara a un objeto temporal.

(desde C++23)

8-11) Constructor de par. Construye una tupla de 2 elementos con cada elemento construido a partir del elemento correspondiente de p.

Formalmente, sea FWD(p) std::forward<decltype(p)>(p), inicializa el primer elemento con std::get<0>(FWD(p)) y el segundo elemento con std::get<1>(FWD(p)).

• Esta sobrecarga participa en la resolución de sobrecarga solo si
  • sizeof...(Types) == 2,
  • std::is_constructible_v<T0, decltype(std::get<0>(FWD(p)))> es true, y
  • std::is_constructible_v<T1, decltype(std::get<1>(FWD(p)))> es true.
• El constructor es explicit si y solo si std::is_convertible_v<decltype(std::get<0>(FWD(p))), T0> o std::is_convertible_v<decltype(std::get<1>(FWD(p))), T1> es false.

Estos constructores se definen como eliminados si la inicialización de cualquier elemento que sea una referencia lo vinculara a un objeto temporal.

(desde C++23)

12) tuple-like constructor. Construye una tupla con cada elemento construido a partir del elemento correspondiente de u.

Formalmente, para todo i, inicializa el iésimo elemento de la tupla con std::get<i>(std::forward<UTuple>(u)).

• Esta sobrecarga participa en la resolución de sobrecarga solo si
  • std::same_as<std::remove_cvref_t<UTuple>, std::tuple> es false,
  • std::remove_cvref_t<UTuple> no es una especialización de std::ranges::subrange,
  • sizeof...(Types) es igual a std::tuple_size_v<std::remove_cvref_t<UTuple>>,
  • std::is_constructible_v<Ti, decltype(std::get<i>(std::forward<UTuple>(u)))> es true para todo i, y
  • o bien
    • sizeof...(Types) no es 1, o
    • (cuando Types... se expande a T) std::is_convertible_v<UTuple, T> y std::is_constructible_v<T, UTuple> son ambos false.
• Este constructor se define como eliminado si la inicialización de cualquier elemento que sea una referencia lo vinculara a un objeto temporal.

13) Constructor de copia definido implícitamente. Inicializa cada elemento de la tupla con el elemento correspondiente de other.

• Este constructor es constexpr si cada operación que realiza es constexpr. Para la tupla vacía std::tuple<>, es constexpr.
• std::is_copy_constructible<Ti>::value debe ser true para todo i, en caso contrario el comportamiento no está definido(hasta C++20)el programa está mal formado(desde C++20).

14) Constructor de movimiento definido implícitamente. Para todo i, inicializa el iésimo elemento de la tupla con std::forward<Ui>(std::get<i>(other)).

• Este constructor es constexpr si cada operación que realiza es constexpr. Para la tupla vacía std::tuple<>, es constexpr.
• std::is_move_constructible<Ti>::value debe ser true para todo i, en caso contrario el comportamiento no está definido(hasta C++20)esta sobrecarga no participa en la resolución de sobrecarga(desde C++20).

15-28) Idéntico a (1-14) excepto que cada elemento se crea mediante construcción con uso-asignador, es decir, el objeto Asignador a se pasa como un argumento adicional al constructor de cada elemento para el cual std::uses_allocator<Ui, Alloc>::value es true.

std::tuple<int, int> foo_tuple() 
{
    // return {1, -1};             // Error antes de N4387
    return std::make_tuple(1, -1); // Siempre funciona
}

using namespace std::chrono;
void launch_rocket_at(std::tuple<hours, minutes, seconds>);
launch_rocket_at({hours(1), minutes(2), seconds(3)}); // CORRECTO
launch_rocket_at({1, 2, 3}); // Error: int no es convertible implícitamente a duration
launch_rocket_at(std::tuple<hours, minutes, seconds>{1, 2, 3}); // CORRECTO

#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <vector>
// función auxiliar para imprimir un vector a un flujo
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;
}
// función auxiliar para imprimir una tupla de cualquier tamaño
template<class Tuple, std::size_t N>
struct TuplePrinter
{
    static void print(const Tuple& t)
    {
        TuplePrinter<Tuple, N - 1>::imprimir(t);
        std::cout << ", ";
        print_single(std::get<N - 1>(t));
    }
};
template<class Tuple>
struct TuplePrinter<Tuple, 1>
{
    static void print(const Tuple& t)
    {
        print_single(std::get<0>(t));
    }
};
template<class... Args>
void print(std::string_view message, const std::tuple<Args...>& t)
{
    std::cout << message << " (";
    TuplePrinter<decltype(t), sizeof...(Args)>::imprimir(t);
    std::cout << ")\n";
}
// fin función auxiliar
int main()
{
    std::tuple<int, std::string, double> t1;
    print("Inicializado con valor, t1:", t1);
    std::tuple<int, std::string, double> t2{42, "Prueba", -3.14};
    print("Inicializado con valores, t2:", t2);
    std::tuple<char, std::string, int> t3{t2};
    print("Convertido implícitamente, t3:", t3);
    std::tuple<int, double> t4{std::make_pair(42, 3.14)};
    print("Construido a partir de un par, t4:", t4);
    // dado Allocator my_alloc con un constructor de un solo argumento
    // my_alloc(int); use my_alloc(1) to allocate 5 ints in a vector
    using my_alloc = std::allocator<int>;
    std::vector<int, my_alloc> v{5, 1, my_alloc{/* 1 */}};
    // usar my_alloc(2) para asignar 5 enteros en un vector en una tupla
    std::tuple<int, std::vector<int, my_alloc>, double> t5
        {std::allocator_arg, my_alloc{/* 2 */}, 42, v, -3.14};
    print("Construido con asignador, t5:", t5);
}

Inicializado por valor, t1: (0, "", 0)
Inicializado con valores, t2: (42, "Test", -3.14)
Conversión implícita, t3: ('*', "Test", -3)
Construido desde un par, t4: (42, 3.14)
Construido con asignador, t5: (42, {1,1,1,1,1}, -3.14)