std::tuple::tuple

来自cppreference.com
< cpp‎ | utility‎ | tuple

定义于头文件 <tuple>
constexpr tuple();
(1) (C++11 起)
explicit tuple( const Types&... args );
(2) (C++11 起)
template< class... UTypes >
explicit tuple( UTypes&&... args );
(3) (C++11 起)
template< class... UTypes >
tuple( const tuple<UTypes...>& other );
(4) (C++11 起)
template <class... UTypes>
tuple( tuple<UTypes...>&& other );
(5) (C++11 起)
template< class U1, class U2 >
tuple( const pair<U1,U2>& p );
(6) (C++11 起)
template< class U1, class U2 >
tuple( pair<U1,U2>&& p );
(7) (C++11 起)
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 起)
template< class Alloc >
tuple( std::allocator_arg_t, const Alloc& a, const Types&... args );
(11) (C++11 起)
template< class Alloc, class... UTypes >
tuple( std::allocator_arg_t, const Alloc& a, UTypes&&... args );
(12) (C++11 起)
template <class Alloc, class... UTypes>
tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>& other );
(13) (C++11 起)
template< class Alloc, class... UTypes >
tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>&& other );
(14) (C++11 起)
template< class Alloc, class U1, class U2 >
tuple( std::allocator_arg_t, const Alloc& a, const pair<U1, U2>& p );
(15) (C++11 起)
template< class Alloc, class U1, class U2 >
tuple( std::allocator_arg_t, const Alloc& a, pair<U1, U2>&& p );
(16) (C++11 起)
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 起)
构造一个新的记录.....
原文:
Constructs a new tuple.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
1)
默认构造函数。值初始化所有元素.....
原文:
Default constructor. Value-initializes all elements.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
2)
初始化与对应的参数的元组的每个元素.
原文:
Initializes each element of the tuple with the corresponding parameter.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
3)
初始化每个元素的元组中的相应值std::forward<Utypes>(args).
原文:
Initializes each element of the tuple with the corresponding value in std::forward<Utypes>(args).
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
4)
为所有isizeof...(UTypes),初始化第i个元素的元组std::get<i>(other).
原文:
For all i in sizeof...(UTypes), initializes ith element of the tuple with std::get<i>(other).
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
5)
为所有isizeof...(UTypes),初始化第i个元素的元组std::forward<Ui>(std::get<i>(other)).
原文:
For all i in sizeof...(UTypes), initializes ith element of the tuple with std::forward<Ui>(std::get<i>(other)).
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
6)
p.first构造与所述第一要素和第二元件从p.second构造一个2元素的元组
原文:
Constructs a 2-element tuple with the first element constructed from p.first and the second element from p.second
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
7)
std::forward<U1>(p.first)构造与所述第一要素和第二元件从std::forward<U2>(p.second)构造一个2元素的元组
原文:
Constructs a 2-element tuple with the first element constructed from std::forward<U1>(p.first) and the second element from std::forward<U2>(p.second)
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
8)
编译器生成的拷贝构造函数。初始化每个元素的元组的对应元素other
原文:
Compiler-generated copy constructor. Initializes each element of the tuple with the corresponding element of other
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
9)
编译器生成的移动构造函数。初始化每个第i个元素的元组std::forward<Ui>(std::get<i>(other)).
原文:
Compiler-generated move constructor. Initializes each ith element of the tuple with std::forward<Ui>(std::get<i>(other)).
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
10 - 18)相同的1-9“的用途 - 的分配器建设”,即通过分配器对象a作为额外的参数的构造函数std::uses_allocator<Ui, Alloc>::value是每个元素的true除了每个元素是由.
原文:
10 - 18) Identical to 1-9 except each element is created by uses-allocator construction, that is, the Allocator object a is passed as an additional argument to the constructor of each element for which std::uses_allocator<Ui, Alloc>::value is true.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

[编辑] 参数

args -
值,用于初始化每个元素的元组
原文:
values used to initialize each element of the tuple
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
other -
来初始化每个元素的TUPE中使用的值的元组
原文:
a tuple of values used to initialize each element of the tupe
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
p -
对用于初始化2元组的两个元素的值
原文:
pair of values used to initialize both elements of this 2-tuple
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
a -
分配器使用在使用分配器建设
原文:
allocator to use in uses-allocator construction
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

[编辑] 示例

#include <iostream>
#include <string>
#include <vector>
#include <tuple>
#include <memory>
 
// helper function to print a tuple of any size
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";
}
// end helper function
 
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);
 
    // given Allocator my_alloc with a single-argument constructor my_alloc(int)
    // use my_alloc(1) to allocate 10 ints in a vector
    std::vector<int, my_alloc> v(10, 1, my_alloc(1));
    // use my_alloc(2) to allocate 10 ints in a vector in a tuple
    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的右值引用
原文:
creates a tuple of rvalue references
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

(函数模板) [编辑]