结构化绑定

本节解决什么问题

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

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

这个特性是什么

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

C++ 标准版本

C++17

需要的头文件

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

基本语法

auto [变量1, 变量2, ...] = 表达式;        // 值拷贝绑定
auto& [变量1, 变量2, ...] = 表达式;       // 引用绑定（可修改原值）
const auto& [变量1, 变量2, ...] = 表达式;  // 只读引用绑定

常用用法

示例代码

示例 1：函数返回 pair，用结构化绑定解包

#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 结构化绑定：一行解包
    auto [result, ok] = divide(10, 2);
    if (ok)
    {
        std::cout << "10 / 2 = " << result << "\n";
    }

    auto [result2, ok2] = divide(10, 0);
    if (!ok2)
    {
        std::cout << "10 / 0: division failed\n";
    }

    return 0;
}

运行结果：

10 / 2 = 5
10 / 0: division failed

示例 2：在示例 1 基础上，解包 tuple 和数组

#include <iostream>
#include <tuple>

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

int main()
{
    // 解包 tuple
    auto [name, age, gpa] = get_student_info();
    std::cout << "Name: " << name << "\n";
    std::cout << "Age: " << age << "\n";
    std::cout << "GPA: " << gpa << "\n";

    // 解包数组
    int arr[] = {10, 20, 30};
    auto [a, b, c] = arr;
    std::cout << "arr: " << a << ", " << b << ", " << c << "\n";

    return 0;
}

运行结果：

Name: Alice
Age: 20
GPA: 3.8
arr: 10, 20, 30

示例 3：在示例 2 基础上，解包结构体

#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};

    // 解包结构体
    auto [x, y, z] = midpoint(p1, p2);
    std::cout << "midpoint: (" << x << ", " << y << ", " << z << ")\n";

    // 解包返回的临时 Point 对象
    auto [a, b, c] = Point{10.0, 20.0, 30.0};
    std::cout << "point: (" << a << ", " << b << ", " << c << ")\n";

    return 0;
}

运行结果：

midpoint: (3, 4, 5)
point: (10, 20, 30)

示例 4：在 map 遍历和 insert 中应用结构化绑定

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

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

    // insert 返回 pair<iterator, bool>
    auto [it1, inserted1] = scores.insert({"Alice", 85});
    if (inserted1)
    {
        std::cout << "Alice inserted, score: " << it1->second << "\n";
    }

    // 再次插入同名（会失败）
    auto [it2, inserted2] = scores.insert({"Alice", 100});
    if (!inserted2)
    {
        std::cout << "Alice already exists, score: " << it2->second << "\n";
    }

    // 再插入几个
    scores.insert({"Bob", 92});
    scores.insert({"Charlie", 78});

    // 遍历 map，结构化绑定解包 key/value
    std::cout << "\nAll scores:\n";
    for (const auto& [name, score] : scores)
    {
        std::cout << "  " << name << ": " << score << "\n";
    }

    return 0;
}

运行结果：

Alice inserted, score: 85
Alice already exists, score: 85

All scores:
  Alice: 85
  Bob: 92
  Charlie: 78

运行结果

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

示例中的关键语法解释

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

结构化绑定默认会拷贝。遍历大对象或想修改原数据时，要写引用。

示例 5：修改 map 的 value 时必须用引用绑定

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

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

    for (auto [name, score] : scores)
    {
        score += 10;  // 修改的是拷贝
    }

    std::cout << "after auto copy:\n";
    for (const auto& [name, score] : scores)
    {
        std::cout << name << ": " << score << "\n";
    }

    for (auto& [name, score] : scores)
    {
        score += 10;  // 修改原 map 的 value
    }

    std::cout << "after auto& reference:\n";
    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 仍然不能改。即使用 auto& [name, score]，name 也是只读的，因为 map 必须保持 key 的排序规则不被破坏。

常见错误

错误 1：变量个数不匹配

auto [x, y] = std::make_tuple(1, 2, 3);  // ❌ left has 2, right has 3

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

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

struct A { private: int x; public: int y; };
A obj;
auto [x, y] = obj;  // ❌ 编译错误！结构体有私有成员时不能解包

正确做法：所有成员都必须是 public。

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

auto [k, v] = *map.begin();  // 拷贝了！
v = 100;  // 只修改了拷贝

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

使用建议

1. 函数返回多值时优先用 std::tuple/std::pair + 结构化绑定，而不是输出参数。
2. 遍历 map 永远用 for (const auto& [key, val] : map)，代码可读性最高。
3. 解包 insert 返回值：auto [it, inserted] = map.insert(...) 比 .second 更清晰。
4. auto& 用于需要修改的场景，const auto& 用于只读场景。
5. 遍历 map 时优先 const auto& [k, v]：避免拷贝，也表达只读意图。

小结

• 结构化绑定可以把 pair / tuple / 结构体 / 数组分解成独立变量。
• 语法：auto [var1, var2, ...] = expression。
• 遍历 map 时 [key, value] 是最佳实践（C++17）。
• insert 返回值用 [iterator, bool] 解包非常清晰。