C++17结构化绑定怎么应用 多返回值解构与元组处理实践

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

// 模拟一个返回多个值的函数
std::tuple<int, std::string, double> get_user_info(int id) {
    if (id == 101) {
        return {101, "Alice", 29.5};
    }
    return {0, "Unknown", 0.0};
}

int main() {
    // 解构一个tuple
    auto [id, name, age] = get_user_info(101);
    std::cout << "User ID: " << id << ", Name: " << name << ", Age: " << age << std::endl;

    // 解构std::pair，比如std::map::insert的返回值
    std::map<int, std::string> users;
    auto [iter, inserted] = users.insert({1, "Bob"});
    if (inserted) {
        std::cout << "Successfully inserted user: " << iter->second << std::endl;
    } else {
        std::cout << "User already exists: " << iter->second << std::endl;
    }

    return 0;
}

#include <iostream>
#include <string>

struct Point {
    int x;
    int y;
    std::string label; // 也可以包含其他类型
};

int main() {
    Point p = {10, 20, "Origin"};
    auto [px, py, plabel] = p; // 按照声明顺序绑定
    std::cout << "Point: (" << px << ", " << py << "), Label: " << plabel << std::endl;

    // 甚至可以绑定到引用，修改原对象
    auto&amp; [ref_x, ref_y, ref_label] = p;
    ref_x = 100;
    std::cout << "Modified Point x: " << p.x << std::endl; // 输出 100

    return 0;
}

#include <iostream>
#include <array>

int main() {
    int arr[] = {1, 2, 3};
    auto [a, b, c] = arr;
    std::cout << "Array elements: " << a << ", " << b << ", " << c << std::endl;

    std::array<double, 2> coords = {10.5, 20.5};
    auto [x, y] = coords;
    std::cout << "Coordinates: (" << x << ", " << y << ")" << std::endl;

    return 0;
}

// 传统方式
// std::pair<std::map<std::string, int>::iterator, bool> result = my_map.insert({"apple", 5});
// if (result.second) {
//     std::cout << "Inserted: " << result.first->first << std::endl;
// }

// 结构化绑定
std::map<std::string, int> my_map;
auto [iter, inserted] = my_map.insert({"apple", 5});
if (inserted) {
    std::cout << "Inserted: " << iter->first << std::endl;
} else {
    std::cout << "Already exists: " << iter->first << std::endl;
}

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

enum class ConfigError {
    NotFound,
    PermissionDenied,
    InvalidFormat
};

// 模拟一个配置读取函数
std::tuple<std::optional<std::string>, std::optional<ConfigError>, std::string> read_config(const std::string& key) {
    if (key == "timeout") {
        return {std::make_optional("30s"), std::nullopt, ""};
    } else if (key == "db_password") {
        return {std::nullopt, std::make_optional(ConfigError::PermissionDenied), "Access denied"};
    }
    return {std::nullopt, std::make_optional(ConfigError::NotFound), "Key not found"};
}

int main() {
    auto [value_opt, error_opt, error_msg] = read_config("timeout");
    if (value_opt) {
        std::cout << "Config 'timeout' value: " << *value_opt << std::endl;
    } else {
        std::cout << "Error reading config: " << error_msg << std::endl;
    }

    auto [value_opt2, error_opt2, error_msg2] = read_config("db_password");
    if (value_opt2) {
        // ...
    } else {
        std::cout << "Error reading config 'db_password': " << error_msg2 << " (Error code: " 
                  << static_cast<int>(*error_opt2) << ")" << std::endl;
    }
    return 0;
}

// 传统方式
// for (const auto& pair : my_map) {
//     std::cout << pair.first << ": " << pair.second << std::endl;
// }

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

int main() {
    std::map<std::string, int> ages = {
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35}
    };

    for (const auto&amp;amp; [name, age] : ages) { // 注意这里的&，避免拷贝
        std::cout << name << " is " << age << " years old." << std::endl;
    }

    // 甚至可以修改值（如果map不是const的）
    for (auto&amp; [name, age] : ages) {
        if (name == "Bob") {
            age = 26; // 直接修改map中的值
        }
    }
    std::cout << "Bob's new age: " << ages["Bob"] << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm> // for std::minmax_element

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9, 3};

    auto [min_it, max_it] = std::minmax_element(numbers.begin(), numbers.end());

    std::cout << "Min element: " << *min_it << std::endl;
    std::cout << "Max element: " << *max_it << std::endl;

    return 0;
}

#include <iostream>
#include <string>

struct UserData {
    int id;
    std::string name;
    std::string email;
};

// 函数返回一个UserData实例
UserData create_user(int id, const std::string& name, const std::string& email) {
    return {id, name, email};
}

// 函数接收一个UserData实例，并使用结构化绑定解构
void print_user_details(const UserData& user) {
    auto [uid, uname, uemail] = user; // 注意这里是拷贝，如果想避免拷贝且不修改，可以用const auto&amp;amp;
    std::cout << "User ID: " << uid << ", Name: " << uname << ", Email: " << uemail << std::endl;
}

int main() {
    UserData newUser = create_user(1, "Alice", "alice@example.com");
    print_user_details(newUser);

    // 也可以直接在调用点解构
    auto [id, name, email] = create_user(2, "Bob", "bob@example.com");
    std::cout << "Created user Bob: " << name << ", " << email << std::endl;

    return 0;
}