std::tuple

std::tuple 是 C++11 引入的标准库类型，用于存储固定大小的异质元素集合（即可以包含不同类型的数据）。它类似数组，但数组只能存储同类型元素，而 std::tuple 可以同时存储不同类型（如 int、std::string、double 等），且大小在编译期固定。

一、基本使用与头文件

使用 std::tuple 需要包含头文件：

#include <tuple>  // 必须包含的头文件

二、创建 std::tuple

有多种方式创建 std::tuple：

1. 直接初始化（指定类型）

#include <tuple>
#include <string>

// 创建一个包含 int、string、double 的 tuple
std::tuple<int, std::string, double> t1(10, "hello", 3.14);

2. 使用 std::make_tuple（自动推导类型）

std::make_tuple 会根据传入的参数自动推导 tuple 的类型，更简洁：

auto t2 = std::make_tuple(20, 'a', 5.5f);  // 类型为 tuple<int, char, float>

3. 空 tuple

std::tuple<> empty_tuple;  // 不包含任何元素的 tuple

三、访问 std::tuple 的元素

std::tuple 的元素没有名称，需通过索引或类型访问（索引从 0 开始）。

1. std::get<N>() 按索引访问

最常用的方式，N 必须是编译期常量（如字面量 0、1，或 constexpr 变量）：

#include <iostream>
#include <tuple>
#include <string>

int main() {
    auto t = std::make_tuple(100, std::string("tuple"), 3.14);
    
    // 访问第 0 个元素（int 类型）
    int val1 = std::get<0>(t);
    std::cout << val1 << "\n";  // 输出：100
    
    // 访问第 1 个元素（string 类型）
    std::string val2 = std::get<1>(t);
    std::cout << val2 << "\n";  // 输出：tuple
    
    // 修改元素值
    std::get<2>(t) = 9.8;
    std::cout << std::get<2>(t) << "\n";  // 输出：9.8
    
    return 0;
}

2. std::get<T>() 按类型访问（谨慎使用）

如果 tuple 中仅存在一个类型为 T 的元素，可以通过类型直接访问：

auto t = std::make_tuple(10, 3.14, std::string("test"));
double d = std::get<double>(t);  // 正确：仅一个 double 元素

⚠️ 注意：若存在多个相同类型的元素，会编译报错（歧义）：

auto t = std::make_tuple(10, 20, 30);  // 三个 int 元素
// int x = std::get<int>(t);  // 编译错误：无法确定是哪个 int 元素

3. C++17 结构化绑定（推荐）

最简洁的访问方式，可一次性将 tuple 元素绑定到变量：

#include <tuple>
#include <iostream>

int main() {
    auto t = std::make_tuple(1, "hello", 3.14f);
    
    // 结构化绑定：将 t 的三个元素分别绑定到 a、b、c
    auto [a, b, c] = t;  // a=int(1), b=const char*("hello"), c=float(3.14f)
    
    std::cout << a << " " << b << " " << c << "\n";  // 输出：1 hello 3.14
    
    return 0;
}

四、常用操作与工具

1. 获取 tuple 大小：std::tuple_size

在编译期获取 tuple 包含的元素数量：

#include <tuple>
#include <iostream>

int main() {
    auto t = std::make_tuple(1, 2.2, "three");
    constexpr size_t size = std::tuple_size<decltype(t)>::value;
    std::cout << "tuple 大小：" << size << "\n";  // 输出：3
    return 0;
}

2. 获取元素类型：std::tuple_element

在编译期获取指定索引的元素类型：

#include <tuple>
#include <type_traits>

int main() {
    using MyTuple = std::tuple<int, std::string, double>;
    
    // 获取第 1 个元素的类型（std::string）
    using ElemType = std::tuple_element<1, MyTuple>::type;
    
    // 验证类型是否正确
    static_assert(std::is_same_v<ElemType, std::string>);  // 编译通过
    return 0;
}

3. 拼接 tuple：std::tuple_cat

将多个 tuple 拼接为一个新的 tuple：

#include <tuple>
#include <iostream>

int main() {
    auto t1 = std::make_tuple(1, 2);
    auto t2 = std::make_tuple("a", 3.14);
    
    // 拼接 t1 和 t2，结果为 tuple<int, int, const char*, double>
    auto combined = std::tuple_cat(t1, t2);
    
    auto [a, b, c, d] = combined;
    std::cout << a << b << c << d << "\n";  // 输出：12a3.14
    return 0;
}

4. 比较操作

std::tuple 支持 ==、!=、<、>、<=、>= 等比较运算符，按元素顺序逐一比较：

#include <tuple>
#include <iostream>

int main() {
    auto t1 = std::make_tuple(1, 2);
    auto t2 = std::make_tuple(1, 3);
    auto t3 = std::make_tuple(2, 1);
    
    std::cout << (t1 < t2) << "\n";  // 输出：1（true，第二个元素 2 < 3）
    std::cout << (t1 < t3) << "\n";  // 输出：1（true，第一个元素 1 < 2）
    return 0;
}

五、应用场景

1. 函数返回多个值：无需定义结构体，直接返回 tuple 即可返回多个不同类型的值：

   #include <tuple>
   #include <string>
   
   // 返回 (int, string, double) 三个值
   std::tuple<int, std::string, double> get_info() {
       return std::make_tuple(20, "Alice", 90.5);
   }
   
   int main() {
       auto [age, name, score] = get_info();  // 结构化绑定接收返回值
       return 0;
   }
   

2. 泛型编程：在模板中作为参数或返回值，处理不确定类型的多元素集合。

3. 替代简单结构体：当需要临时存储多个不同类型的数据，且无需为成员命名时，比结构体更简洁。

总结

std::tuple 是处理固定大小、异质元素集合的强大工具，尤其在需要返回多个值或泛型编程中非常实用。C++17 的结构化绑定极大简化了其访问方式，使其成为日常开发中的常用类型。