【LeetCode-C】Tuple & get & variant

`std::tuple`

std::tuple 是 C++11 引入的模板类，用于存储 任意数量、不同类型 的元素。它是 std::pair 的泛化版本，突破了 pair 仅能存储两个元素的限制。以下是其核心特性、使用方法和应用场景的全面解析：

核心特性

异构性
可存储不同类型元素（如 int、std::string、自定义类等），且元素类型在编译时确定。
固定大小
元素数量和类型在初始化后不可修改，但支持通过 std::tuple_cat 拼接多个元组。
灵活访问
通过索引或类型（若类型唯一）访问元素，支持编译时类型检查。

与 std::pair 对比

特性	std::tuple	std::pair
元素数量	任意数量（0 个或多个）	固定 2 个元素
元素访问方式	std::get 或结构化绑定	.first 和 .second
应用场景	多返回值、复杂数据聚合	简单键值对或双元素关系

创建与初始化

直接构造

std::tuple<int, std::string, double> t1(42, "Hello", 3.14);  // 显式指定类型
std::tuple t2(1, 2.5, "C++");                               // C++17 自动类型推导（CTAD）

使用 std::make_tuple
自动推导类型，适合泛型编程：

auto t3 = std::make_tuple(10, 3.14f, "Hello");  // 类型为 tuple<int, float, const char*>

结构化绑定（C++17+）
解构元组到变量，提升代码可读性：

auto [id, name, score] = getData();  // 假设 getData() 返回 tuple<int, string, double>

引用绑定

std::tie：绑定到已有变量的引用，用于批量赋值或解包返回值：

int a; std::string b;
std::tie(a, b) = std::make_tuple(42, "World");  // a=42, b="World"

std::forward_as_tuple：创建包含转发引用的元组，避免拷贝：

auto t4 = std::forward_as_tuple(x, std::move(y));  // 类型为 tuple<int&, int&&>

元素访问

通过索引访问
使用 std::get<N>(tuple)，索引从 0 开始：

int num = std::get<0>(t1);  // 获取第一个元素
std::get<1>(t1) = "Hi";     // 修改第二个元素

通过类型访问（需类型唯一）

double val = std::get<double>(t1);  // 若存在多个 double 类型元素会报错

编译时元信息查询
- std::tuple_size<decltype(tuple)>::value：获取元素数量。
- std::tuple_element<N, decltype(tuple)>::type：获取第 N 个元素的类型。

应用场景

函数返回多值
替代 struct 或指针参数，简化接口设计：

std::tuple<int, std::string, bool> processData() {
    return {42, "success", true};
}

异构数据聚合
存储复杂数据组合，如数据库查询结果或配置项：

std::tuple<std::string, int, std::vector<float>> record("ProductA", 100, {1.2f, 3.4f});

结合 std::apply 调用函数
将元组元素解包为函数参数：

void print(int a, const std::string& b) { /*...*/ }
std::tuple args(10, "Test");
std::apply(print, args);  // 输出：10 - Test

泛型编程与元编程
用于模板参数展开、类型操作（如拼接、删除元素）。

高级特性（C++17+）

结构化绑定增强
直接解包元组到新变量，无需提前声明：
```
auto [x, y, z] = std::make_tuple(1, 2.5, "Hi");
```
推导指南（CTAD）
简化构造语法，自动推导元素类型：
```
std::tuple t(1, "Hello");  // 类型为 tuple<int, const char*>
```

std::make_from_tuple
使用元组元素构造对象：

auto vec = std::make_from_tuple<std::vector<int>>(std::tuple(5, 42));  // {42, 42, 42, 42, 42}

注意事项

索引越界
访问不存在的索引会导致编译错误，可用 static_assert 检查范围：
```
static_assert(std::tuple_size_v<decltype(t1)> > 2, "Index out of range");
```
类型歧义
通过类型访问元素时，若类型重复需改用索引访问。
引用生命周期
使用 std::tie 或 std::forward_as_tuple 时需确保绑定对象的有效性。

总结

std::tuple 是 C++ 中处理异构数据的核心工具，尤其适用于需要灵活组合多种类型数据的场景。结合 C++17 的结构化绑定和推导指南，代码可读性和开发效率显著提升。在泛型编程中，其与 std::apply、std::tuple_cat 等函数的配合，进一步扩展了应用边界。

`std::get`

std::get 并非仅用于 std::tuple，它在 C++ 标准库中支持多种容器和类型的元素访问。以下是其核心应用场景及具体用法：

`std::get` 的适用范围

std::tuple（元组）
这是 std::get 最典型的应用场景。通过索引或类型（C++14+）访问元组中的元素：

std::tuple<int, std::string, double> t(42, "Hello", 3.14);
int val = std::get<0>(t);       // 通过索引访问
std::string s = std::get<1>(t); 
double d = std::get<double>(t); // 通过类型访问（需唯一）

std::pair（键值对）
虽然 std::pair 有 .first 和 .second 成员，但 std::get 同样支持通过索引访问：

std::pair<int, double> p(10, 2.5);
int key = std::get<0>(p);   // 等价于 p.first
double value = std::get<1>(p); // 等价于 p.second

std::array（静态数组）
支持通过索引访问数组元素，与常规数组的 [] 操作符类似：
```
std::array<int, 5> arr{1, 2, 3, 4, 5};
int third = std::get<2>(arr); // 值为 3
```

std::variant（类型安全联合）
用于访问 std::variant 中当前存储的值，需确保类型匹配，否则抛出 std::bad_variant_access 异常：

std::variant<int, std::string> v = "Hello";
try {
    std::string s = std::get<std::string>(v); // 正确获取值
} catch (const std::bad_variant_access& e) {
    // 处理类型不匹配异常
}

自定义类型
通过为自定义类型实现 std::get 的特化版本，可扩展其功能。例如：

struct Foo { int a; double b; std::string c; };

// 实现特化版本的 std::get
template <size_t N> auto& get(Foo& f) {
    static_assert(N < 3);
    if constexpr (N == 0) return f.a;
    else if constexpr (N == 1) return f.b;
    else return f.c;
}

Foo f{1, 2.5, "Test"};
int x = std::get<0>(f); // 1

`std::get` 的核心特性

编译时类型检查
• 索引有效性在编译时验证，避免运行时越界错误。 • 类型匹配错误（如 std::variant）在运行时抛出异常。
灵活访问方式
• 索引访问：适用于所有支持 std::get 的容器。 • 类型访问（C++14+）：仅适用于 std::tuple 和 std::variant，且类型需唯一。
引用语义
返回元素的引用，可直接修改容器内的值：
```
std::get<0>(t) = 100; // 修改元组的第一个元素
```

与其他访问方式的对比

访问方式	适用容器	特点
`std::get`	`tuple`、`pair`、`array`、`variant`、自定义类型	类型安全，支持编译时检查
`.first`/`.second`	`std::pair`	仅限两个元素，代码直观
`[]` 操作符	`std::array`、`std::vector`	仅支持索引访问，不适用于异构容器
`std::visit`	`std::variant`	多态处理，需配合访问器模式使用

注意事项

索引越界
使用超出范围的索引会导致编译错误（如 std::get<5> 访问仅有3个元素的元组）。
类型匹配
对 std::variant 使用 std::get 时需确保当前存储的类型与请求的类型一致，否则触发异常。
自定义类型支持
需手动实现特化版本的 std::get，并遵循标准库的引用和移动语义规则。

总结

std::get 是 C++ 中一个高度通用的访问工具，支持多种标准库容器及自定义类型。其核心优势在于 类型安全性 和 编译时检查，尤其适合需要精确控制元素访问的场景（如元组解包、变体类型操作）。对于需要动态类型处理的场景（如不确定 std::variant 的当前类型），建议结合 std::holds_alternative 或 std::visit 使用以提升代码健壮性。

`std::variant`

C++ `std::variant` 全面解析

std::variant 是 C++17 引入的类型安全的联合体（tagged union），用于在运行时存储和管理多个预定义类型中的某一个值。它结合了传统联合体的灵活性和现代 C++ 的类型安全性，适用于需要处理多种异构数据的场景。

核心特性

类型安全
与传统的 C 风格 union 不同，std::variant 在编译时严格检查类型有效性。若尝试访问非当前存储的类型，会抛出 std::bad_variant_access 异常，避免未定义行为。
多类型存储
可存储预定义类型集合中的任意一种值，例如 std::variant<int, double, std::string> 可容纳整数、浮点数或字符串。
自动生命周期管理
自动处理值的构造、析构和赋值，无需手动管理内存。
丰富的访问接口
支持通过类型、索引或访问者模式（Visitor Pattern）操作存储的值，如 std::get、std::visit 和 std::holds_alternative。

基本用法

1. 定义与初始化

#include <variant>
#include <string>

std::variant<int, double, std::string> v;  // 默认存储第一个类型（int）
v = 3.14;      // 存储 double
v = "Hello";   // 存储 std::string

就地构造：避免临时对象拷贝：

v.emplace<std::string>("Construct in-place");

2. 类型检查

使用 std::holds_alternative 检查当前存储的类型：

if (std::holds_alternative<int>(v)) {
    std::cout << "Current type: int\n";
} else if (std::holds_alternative<std::string>(v)) {
    std::cout << "Current type: string\n";
}

3. 访问值

通过类型或索引：

try {
    int num = std::get<int>(v);        // 按类型访问
    double d = std::get<1>(v);         // 按索引访问（索引从 0 开始）
} catch (const std::bad_variant_access& e) {
    std::cerr << "Error: " << e.what() << "\n";
}

安全指针访问（std::get_if）：

if (auto* p = std::get_if<double>(&v)) {
    std::cout << "Double value: " << *p << "\n";
}

高级用法

1. 访问者模式（`std::visit`）

通过泛型 Lambda 或自定义访问者处理所有可能的类型：

// 泛型 Lambda
std::visit([](auto&& arg) {
    std::cout << "Value: " << arg << "\n";
}, v);

// 自定义访问者
struct Visitor {
    void operator()(int i) { /* 处理 int */ }
    void operator()(const std::string& s) { /* 处理 string */ }
};
std::visit(Visitor{}, v);

2. 状态查询与异常处理

获取当前类型索引：

size_t idx = v.index();  // 返回当前类型的索引（0, 1, 2...）

无效状态检测：

if (v.valueless_by_exception()) {
    // 因异常导致无有效值
}

3. 与 C++20 新特性结合

结构化绑定（C++17+）：

auto [value] = std::get<0>(v);  // 解包特定类型的值

单子操作（C++26+）：

v.visit([](auto&& val) { /* ... */ });  // 成员函数版本的 visit

与传统 `union` 的对比

特性	`std::variant`	C `union`
类型安全性	编译时检查，避免未定义行为	无，需手动管理活跃类型
生命周期管理	自动构造/析构	手动管理
访问方式	类型/索引/访问者模式	仅通过成员名访问
异常支持	支持 `std::bad_variant_access`	无

注意事项

性能考量
std::variant 的内存占用为所有可能类型中最大的一个，外加类型标签开销。
默认构造限制
若第一个类型不可默认构造，需显式初始化或使用 std::monostate 占位。
类型唯一性
若多个类型相同（如 std::variant<int, int>），需通过索引访问。

总结

std::variant 提供了一种现代、安全的方式处理多类型数据，适用于配置文件解析、状态机实现、多态替代等场景。结合 std::visit 和 C++20 新特性，可显著提升代码的灵活性和可维护性。对于需要兼容旧代码或极致性能的场景，传统 union 仍有其价值，但在大多数情况下，std::variant 是更优选择。

`std::visit`

std::visit 是 C++17 引入的一个核心函数模板，用于以类型安全的方式访问 std::variant（类型安全联合体）中存储的值。它通过 访问者模式（Visitor Pattern）实现对不同数据类型的动态分发，避免了手动类型检查的繁琐，同时确保代码的简洁性和安全性。

核心功能与定义

核心功能
- 类型安全访问：根据 std::variant 当前存储的类型，自动调用匹配的处理逻辑，避免未定义行为。
- 多态分派：支持单参数或多参数 std::variant 的联合访问，适用于复杂数据类型组合的场景。
- 泛型兼容性：可调用对象（如 Lambda、函数对象）需覆盖所有可能的类型分支，否则会触发编译错误。
函数原型
```
template <class Visitor, class... Variants>
constexpr decltype(auto) visit(Visitor&& vis, Variants&&... vars);
```
- Visitor：可调用对象（如 Lambda 表达式或函数对象），需覆盖所有可能的类型组合。
- Variants：一个或多个 std::variant 对象。

基本用法

1. 使用 Lambda 表达式

通过泛型 Lambda 简化对 std::variant 的访问：

#include <variant>
#include <iostream>

int main() {
    std::variant<int, std::string> var = "Hello";
    std::visit([](auto&& arg) { 
        std::cout << arg << std::endl; 
    }, var);  // 输出 "Hello"
}

优点：代码简洁，无需显式类型判断。

2. 使用函数对象

定义包含多个重载 operator() 的访问者对象，实现类型分派：

struct Visitor {
    void operator()(int i) { std::cout << "Integer: " << i << std::endl; }
    void operator()(const std::string& s) { std::cout << "String: " << s << std::endl; }
};

std::variant<int, std::string> var = 42;
std::visit(Visitor{}, var);  // 输出 "Integer: 42"

适用场景：需要针对不同类型执行不同逻辑的复杂操作。

高级用法

1. 多参数联合访问

同时处理多个 std::variant 对象，需覆盖所有可能的类型组合：

std::variant<int, double> var1 = 3.14;
std::variant<std::string, char> var2 = 'X';

std::visit([](auto a, auto b) { 
    std::cout << a << ", " << b << std::endl; 
}, var1, var2);  // 输出 "3.14, X"

注意：参数组合数量随 std::variant 类型数量指数级增长，需谨慎设计访问者逻辑。

2. 结合 `if constexpr` 类型判断

在泛型 Lambda 中通过编译时类型判断执行不同操作：

std::visit([](auto&& value) {
    if constexpr (std::is_same_v<decltype(value), int>) {
        std::cout << "Integer: " << value << std::endl;
    } else if constexpr (std::is_same_v<decltype(value), std::string>) {
        std::cout << "String: " << value << std::endl;
    }
}, var);

优势：减少重复代码，提升可维护性。

3. 处理返回值

所有分支必须返回相同类型，否则需显式转换：

auto result = std::visit([](auto&& arg) -> int {
    if constexpr (std::is_arithmetic_v<decltype(arg)>) {
        return static_cast<int>(arg);
    } else {
        return 0;
    }
}, var);

C++20 扩展：支持指定返回类型 std::visit<int>(...)，强制统一返回值。

注意事项

未初始化 std::variant
若 std::variant 未存储有效值（如处于 valueless_by_exception 状态），调用 std::visit 会抛出 std::bad_variant_access 异常。
类型覆盖完整性
访问者必须覆盖所有可能的类型分支，否则编译失败。例如，若 std::variant 包含 int 和 std::string，访问者必须为这两种类型提供处理逻辑。
性能优化
std::visit 的分派逻辑在编译时生成，无运行时类型检查开销，适合高性能场景。

实际应用场景

数据解析
处理 JSON、XML 等格式时，动态访问不同类型的数据节点。
状态机实现
根据当前状态类型执行对应的状态转移逻辑。
GUI 事件处理
分发鼠标点击、键盘输入等不同类型的事件。

C++20 新特性

overload 辅助模板（需手动实现或使用第三方库）：
简化多类型访问者的定义：

template<typename... Ts> struct overloaded : Ts... { using Ts::operator()...; };

std::visit(overloaded{
    [](int i) { /* ... */ },
    [](std::string s) { /* ... */ }
}, var);

优势：避免显式定义函数对象类。

总结

std::visit 是处理 std::variant 的核心工具，通过编译时类型分派显著提升代码安全性和可维护性。结合 C++20 的新特性（如 overload 模板），可进一步简化复杂逻辑的实现。在需要动态处理异构数据或实现多态行为的场景中，std::visit 是不可或缺的现代 C++ 特性。

std::tuple

核心特性

创建与初始化

元素访问

应用场景

高级特性（C++17+）

注意事项

总结

std::get

std::get 的适用范围

std::get 的核心特性

与其他访问方式的对比

注意事项

总结

std::variant

C++ std::variant 全面解析

核心特性

基本用法

1. 定义与初始化

2. 类型检查

3. 访问值

高级用法

1. 访问者模式（std::visit）

2. 状态查询与异常处理

3. 与 C++20 新特性结合

与传统 union 的对比

注意事项

总结

std::visit

核心功能与定义

基本用法

1. 使用 Lambda 表达式

2. 使用函数对象

高级用法

1. 多参数联合访问

2. 结合 if constexpr 类型判断

3. 处理返回值

注意事项

实际应用场景

C++20 新特性

总结

`std::tuple`

`std::get`

`std::get` 的适用范围

`std::get` 的核心特性

`std::variant`

C++ `std::variant` 全面解析

1. 访问者模式（`std::visit`）

与传统 `union` 的对比

`std::visit`

2. 结合 `if constexpr` 类型判断