std::tuple::tuple

来自cppreference.com
< cpp‎ | utility‎ | tuple
定义于头文件 <tuple>
(1)
constexpr tuple();
(C++11 起)
(C++17 前)
/*EXPLICIT*/ constexpr tuple();
(C++17 起)
(2)
explicit tuple( const Types&... args );
(C++11 起)
(C++14 前)
explicit constexpr tuple( const Types&... args );
(C++14 起)
(C++17 前)
/*EXPLICIT*/ constexpr tuple( const Types&... args );
(C++17 起)
(3)
template< class... UTypes >
explicit tuple( UTypes&&... args );
(C++11 起)
(C++14 前)
template< class... UTypes >
explicit constexpr tuple( UTypes&&... args );
(C++14 起)
(C++17 前)
template< class... UTypes >
/*EXPLICIT*/ constexpr tuple( UTypes&&... args );
(C++17 起)
(4)
template< class... UTypes >
tuple( const tuple<UTypes...>& other );
(C++11 起)
(C++14 前)
template< class... UTypes >
constexpr tuple( const tuple<UTypes...>& other );
(C++14 起)
(C++17 前)
template< class... UTypes >
/*EXPLICIT*/ constexpr tuple( const tuple<UTypes...>& other );
(C++17 起)
(5)
template <class... UTypes>
tuple( tuple<UTypes...>&& other );
(C++11 起)
(C++14 前)
template <class... UTypes>
constexpr tuple( tuple<UTypes...>&& other );
(C++14 起)
(C++17 前)
template <class... UTypes>
/*EXPLICIT*/ constexpr tuple( tuple<UTypes...>&& other );
(C++17 起)
(6)
template< class U1, class U2 >
tuple( const pair<U1,U2>& p );
(C++11 起)
(C++14 前)
template< class U1, class U2 >
constexpr tuple( const pair<U1,U2>& p );
(C++14 起)
(C++17 前)
template< class U1, class U2 >
/*EXPLICIT*/ constexpr tuple( const pair<U1,U2>& p );
(C++17 起)
(7)
template< class U1, class U2 >
tuple( pair<U1,U2>&& p );
(C++11 起)
(C++14 前)
template< class U1, class U2 >
constexpr tuple( pair<U1,U2>&& p );
(C++14 起)
(C++17 前)
template< class U1, class U2 >
/*EXPLICIT*/ constexpr tuple( pair<U1,U2>&& p );
(C++17 起)
tuple( const tuple& other ) = default;
(8) (C++11 起)
tuple( tuple&& other ) = default;
(9) (C++11 起)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a );
(10) (C++11 起)
(11)
template< class Alloc >

tuple( std::allocator_arg_t, const Alloc& a,

       const Types&... args );
(C++11 起)
(C++17 前)
template< class Alloc >

/*EXPLICIT*/ tuple( std::allocator_arg_t, const Alloc& a,

                    const Types&... args );
(C++17 起)
(12)
template< class Alloc, class... UTypes >

tuple( std::allocator_arg_t, const Alloc& a,

       UTypes&&... args );
(C++11 起)
(C++17 前)
template< class Alloc, class... UTypes >

/*EXPLICIT*/ tuple( std::allocator_arg_t, const Alloc& a,

                    UTypes&&... args );
(C++17 起)
(13)
template <class Alloc, class... UTypes>

tuple( std::allocator_arg_t, const Alloc& a,

       const tuple<UTypes...>& other );
(C++11 起)
(C++17 前)
template <class Alloc, class... UTypes>

/*EXPLICIT*/ tuple( std::allocator_arg_t, const Alloc& a,

                    const tuple<UTypes...>& other );
(C++17 起)
(14)
template< class Alloc, class... UTypes >

tuple( std::allocator_arg_t, const Alloc& a,

       tuple<UTypes...>&& other );
(C++11 起)
(C++17 前)
template< class Alloc, class... UTypes >

/*EXPLICIT*/ tuple( std::allocator_arg_t, const Alloc& a,

                    tuple<UTypes...>&& other );
(C++17 起)
(15)
template< class Alloc, class U1, class U2 >

tuple( std::allocator_arg_t, const Alloc& a,

       const pair<U1, U2>& p );
(C++11 起)
(C++17 前)
template< class Alloc, class U1, class U2 >

/*EXPLICIT*/ tuple( std::allocator_arg_t, const Alloc& a,

                    const pair<U1, U2>& p );
(C++17 起)
(16)
template< class Alloc, class U1, class U2 >

tuple( std::allocator_arg_t, const Alloc& a,

       pair<U1, U2>&& p );
(C++11 起)
(C++17 前)
template< class Alloc, class U1, class U2 >

/*EXPLICIT*/ tuple( std::allocator_arg_t, const Alloc& a,

                    pair<U1, U2>&& p );
(C++17 起)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a, const tuple& other );
(17) (C++11 起)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a, tuple&& other );
(18) (C++11 起)

构造新的 tuple 。

1) 默认构造函数。值初始化所有元素。
要求 std::is_default_constructible<Ti>::value 对所有 itrue
(C++17 前)
此重载仅若 std::is_default_constructible<Ti>::value 对所有 itrue 才参与重载决议。
构造函数若且唯若至少一个 i 不可隐式默认构造才为 explicit
(C++17 起)
2) 直接构造函数。以对应参数初始化 tuple 的每个元素。
此重载仅若 sizeof...(Types) >= 1std::is_copy_constructible<Ti>::value 对所有 itrue 才参与重载决议。
此构造函数若且唯若 std::is_convertible<const Ti&, Ti>::value 对至少一个 ifalse 才为 explicit
(C++17 起)
3) 转换构造函数。以 std::forward<Utypes>(args) 中的对应值初始化 tuple 的每个元素。
要求 sizeof...(Types) == sizeof...(UTypes)
此重载仅若 sizeof...(Types) >= 1std::is_constructible<Ti, Ui&&>::value 对所有 itrue 才参与重载决议。
(C++17 前)
此重载仅若 sizeof...(Types) == sizeof...(UTypes)sizeof...(Types) >= 1std::is_constructible<Ti, Ui&&>::value 对所有 itrue 才参与重载决议。
构造函数若且唯若才 std::is_convertible<Ui&&, Ti>::value 对至少一个 ifalseexplicit
(C++17 起)
4) 转换复制构造函数。对 sizeof...(UTypes) 中所有 i ,以 std::get<i>(other) 初始化 tuple 的第 i 个元素。
要求 sizeof...(Types) == sizeof...(UTypes)
此重载仅若 std::is_constructible<Ti, const Ui&>::value 对所有 itrue 才参与重载决议。
(C++17 前)
此重载仅若

sizeof...(Types) == sizeof...(UTypes)
std::is_constructible_v<Ti, const Ui&> 对所有 itrue
sizeof...(Types) != 1

Types... 展开成 TUTypes... 展开成 U 时) std::is_convertible_v<const tuple<U>&, T>std::is_constructible_v<T, const tuple<U>&>std::is_same_v<T, U> 均为 false 才参与重载决议。
构造函数若且唯若 std::is_convertible<const Ui&, Ti>::value 对至少一个 ifalse 才为 explicit
(C++17 起)
5) 转换移动构造函数。对 sizeof...(UTypes) 中所有 i ,以 std::forward<Ui>(std::get<i>(other)) 初始化 tuple 的第 i 个元素。
要求 sizeof...(Types) == sizeof...(UTypes)
此重载仅若 std::is_constructible<Ti, Ui&&>::value 对所有 itrue 才参与重载决议。
(C++17 前)
此重载仅若

sizeof...(Types) == sizeof...(UTypes)
std::is_constructible_v<Ti, Ui&&> 对所有 itrue
sizeof...(Types) != 1

Types... 展开成 TUTypes... 展开成 U 时) std::is_convertible_v<tuple<U>, T>std::is_constructible_v<T, tuple<U>>std::is_same_v<T, U> 均为 false 才参与重载决议。
构造函数若且唯若 std::is_convertible<Ui&&, Ti>::value 对至少一个 ifalse 才为 explicit
(C++17 起)
6) pair 复制构造函数。构造 2-tuple ,从 p.first 构造第一个元素,从 p.second 构造第二个元素。
要求 sizeof...(Types) == 2
此重载仅若 std::is_constructible<T0,const U1&>::valuestd::is_constructible<T1, const U2&>::value 均为 true 才参与重载决议。
(C++17 前)
此重载仅若 sizeof...(Types) == 2std::is_constructible<T0,const U1&>::valuestd::is_constructible<T1, const U2&>::value 均为 true 才参与重载决议。
构造函数若且唯若 std::is_convertible<const U1&, T0>::valuestd::is_convertible<const U2&, T1>::valuefalse 才为 explicit
(C++17 起)
7) pair 移动构造函数。构造 2-tuple ,从 std::forward<U1>(p.first) 构造第一个元素,从 std::forward<U2>(p.second) 构造第二个元素。
要求 sizeof...(Types) == 2
此重载仅若 std::is_constructible<T0, U1&&>::valuestd::is_constructible<T1, U2&&>::value 均为 true 才参与重载决议。
(C++17 前)
此重载仅若 sizeof...(Types) == 2std::is_constructible<T0, U1&&>::valuestd::is_constructible<T1, U2&&>::value 均为 true 才参与重载决议。
构造函数若且唯若 std::is_convertible<U1&&, T0>::valuestd::convertible<U2&&, T1>::valuefalse 才为 explicit
(C++17 起)
8) 隐式定义的复制构造函数。以 other 的对应元素初始化 tuple 的每个元素。
若此函数进行的每个操作都是 constexpr ,则它是 constexpr 。对于空 tuple std::tuple<> ,它是 constexpr
要求 std::is_copy_constructible<Ti>::value 对所有 itrue
9) 隐式定义的移动构造函数。以 std::forward<Ui>(std::get<i>(other)) 构造 tuple 的第 i 个元素。
若此函数进行的每个操作都是 constexpr ,则它是 constexpr 。对于空 tuple std::tuple<> ,它是 constexpr
要求 std::is_move_constructible<Ti>::value 对所有 itrue
10-18) 等同于 (1-9) ,除了每个元素以 uses-allocator 构造创建,即以分配器 (Allocator) 对象 a 为额外参数传递给每个 std::uses_allocator<Ui, Alloc>::valuetrue 的对象的构造函数。

目录

[编辑] 参数

args - 用于初始化 tuple 每个元素的值
other - 用于初始化 tuple 每个元素的值的 tuple
p - 用于初始化此 2-tuple 的两个元素的值的 pair
a - 用于 uses-allocator 构造的分配器

[编辑] 注意

C++17 中条件性 explicit 的构造函数使得可以用列表初始化语法于复制初始化语境构造 tuple :

std::tuple<int, int> foo_tuple() 
{
  return {1, -1};  // C++17 前错误
  return std::make_tuple(1, -1); // 始终工作
}

注意若列表中某元素不可隐式转换成目标 tuple 中的对应元素,则构造函数变为 explicit 。

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}); // 错误: int 不可显式转换成 duration
launch_rocket_at(std::tuple<hours, minutes, seconds>{1, 2, 3}); // OK

[编辑] 示例

#include <iostream>
#include <string>
#include <vector>
#include <tuple>
#include <memory>
 
// 打印任何大小 tuple 的帮助函数
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) 
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};
 
template<class Tuple>
struct TuplePrinter<Tuple, 1>{
    static void print(const Tuple& t) 
    {
        std::cout << std::get<0>(t);
    }
};
 
template<class... Args>
void print(const std::tuple<Args...>& t) 
{
    std::cout << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// 帮助函数结束
 
int main()
{
    std::tuple<int, std::string, double> t1;
    std::cout << "Value-initialized: "; print(t1);
    std::tuple<int, std::string, double> t2(42, "Test", -3.14);
    std::cout << "Initialized with values: "; print(t2);
    std::tuple<char, std::string, int> t3(t2);
    std::cout << "Implicitly converted: "; print(t3);
    std::tuple<int, double> t4(std::make_pair(42, 3.14));
    std::cout << "Constructed from a pair"; print(t4);
 
    // 给出分配器 (Allocator) my_alloc ,带单参数构造函数 my_alloc(int)
    // 用 my_alloc(1) 于 vector 中分配 10 个 int
    std::vector<int, my_alloc> v(10, 1, my_alloc(1));
    // 用 my_alloc(2) 于 tuple 中的 vector 分配 10 个 int
    std::tuple<int, std::vector<int, my_alloc>, double> t5(std::allocator_arg,
                                                           my_alloc(2), 42, v,  -3.14);
}

输出:

Value-initialized: (0, , 0)
Initialized with values: (42, Test, -3.14)
Implicitly converted: (*, Test, -3)
Constructed from a pair(42, 3.14)

[编辑] 参阅

创建一个类型由参数类型定义的tuple对象
(函数模板) [编辑]
创建左值引用的一个 tuple ,或解包 tuple 为独立对象
(函数模板) [编辑]
创建右值引用的 tuple
(函数模板) [编辑]