结构化绑定

本节解决什么问题

当函数需要返回多个值（如成功标志 + 数据），或者遍历 map 时需要同时拿到 key 和 value，在 C++17 之前需要借助 std::pair / std::tuple + std::get<>() 或 .first / .second，代码冗长且不易读。

结构化绑定让你可以一行语句把复合类型（pair、tuple、结构体）分解成独立的变量，代码清晰很多。

这个特性是什么

结构化绑定（Structured Bindings）是 C++17 引入的语法，允许你将一个结构体、pair、tuple 或数组的元素"绑定"到独立的变量名上。

C++ 标准版本

C++17。编译本节完整示例时，需要启用 C++17 或更高标准，例如：

g++ example.cpp -std=c++17

需要的头文件

不需要额外头文件。结构化绑定是语言特性。如果用于 tuple 需要 <tuple>，用于 pair 需要 <utility>。

从 C++17 前的写法到结构化绑定

C++17 之前没有统一的“解包”语法。面对不同的复合类型，需要使用各自的访问方式：

以 std::pair 为例，C++17 之前需要分别访问 first 和 second：

std::pair<int, bool> result = {5, true};

// C++17 之前：通过 pair 固定的成员名 first 和 second 取出两个值。
int value = result.first;
bool ok = result.second;

C++17 开始，可以使用结构化绑定一次取出两个值，并根据含义为它们命名：

std::pair<int, bool> result = {5, true};

// C++17：value 对应 result.first，ok 对应 result.second。
auto [value, ok] = result;

结构化绑定没有改变 pair、tuple、结构体或数组本身，只是提供了一套统一、简洁的取值语法。方括号中的变量按元素或成员的原有顺序一一对应。

基本语法

// 以下三种写法都是 C++17 开始支持的结构化绑定。
auto [变量1, 变量2, ...] = 表达式;        // 值绑定：通常会得到各元素的副本。
auto& [变量1, 变量2, ...] = 表达式;       // 引用绑定：可以通过变量修改原对象。
const auto& [变量1, 变量2, ...] = 表达式;  // 只读引用绑定：不拷贝，也不允许修改。

常用用法

下表中的写法都需要启用 C++17 或更高版本：

示例代码

示例 1：函数返回 pair——从 C++17 前的成员访问到结构化绑定

#include <iostream>
#include <utility>  // for std::pair

// 返回两个值的函数
std::pair<int, bool> divide(int a, int b)
{
    if (b == 0)
    {
        return {0, false};  // 除数为 0，返回失败
    }
    return {a / b, true};   // 返回结果和成功标志
}

int main()
{
    // C++17 之前：先接收完整的 pair 对象。
    const std::pair<int, bool> old_result = divide(10, 2);

    // pair 的 first 是第一个值，这里代表除法结果。
    const int old_value = old_result.first;

    // pair 的 second 是第二个值，这里代表操作是否成功。
    const bool old_ok = old_result.second;

    if (old_ok)
    {
        std::cout << "before C++17: 10 / 2 = " << old_value << "\n";
    }

    // C++17：结构化绑定把返回的 pair 按顺序拆成 value 和 ok。
    // value 对应 pair.first，ok 对应 pair.second。
    const auto [value, ok] = divide(10, 2);
    if (ok)
    {
        std::cout << "C++17: 10 / 2 = " << value << "\n";
    }

    // C++17：同样的方法也可以接收失败结果。
    const auto [failed_value, failed_ok] = divide(10, 0);

    // failed_ok 为 false，说明 failed_value 不是有效的除法结果。
    if (!failed_ok)
    {
        std::cout << "10 / 0: division failed\n";
    }

    return 0;
}

运行结果：

before C++17: 10 / 2 = 5
C++17: 10 / 2 = 5
10 / 0: division failed

示例 2：tuple 和数组——从逐项访问到 C++17 结构化绑定

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

// 返回多个值
std::tuple<std::string, int, double> get_student_info()
{
    return {"Alice", 20, 3.8};  // 姓名、年龄、GPA
}

int main()
{
    // C++17 之前：先保存完整的 tuple。
    const auto old_info = get_student_info();

    // std::get<下标>() 按位置访问 tuple，编号从 0 开始。
    const std::string& old_name = std::get<0>(old_info);
    const int old_age = std::get<1>(old_info);
    const double old_gpa = std::get<2>(old_info);

    std::cout << "before C++17 tuple: "
              << old_name << ", " << old_age << ", " << old_gpa << "\n";

    // C++17：结构化绑定按 tuple 中元素的顺序声明三个变量。
    // const auto& 表示只读引用，可以避免复制 tuple 中的 string。
    const auto& [name, age, gpa] = old_info;
    std::cout << "C++17 tuple: "
              << name << ", " << age << ", " << gpa << "\n";

    int numbers[] = {10, 20, 30};

    // C++17 之前：使用下标逐个访问数组元素。
    std::cout << "before C++17 array: "
              << numbers[0] << ", " << numbers[1] << ", " << numbers[2] << "\n";

    // C++17：数组有三个元素，所以左侧也必须声明三个名字。
    // 这里没有写 &，因此 a、b、c 是三个元素的副本。
    const auto [a, b, c] = numbers;
    std::cout << "C++17 array: " << a << ", " << b << ", " << c << "\n";

    return 0;
}

运行结果：

before C++17 tuple: Alice, 20, 3.8
C++17 tuple: Alice, 20, 3.8
before C++17 array: 10, 20, 30
C++17 array: 10, 20, 30

示例 3：结构体——从成员访问到 C++17 结构化绑定

#include <iostream>
#include <string>

struct Point
{
    double x;
    double y;
    double z;
};

Point midpoint(const Point& p1, const Point& p2)
{
    return {
        (p1.x + p2.x) / 2.0,
        (p1.y + p2.y) / 2.0,
        (p1.z + p2.z) / 2.0
    };
}

int main()
{
    Point p1{1.0, 2.0, 3.0};
    Point p2{5.0, 6.0, 7.0};

    // C++17 之前：先接收完整的结构体，再通过成员名访问数据。
    const Point old_middle = midpoint(p1, p2);
    std::cout << "before C++17 midpoint: ("
              << old_middle.x << ", "
              << old_middle.y << ", "
              << old_middle.z << ")\n";

    // C++17：结构化绑定按成员的声明顺序解包结构体。
    // x 对应 Point::x，y 对应 Point::y，z 对应 Point::z。
    const auto [x, y, z] = midpoint(p1, p2);
    std::cout << "C++17 midpoint: (" << x << ", " << y << ", " << z << ")\n";

    // C++17：也可以直接解包临时创建的结构体对象。
    const auto [a, b, c] = Point{10.0, 20.0, 30.0};
    std::cout << "C++17 temporary point: ("
              << a << ", " << b << ", " << c << ")\n";

    return 0;
}

运行结果：

before C++17 midpoint: (3, 4, 5)
C++17 midpoint: (3, 4, 5)
C++17 temporary point: (10, 20, 30)

示例 4：map——对比 C++17 前后的插入结果和遍历写法

#include <iostream>
#include <map>
#include <string>

int main()
{
    std::map<std::string, int> scores;

    // map::insert 返回一个 pair<iterator, bool>：
    // first 是指向相应元素的迭代器，second 表示是否插入成功。

    // C++17 之前：先接收完整的 pair，再分别读取 first 和 second。
    const auto old_insert_result = scores.insert({"Alice", 85});
    const auto old_it = old_insert_result.first;
    const bool old_inserted = old_insert_result.second;

    if (old_inserted)
    {
        // 迭代器的 second 是 map 元素的 value，这里是 Alice 的分数。
        std::cout << "before C++17 insert: Alice inserted, score: "
                  << old_it->second << "\n";
    }

    // C++17：直接把 insert 返回的 pair 解包为迭代器和成功标志。
    // 由于 Alice 已经存在，这次重复插入会失败。
    const auto [it, inserted] = scores.insert({"Alice", 100});
    if (!inserted)
    {
        std::cout << "C++17 insert: Alice already exists, score: "
                  << it->second << "\n";
    }

    // 添加另外两个元素，供下面演示遍历使用。
    scores.insert({"Bob", 92});
    scores.insert({"Charlie", 78});

    // C++17 之前：范围 for 每次取得一个 pair。
    // pair.first 是 map 的 key，pair.second 是 map 的 value。
    std::cout << "\nbefore C++17 traversal:\n";
    for (const auto& pair : scores)
    {
        std::cout << "  " << pair.first << ": " << pair.second << "\n";
    }

    // C++17：在范围 for 中使用结构化绑定，直接命名 key 和 value。
    // const auto& 表示只读引用，既不复制元素，也不会修改 map。
    std::cout << "C++17 traversal:\n";
    for (const auto& [name, score] : scores)
    {
        std::cout << "  " << name << ": " << score << "\n";
    }

    return 0;
}

运行结果：

before C++17 insert: Alice inserted, score: 85
C++17 insert: Alice already exists, score: 85

before C++17 traversal:
  Alice: 85
  Bob: 92
  Charlie: 78
C++17 traversal:
  Alice: 85
  Bob: 92
  Charlie: 78

运行结果

见上方每个示例的"运行结果"。

示例中的关键语法解释

auto [a, b] 和 auto& [a, b] 的区别

下面讨论的 auto [a, b]、auto& [a, b] 都是 C++17 结构化绑定语法。结构化绑定不写 & 时通常会产生副本；遍历大对象或想修改原数据时，需要考虑使用引用。

C++17 之前没有结构化绑定。修改 map 的 value 时，通常取得整个 pair 的引用，再修改它的 second：

// C++17 之前：pair.second 是 map 元素的 value。
for (auto& pair : scores)
{
    pair.second += 10;
}

示例 5：C++17 结构化绑定中，修改 map 的 value 必须使用引用

#include <iostream>
#include <map>
#include <string>

int main()
{
    std::map<std::string, int> scores = {
        {"Alice", 85},
        {"Bob", 92}
    };

    // C++17：没有写 &，name 和 score 不引用 map 中的原元素。
    // 每轮循环得到的是当前 key 和 value 的副本。
    for (auto [name, score] : scores)
    {
        // 这里只修改局部变量 score，scores 中的原分数不会变化。
        score += 10;
    }

    std::cout << "after auto copy:\n";

    // C++17：const auto& 不复制 map 元素，适合只读输出。
    for (const auto& [name, score] : scores)
    {
        std::cout << name << ": " << score << "\n";
    }

    // C++17：auto& 让 name 和 score 引用 map 中的原元素。
    for (auto& [name, score] : scores)
    {
        // score 是 value 的引用，因此这次会修改原 map 中的分数。
        score += 10;
    }

    std::cout << "after auto& reference:\n";

    // 修改完成后再次只读遍历，确认新分数已经保存在 map 中。
    for (const auto& [name, score] : scores)
    {
        std::cout << name << ": " << score << "\n";
    }

    return 0;
}

运行结果：

after auto copy:
Alice: 85
Bob: 92
after auto& reference:
Alice: 95
Bob: 102

注意：map 的 key 仍然不能改。即使使用 C++17 的 auto& [name, score]，name 也是只读的，因为 map 必须保证 key 不变，才能维持内部的排序规则。

常见错误

错误 1：变量个数不匹配

// C++17：右侧 tuple 有三个元素，左侧却只有两个变量，无法一一对应。
auto [x, y] = std::make_tuple(1, 2, 3);  // ❌ 编译错误

正确做法：变量个数必须等于复合类型的元素个数。

错误 2：解包非公有成员的结构体

struct A { private: int x; public: int y; };
A obj;

// C++17：此处不能访问私有成员 x，因此不能这样进行结构化绑定。
auto [x, y] = obj;  // ❌ 编译错误

正确做法：在使用结构化绑定的位置，所有被绑定的成员都必须可以访问。对初学阶段常见的普通结构体来说，最直观的做法是让这些成员保持 public。

错误 3：用 auto 而不是 auto& 导致修改无效

// C++17：没有写 &，k 和 v 是从 map 元素得到的副本。
auto [k, v] = *map.begin();

// 这里只修改局部变量 v，不会修改 map 中的 value。
v = 100;

正确做法：要修改原值用 auto& [k, v] = ...。

使用建议

1. 函数返回多值时优先用 std::tuple/std::pair + 结构化绑定，而不是输出参数。
2. C++17 中只读遍历 map 时优先用 const auto& [key, value]，避免拷贝，也能清楚表达 key 和 value 的含义。
3. 解包 insert 返回值：C++17 的 auto [it, inserted] = map.insert(...) 比继续使用 .first、.second 更直观。
4. 需要修改原数据时使用 auto&；只读且不想拷贝时使用 const auto&。
5. 维护 C++17 以前的项目时继续使用原有访问方式：pair 用 .first/.second，tuple 用 std::get<N>()。

小结

• C++17 之前需要通过 .first/.second、std::get<N>()、成员名或数组下标分别取值。
• C++17 结构化绑定可以把 pair / tuple / 结构体 / 数组分解成独立变量。
• C++17 基本语法是 auto [var1, var2, ...] = expression。
• 遍历 map 时 [key, value] 是最佳实践（C++17）。
• insert 返回值用 [iterator, bool] 解包非常清晰。