std::tuple学习

std::tuple 是 C++11 引入的一个固定大小的异质容器，它可以存储多种不同类型的元素。可以把它看作 std::pair 的泛化版本。

基本特性

• 固定大小：编译时确定元素个数

• 异质类型：每个元素可以是不同的类型

• 值语义：支持拷贝、移动和赋值

基本用法

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

// 创建 tuple
auto t1 = std::make_tuple(42, 3.14, "hello");
std::tuple<int, double, std::string> t2(42, 3.14, "hello");
std::tuple t3{42, 3.14, "hello"};  // C++17 类模板推导

// 访问元素
int i = std::get<0>(t1);
double d = std::get<1>(t1);
std::string s = std::get<2>(t1);

// 使用类型访问（C++14）
std::string s2 = std::get<std::string>(t1);  // 要求类型唯一

// 解包（C++17）
auto [a, b, c] = t1;  // 结构化绑定

常用操作

// 获取 tuple 大小
constexpr size_t size = std::tuple_size<decltype(t1)>::value;
// 或 C++17
size = std::tuple_size_v<decltype(t1)>;

// 获取元素类型
using FirstType = std::tuple_element<0, decltype(t1)>::type;

// 连接 tuple
auto t4 = std::tuple_cat(t1, std::make_tuple("world", true));

// 比较（要求所有元素都支持比较操作）
auto t5 = std::make_tuple(1, 2.5);
auto t6 = std::make_tuple(1, 2.5);
bool eq = (t5 == t6);  // true

// 应用函数
std::apply([](int x, double y, const std::string& z) {
    std::cout << x << ", " << y << ", " << z << '\n';
}, t1);

高级用法示例

1. 遍历 tuple（编译时）

#include <tuple>
#include <type_traits>

template<typename Tuple, typename Func, size_t... Indices>
void tuple_for_each_impl(Tuple&& tuple, Func&& func, std::index_sequence<Indices...>) {
    (func(std::get<Indices>(std::forward<Tuple>(tuple))), ...);  // C++17 折叠表达式
}

template<typename Tuple, typename Func>
void tuple_for_each(Tuple&& tuple, Func&& func) {
    constexpr size_t size = std::tuple_size<std::decay_t<Tuple>>::value;
    tuple_for_each_impl(std::forward<Tuple>(tuple), std::forward<Func>(func),
                        std::make_index_sequence<size>{});
}

// 使用
auto t = std::make_tuple(1, 2.5, "test");
tuple_for_each(t, [](const auto& item) {
    std::cout << item << ' ';
});

2. 转换 tuple 类型

template<typename Tuple, typename Func>
auto tuple_transform(Tuple&& tuple, Func&& func) {
    return std::apply([&](auto&&... args) {
        return std::make_tuple(func(std::forward<decltype(args)>(args))...);
    }, std::forward<Tuple>(tuple));
}

// 使用
auto t = std::make_tuple(1, 2.5, 3);
auto result = tuple_transform(t, [](auto x) { return x * 2; });
// result: (2, 5.0, 6)

常见应用场景

1. 多返回值

std::tuple<int, double, bool> calculate() {
    return {42, 3.14, true};
}

// C++17
auto [value, ratio, ok] = calculate();

// C++11/14
int value;
double ratio;
bool ok;
std::tie(value, ratio, ok) = calculate();

2. 替代简单结构体

// 临时组合多个值
std::vector<std::tuple<std::string, int, double>> items;
items.emplace_back("apple", 10, 0.99);
items.emplace_back("banana", 5, 0.49);

// C++17 结构化绑定遍历
for (const auto& [name, count, price] : items) {
    std::cout << name << ": " << count << " @ $" << price << '\n';
}

3. 编译时编程

template<typename... Types>
class MyClass {
    std::tuple<Types...> data;
public:
    template<size_t I>
    auto& get() { return std::get<I>(data); }
    
    template<typename T>
    auto& get() { return std::get<T>(data); }
};

性能考虑

• std::tuple 在编译时展开，没有运行时开销

• 存储效率高，元素连续存储（但实现可能添加对齐填充）

• 访问是 O(1) 编译时索引

• 适合小型、固定大小的数据聚合

与替代方案的比较

特性	std::tuple	std::pair	struct	std::array
元素类型	可不同	可不同	可不同	必须相同
大小	固定	固定	固定	固定
元素访问	std::get<I>()	.first/.second	命名成员	索引或迭代器
可读性	较低（无命名）	较低	高	中等
适合场景	泛型代码、多返回值	成对数据	明确业务逻辑	同类型序列

注意事项

1. 避免滥用：对于有明确业务含义的数据，使用命名结构体更清晰

2. 编译时间：大量使用 tuple 会显著增加编译时间

3. 调试困难：tuple 在调试器中显示不直观

4. 类型唯一：使用 std::get<Type>() 要求该类型在 tuple 中唯一

std::tuple 是 C++ 泛型编程的强大工具，特别适合编写通用库代码和处理异构数据集合。

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

int main() {
    // ✅ 每个类型都不同 - 可以通过类型访问
    auto t1 = std::make_tuple(42, 3.14, std::string("hello"));
    int i = std::get<int>(t1);           // ✅ OK，只有一个int
    double d = std::get<double>(t1);     // ✅ OK，只有一个double
    std::string s = std::get<std::string>(t1); // ✅ OK，只有一个string
    
    // ❌ 有重复类型 - 不能通过类型访问
    auto t2 = std::make_tuple(42, 100, 3.14);  // 两个int
    // int x = std::get<int>(t2);  // ❌ 编译错误！有多个int，不知道取哪个
    
    // ✅ 但仍然可以通过索引访问
    int first = std::get<0>(t2);   // ✅ 42
    int second = std::get<1>(t2);  // ✅ 100
    double d2 = std::get<2>(t2);   // ✅ 3.14
    
    // 更复杂的例子
    auto t3 = std::make_tuple(1, 2.5, 'c', 3.14f, std::string("test"));
    // int可以访问（只有一个int）
    // double可以访问（只有一个double）
    // 但不能用float访问（实际是3.14f，但float和double是不同的类型）
    float f = std::get<float>(t3);  // ✅ OK，只有一个float
    
    return 0;
}