怎样使用C++的结构化绑定 解构元组数组结构体的语法糖

std::tuple

std::pair

auto [变量1, 变量2, ...] = 表达式;

表达式

auto

&

&&

#include <iostream>
#include <string>

struct User {
    int id;
    std::string name;
    double balance;
};

int main() {
    User u = {101, "Alice", 123.45};

    // 使用结构化绑定解构User对象
    auto [userId, userName, userBalance] = u; 
    // 或者如果你想修改原对象，可以使用引用：
    // auto&amp; [userIdRef, userNameRef, userBalanceRef] = u;

    std::cout << "ID: " << userId << ", Name: " << userName << ", Balance: " << userBalance << std::endl;

    // 结构化绑定也适用于std::pair，因为它本质上也是一个结构体
    std::pair<std::string, int> city_pop = {"Beijing", 2154};
    auto [city, population] = city_pop;
    std::cout << "City: " << city << ", Population: " << population << std::endl;

    return 0;
}

std::array

#include <iostream>
#include <array>

int main() {
    int arr[] = {10, 20, 30};
    auto [x, y, z] = arr; // 绑定到数组的三个元素
    std::cout << "Array elements: " << x << ", " << y << ", " << z << std::endl;

    std::array<double, 2> coords = {1.23, 4.56};
    auto [lat, lon] = coords; // 绑定std::array
    std::cout << "Coordinates: Lat=" << lat << ", Lon=" << lon << std::endl;

    return 0;
}

std::tuple

#include <iostream>
#include <string>
#include <tuple> // 包含std::tuple

std::tuple<int, std::string, double> get_product_info() {
    return {1001, "Laptop", 999.99};
}

int main() {
    // 解构函数返回的元组
    auto [productId, productName, productPrice] = get_product_info();
    std::cout << "Product ID: " << productId 
              << ", Name: " << productName 
              << ", Price: " << productPrice << std::endl;

    return 0;
}

std::pair

std::tuple

// 传统方式解构std::pair
std::pair<std::string, int> result = {"Error", 404};
std::string error_msg = result.first;
int error_code = result.second;

// 传统方式解构std::tuple，使用std::tie或者std::get
std::tuple<int, std::string, double> info = {1, "Book", 29.99};
int id;
std::string name;
double price;
std::tie(id, name, price) = info; // 需要先声明变量，然后用std::tie绑定

// 或者更直接但不够优雅的std::get
// int id = std::get<0>(info);
// std::string name = std::get<1>(info);
// double price = std::get<2>(info);

.first

.second

std::tie

std::tie

std::map

std::unordered_map

// 传统遍历map
std::map<std::string, int> ages = {{"Alice", 30}, {"Bob", 25}};
for (const auto&amp;amp;amp; pair : ages) {
    std::cout << pair.first << " is " << pair.second << " years old." << std::endl;
}

pair

std::pair

.first

.second

// 使用结构化绑定遍历map
std::map<std::string, int> ages = {{"Alice", 30}, {"Bob", 25}};
for (const auto&amp;amp;amp; [name, age] : ages) { // 一目了然，name就是键，age就是值
    std::cout << name << " is " << age << " years old." << std::endl;
}

[name, age]

std::pair

std::tuple

// 假设一个函数返回操作结果和错误信息
std::pair<bool, std::string> perform_action(int data) {
    if (data > 0) {
        return {true, "Success"};
    } else {
        return {false, "Invalid data"};
    }
}

int main() {
    auto [success, message] = perform_action(10); // 直接解构
    if (success) {
        std::cout << "Action succeeded: " << message << std::endl;
    } else {
        std::cout << "Action failed: " << message << std::endl;
    }

    auto [s2, m2] = perform_action(-5);
    std::cout << "Action result 2: " << (s2 ? "Success" : "Failed") << ", Msg: " << m2 << std::endl;
    return 0;
}

std::tie

std::ignore

auto [v1, v2] = obj;

v1

v2

obj

obj

obj

struct Point { int x, y; };
int main() {
    Point p = {1, 2};
    auto [px, py] = p; // 默认情况下，px和py是p.x和p.y的拷贝
    px = 10; // 改变px不会影响p.x
    std::cout << "p.x: " << p.x << ", px: " << px << std::endl; // p.x: 1, px: 10

    auto&amp; [rx, ry] = p; // rx和ry是p.x和p.y的引用
    rx = 100; // 改变rx会影响p.x
    std::cout << "p.x: " << p.x << ", rx: " << rx << std::endl; // p.x: 100, rx: 100
    return 0;
}

auto&

const auto&

#include <iostream>
#include <string>
#include <utility>

struct TempData {
    int id;
    std::string name;
    // 构造函数和析构函数方便观察生命周期
    TempData(int i, std::string n) : id(i), name(std::move(n)) {
        std::cout << "TempData(" << id << ") constructed." << std::endl;
    }
    ~TempData() {
        std::cout << "TempData(" << id << ") destructed." << std::endl;
    }
};

TempData create_temp_data() {
    return TempData(42, "Temporary");
}

int main() {
    // 错误示例：结构化绑定到临时对象，并尝试获取引用
    // auto&amp; [id_ref, name_ref] = create_temp_data(); // 这是一个悬空引用！
    // 临时对象在表达式结束时销毁，id_ref和name_ref指向的内存已无效
    // std::cout << id_ref << ", " << name_ref << std::endl; // 行为未定义

    // 正确的做法是让临时对象延长生命周期，或者直接拷贝
    // 方式一：拷贝（如果对象不大，且不需要修改原值）
    auto [id_copy, name_copy] = create_temp_data(); 
    std::cout << id_copy << ", " << name_copy << std::endl; // OK

    // 方式二：绑定到const引用，延长临时对象生命周期
    const auto&amp;amp;amp; [id_const_ref, name_const_ref] = create_temp_data();
    std::cout << id_const_ref << ", " << name_const_ref << std::endl; // OK，临时对象生命周期延长到该行结束

    // 方式三：先将临时对象赋值给一个具名变量
    TempData my_data = create_temp_data();
    auto&amp; [id_safe_ref, name_safe_ref] = my_data;
    std::cout << id_safe_ref << ", " << name_safe_ref << std::endl; // OK

    return 0;
}

const auto&

const

int

std::string