c++11 标准模板（STL）（std::tuple）（三）

定义于头文件 <tuple>

template< class... Types >
class tuple;

(C++11 起)

类模板 std::tuple 是固定大小的异类值汇集。它是 std::pair 的推广。

若 (std::is_trivially_destructible_v<Types> && ...) 为 true ，则 tuple 的析构函数是平凡的。

(C++17 起)

模板形参

Types... - tuple 所存储的元素的类型。支持空列表。

赋值一个 tuple 的内容给另一个

std::tuple<Types...>::operator=

tuple& operator=( const tuple& other );	(1)	(C++11 起) (C++20 前)
constexpr tuple& operator=( const tuple& other );	(1)	(C++20 起)
tuple& operator=( tuple&& other ) noexcept(/* see below */);	(2)	(C++11 起) (C++20 前)
constexpr tuple& operator=( tuple&& other ) noexcept(/* see below */);		(C++20 起)
template< class... UTypes > tuple& operator=( const tuple<UTypes...>& other );		(3)	(C++11 起) (C++20 前)
template< class... UTypes > constexpr tuple& operator=( const tuple<UTypes...>& other );		(3)	(C++20 起)
template< class... UTypes > tuple& operator=( tuple<UTypes...>&& other );		(4)	(C++11 起) (C++20 前)
template< class... UTypes > constexpr tuple& operator=( tuple<UTypes...>&& other );		(4)	(C++20 起)
template< class U1, class U2 > tuple& operator=( const pair<U1,U2>& p );		(5)	(C++11 起) (C++20 前)
template< class U1, class U2 > constexpr tuple& operator=( const pair<U1,U2>& p );		(5)	(C++20 起)
template< class U1, class U2 > tuple& operator=( pair<U1,U2>&& p );		(6)	(C++11 起) (C++20 前)
template< class U1, class U2 > constexpr tuple& operator=( pair<U1,U2>&& p );		(6)	(C++20 起)

以另一 tuple 或 pair 的内容替换 tuple 的内容。

1) 复制赋值运算符。复制赋值 other 的每个元素给 *this 的对应元素。

2) 移动赋值运算符。对所有 i ，赋值 std::forward<Ti>(get(other)) 给 get(*this) 。

3) 对所有 i ，赋 std::get(other) 给 std::get(*this) 。

4) 对所有 i ，赋 std::forward<Ui>(std::get(other)) 给 std::get(*this) 。

5) 赋 p.first 给 *this 的首元素并赋 p.second 给 *this 的第二元素。

6) 赋 std::forward<U1>(p.first) 给 *this 的首元素并赋 std::forward<U2>(p.second) 给 *this 的第二元素。

这些函数的行为未定义，除非：

对于 (1) ， std::is_copy_assignable<T_i>::value 对 Types 中所有 T_i 为 true 。
对于 (2) ， std::is_move_assignable<T_i>::value 对 Types 中所有 T_i 为 true 。
对于 (3) ， sizeof...(UTypes) == sizeof...(Types) 且 std::is_assignable<T_i&, const U_i&>::value 对所有 Types 中的 T_i 和 UTypes 中的 U_i 的对应对为 true 。
对于 (4) ， sizeof...(UTypes) == sizeof...(Types) 且 std::is_assignable<T_i&, U_i&&>::value 对所有 Types 中的 T_i 和 UTypes 中的 U_i 的对应对为 true 。
对于 (5) ， sizeof...(Types) == 2 且 std::is_assignable<T_0&, const U1&>::value 与 std::is_assignable<T_1&, const U2&>::value 都是 true ，其中 T_0 与 T_1 是组成 Types 的二个类型。
对于 (6) ， sizeof...(Types) == 2 且 std::is_assignable<T_0&, U1&&>::value 与 std::is_assignable<T_1&, U2&&>::value 都是 true ，其中 T_0 与 T_1 是组成 Types 的二个类型。

(C++17 前)

这些函数不参与重载决议（或对于复制赋值运算符，为定义为被删除），若任何要求的赋值运算非法或若存在大小不匹配。特别是：

(1) 定义为被删除，除非 std::is_copy_assignable<T_i>::value 对 Types 中所有 T_i 为 true 。
(2) 不参与重载决议，除非 std::is_move_assignable<T_i>::value 对 Types 中所有 T_i 为 true 。
(3) 不参与重载决议，除非 sizeof...(UTypes) == sizeof...(Types) 且 std::is_assignable<T_i&, const U_i&>::value 对所有 Types 中的 T_i 和 UTypes 中的 U_i 的对应对为 true 。
(4) 不参与重载决议，除非 sizeof...(UTypes) == sizeof...(Types) 且 std::is_assignable<T_i&, U_i&&>::value 对所有 Types 中的 T_i 和 UTypes 中的 U_i 的对应对为 true 。
(5) 不参与重载决议，除非 sizeof...(Types) == 2 且 std::is_assignable<T_0&, const U1&>::value 与 std::is_assignable<T_1&, const U2&>::value 都是 true ，其中 T_0 与 T_1 是组成 Types 的二个类型。
(6) 不参与重载决议，除非 sizeof...(Types) == 2 且 std::is_assignable<T_0&, U1&&>::value 与 std::is_assignable<T_1&, U2&&>::value 都是 true ，其中 T_0 与 T_1 是组成 Types 的二个类型。

(C++17 起)

参数

other	-	要替换此 `tuple` 内容的 `tuple`
p	-	要替换此 2-tuple 内容的 `pair`

返回值

*this

异常

1) （无）

2)noexcept 规定：

noexcept(is_nothrow_move_assignable<T0>::value &&is_nothrow_move_assignable<T1>::value &&is_nothrow_move_assignable<T2>::value &&...
)

3-6) （无）

调用示例

#include <tuple>
#include <iostream>
#include <string>
#include <typeinfo>
#include <stdexcept>
#include <iostream>
#include <vector>
#include <memory>struct Cell
{int x;int y;Cell() = default;Cell(int a, int b): x(a), y(b) {}Cell(const Cell &cell){x = cell.x;y = cell.y;}Cell &operator+(const Cell &cell){x += cell.x;y += cell.y;return *this;}Cell &operator+=(const Cell &cell){x += cell.x;y += cell.y;return *this;}Cell &operator*=(int n){x *= n;y *= n;return *this;}Cell &operator++(){x += 1;y += 1;return *this;}friend Cell operator +(const Cell &cell1, const Cell &cell2){Cell cell = cell1;cell += cell2;return cell;}friend Cell operator *(const Cell &cell1, const Cell &cell2){Cell cell = {cell1.x * cell2.x, cell1.y * cell2.y};return cell;}friend Cell operator /(const Cell &cell1, const Cell &cell2){Cell cell = {cell1.x / cell2.x, cell1.y / cell2.y};return cell;}friend Cell operator %(const Cell &cell1, const Cell &cell2){Cell cell = {cell1.x % cell2.x, cell1.y % cell2.y};return cell;}friend bool operator ==(const Cell &cell1, const Cell &cell2){return cell1.x == cell2.x && cell1.y == cell2.y;}friend bool operator !=(const Cell &cell1, const Cell &cell2){return cell1.x != cell2.x && cell1.y != cell2.y;}friend bool operator <(const Cell &cell1, const Cell &cell2){if (cell1.x == cell2.x){return cell1.y < cell2.y;}else{return cell1.x < cell2.x;}}friend bool operator >(const Cell &cell1, const Cell &cell2){if (cell1.x == cell2.x){return cell1.y > cell2.y;}else{return cell1.x > cell2.x;}}
};std::ostream &operator<<(std::ostream &os, const Cell &cell)
{os << "{" << cell.x << "," << cell.y << "}";return os;
}// 打印任何大小 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 << ")" << std::endl;
}
// 辅助函数结束int main()
{std::tuple<Cell, std::string, double> tuple1(Cell{101, 101}, "GGX", 3.14);std::cout << "Initialized with values: ";print(tuple1);//以另一 tuple 或 pair 的内容替换 tuple 的内容。//1) 复制赋值运算符。复制赋值 other 的每个元素给 *this 的对应元素。std::tuple<Cell, std::string, double> tuple2 = tuple1;std::cout << "Assignment Operators: ";print(tuple2);//2) 移动赋值运算符。对所有 i ，赋值 std::forward<Ti>(get<i>(other)) 给 get<i>(*this) 。std::tuple<Cell, std::string, double> tuple3 = std::move(tuple1);std::cout << "Mobile assignment operator: ";print(tuple3);//3) 对所有 i ，赋 std::get<i>(other) 给 std::get<i>(*this) 。std::tuple<Cell, std::string, double> tuple4 =std::tuple<Cell, std::string, double>(Cell{101, 101}, "GGX", 3.14);std::cout << "Mobile assignment operator: ";print(tuple4);//4) 对所有 i ，赋 std::forward<Ui>(std::get<i>(other)) 给 std::get<i>(*this) 。std::tuple<Cell, std::string, double> tuple5 =std::move(std::tuple<Cell, std::string, double>(Cell{101, 101}, "GGX", 3.14));std::cout << "Mobile assignment operator: ";print(tuple5);//5) 赋 p.first 给 *this 的首元素并赋 p.second 给 *this 的第二元素。std::tuple<Cell, std::string> tuple6 = std::make_pair(Cell{1023, 1024}, "GGX");std::cout << "std::make_pair(): ";print(tuple6);//6) 赋 std::forward<U1>(p.first) 给 *this 的首元素并赋//std::forward<U2>(p.second) 给 *this 的第二元素。std::tuple<Cell, std::string> tuple7 = std::make_pair(Cell{1023, 1024}, "GGX");std::cout << "std::move(std::make_pair()): ";print(tuple7);return 0;
}

输出

Initialized with values: ({101,101}, GGX, 3.14)
Assignment Operators: ({101,101}, GGX, 3.14)
Mobile assignment operator: ({101,101}, GGX, 3.14)
Mobile assignment operator: ({101,101}, GGX, 3.14)
Mobile assignment operator: ({101,101}, GGX, 3.14)
std::make_pair(): ({1023,1024}, GGX)
std::move(std::make_pair()): ({1023,1024}, GGX)