std::tuple
定义在头文件 <tuple> 中 |
||
template< class... Types > class tuple; |
(自 C++11 起) | |
类模板 std::tuple
是一个固定大小的异构值集合。它是 std::pair 的泛化。
如果 std::is_trivially_destructible<Ti>::value 对 Types
中的每个 Ti
都是 true,则 std::tuple
的析构函数是平凡的。
如果程序声明了 std::tuple
的 显式 或 部分 特化,则程序格式错误,不需要诊断。
内容 |
[编辑] 模板参数
Types... | - | 元组存储的元素的类型。支持空列表。 |
[编辑] 成员函数
构造一个新的 tuple (公共成员函数) | |
将一个 tuple 的内容赋值给另一个(公共成员函数) | |
交换两个 tuple 的内容(公共成员函数) |
[编辑] 非成员函数
(C++11) |
创建由参数类型定义的类型的 tuple 对象(函数模板) |
(C++11) |
创建 tuple 左值引用或将元组解包到单个对象中 (函数模板) |
(C++11) |
创建 转发引用 的 tuple (函数模板) |
(C++11) |
通过连接任意数量的元组来创建 tuple (函数模板) |
(C++11) |
元组访问指定元素 (函数模板) |
(C++20 中已删除)(C++20 中已删除)(C++20 中已删除)(C++20 中已删除)(C++20 中已删除)(C++20) |
按字典顺序比较元组中的值 (函数模板) |
(C++11) |
专门针对 std::swap 算法 (函数模板) |
[编辑] 辅助概念
(C++23) |
指定类型是否实现了 元组协议 (std::get, std::tuple_element, std::tuple_size) (仅供说明的 概念*) |
[编辑] 辅助类
(C++11) |
获取 一个 |
获取指定元素的类型 (类模板特化) | |
特化 std::uses_allocator 类型特征 (类模板特化) | |
确定一个 tuple 和一个 元组类 类型的通用引用类型(类模板特化) | |
(C++23) |
确定一个 tuple 和一个 元组类 类型的通用类型(类模板特化) |
(C++23) |
对 tuple 的格式化支持(类模板特化) |
(C++11) |
占位符,用于在使用 tie 解包 tuple 时跳过一个元素(常量) |
[编辑] 辅助特化
template< class... Ts > constexpr bool enable_nonlocking_formatter_optimization<std::tuple<Ts...>> |
(自 C++23 起) | |
此 std::enable_nonlocking_formatter_optimization 的特化,在每个元素类型都支持的情况下,可以实现对打印 tuple
对象的 std::print 和 std::println 的高效实现。
[编辑] 推导指南 (自 C++17 起)
[编辑] 备注
由于元组的“形状”——它的尺寸、元素类型和这些类型的排序——是其类型签名的组成部分,因此它们必须在编译时都可用,并且只能依赖于其他编译时信息。这意味着对元组进行许多条件操作——尤其是条件前缀/后缀和过滤——只有在条件可以在编译时进行评估的情况下才有可能。例如,给定一个 std::tuple<int, double, int>,可以根据类型进行过滤——例如返回一个 std::tuple<int, int>——但不能根据每个元素是否为正数进行过滤(这将根据元组的运行时值具有不同的类型签名),除非所有元素本身都是 constexpr。
作为一种变通方法,可以处理 std::optional 的元组,但仍然无法根据运行时信息调整大小。
在 N4387(作为对 C++11 的缺陷报告应用)之前,函数无法使用复制列表初始化返回元组
std::tuple<int, int> foo_tuple() { return {1, -1}; // Error until N4387 return std::tuple<int, int>{1, -1}; // Always works return std::make_tuple(1, -1); // Always works }
[编辑] 示例
#include <iostream> #include <stdexcept> #include <string> #include <tuple> std::tuple<double, char, std::string> get_student(int id) { switch (id) { case 0: return {3.8, 'A', "Lisa Simpson"}; case 1: return {2.9, 'C', "Milhouse Van Houten"}; case 2: return {1.7, 'D', "Ralph Wiggum"}; case 3: return {0.6, 'F', "Bart Simpson"}; } throw std::invalid_argument("id"); } int main() { const auto student0 = get_student(0); std::cout << "ID: 0, " << "GPA: " << std::get<0>(student0) << ", " << "grade: " << std::get<1>(student0) << ", " << "name: " << std::get<2>(student0) << '\n'; const auto student1 = get_student(1); std::cout << "ID: 1, " << "GPA: " << std::get<double>(student1) << ", " << "grade: " << std::get<char>(student1) << ", " << "name: " << std::get<std::string>(student1) << '\n'; double gpa2; char grade2; std::string name2; std::tie(gpa2, grade2, name2) = get_student(2); std::cout << "ID: 2, " << "GPA: " << gpa2 << ", " << "grade: " << grade2 << ", " << "name: " << name2 << '\n'; // C++17 structured binding: const auto [gpa3, grade3, name3] = get_student(3); std::cout << "ID: 3, " << "GPA: " << gpa3 << ", " << "grade: " << grade3 << ", " << "name: " << name3 << '\n'; }
输出
ID: 0, GPA: 3.8, grade: A, name: Lisa Simpson ID: 1, GPA: 2.9, grade: C, name: Milhouse Van Houten ID: 2, GPA: 1.7, grade: D, name: Ralph Wiggum ID: 3, GPA: 0.6, grade: F, name: Bart Simpson
[编辑] 缺陷报告
以下更改行为的缺陷报告已追溯应用于之前发布的 C++ 标准。
DR | 应用于 | 发布的行为 | 正确的行为 |
---|---|---|---|
LWG 2796 | C++11 | std::tuple 析构函数的平凡性未指定 |
已指定 |
LWG 3990 | C++11 | 程序可以声明 std::tuple 的显式或部分特化 |
程序在这种情况下是非法的 (不需要诊断) |
[编辑] 参考文献
- C++23 标准 (ISO/IEC 14882:2024)
- 22.4 元组 [tuple]
- C++20 标准 (ISO/IEC 14882:2020)
- 20.5 元组 [tuple]
- C++17 标准 (ISO/IEC 14882:2017)
- 23.5 元组 [tuple]
- C++14 标准 (ISO/IEC 14882:2014)
- 20.4 元组 [tuple]
- C++11 标准 (ISO/IEC 14882:2011)
- 20.4 元组 [tuple]
[编辑] 参见
实现二元元组,即一对值 (类模板) |