C++学习笔记-结构化绑定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

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

std::tuple<std::string, int> CreatePerson()
{
    return {"Jerry", 28};
}

int main()
{
    std::cout << "=== Basic Structured Bindings ===" << std::endl;
    
    // 传统方法
    std::tuple<std::string, int> person = CreatePerson();
    std::string& name = std::get<0>(person);
    int age = std::get<1>(person);
    
    std::cout << "Traditional way: " << name << ", " << age << std::endl;
    
    // 使用std::tie
    std::string name2;
    int age2;
    std::tie(name2, age2) = CreatePerson();
    
    std::cout << "Using std::tie: " << name2 << ", " << age2 << std::endl;
    
    // 结构化绑定（需要C++17标准）
    auto [name3, age3] = CreatePerson();
    /*
     * 右键项目->属性->C/C++->语言->C++语言标准->C++17
     */
    
    std::cout << "Structured bindings: " << name3 << ", " << age3 << std::endl;
    
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101

#include <iostream>
#include <tuple>
#include <array>
#include <utility>
#include <map>

void TupleBindings()
{
    std::cout << "=== Tuple Bindings ===" << std::endl;
    
    // 三元组
    std::tuple<int, double, std::string> data{42, 3.14, "Hello"};
    auto [i, d, s] = data;
    
    std::cout << "Tuple: " << i << ", " << d << ", " << s << std::endl;
    
    // 修改绑定的值
    i = 100;
    std::cout << "Modified i: " << i << std::endl;
    std::cout << "Original tuple: " << std::get<0>(data) << std::endl; // 原始值不变
    
    // 引用绑定
    auto& [ri, rd, rs] = data;
    ri = 200;
    std::cout << "Reference binding - modified ri: " << ri << std::endl;
    std::cout << "Original tuple after reference modification: " << std::get<0>(data) << std::endl;
}

void PairBindings()
{
    std::cout << "\n=== Pair Bindings ===" << std::endl;
    
    std::pair<std::string, int> keyValue{"score", 95};
    auto [key, value] = keyValue;
    
    std::cout << "Pair: " << key << " = " << value << std::endl;
    
    // 在map中的应用
    std::map<std::string, int> scores{
        {"Alice", 95},
        {"Bob", 87},
        {"Charlie", 92}
    };
    
    std::cout << "Map iteration with structured bindings:" << std::endl;
    for (const auto& [name, score] : scores)
    {
        std::cout << "  " << name << ": " << score << std::endl;
    }
}

void ArrayBindings()
{
    std::cout << "\n=== Array Bindings ===" << std::endl;
    
    // C风格数组
    int cArray[3] = {1, 2, 3};
    auto [a, b, c] = cArray;
    std::cout << "C array: " << a << ", " << b << ", " << c << std::endl;
    
    // std::array
    std::array<double, 4> stdArray{1.1, 2.2, 3.3, 4.4};
    auto [x, y, z, w] = stdArray;
    std::cout << "std::array: " << x << ", " << y << ", " << z << ", " << w << std::endl;
}

void StructBindings()
{
    std::cout << "\n=== Struct Bindings ===" << std::endl;
    
    struct Point
    {
        double x, y;
    };
    
    Point p{10.5, 20.3};
    auto [px, py] = p;
    std::cout << "Point: (" << px << ", " << py << ")" << std::endl;
    
    // 复杂结构体
    struct Person
    {
        std::string name;
        int age;
        double salary;
    };
    
    Person employee{"John Doe", 30, 75000.0};
    auto [empName, empAge, empSalary] = employee;
    std::cout << "Employee: " << empName << ", " << empAge << " years old, $" << empSalary << std::endl;
}

int main()
{
    TupleBindings();
    PairBindings();
    ArrayBindings();
    StructBindings();
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#include <iostream>
#include <tuple>
#include <optional>
#include <vector>
#include <algorithm>

// 返回多个计算结果
std::tuple<double, double, double> CalculateStats(const std::vector<double>& data)
{
    if (data.empty())
        return {0.0, 0.0, 0.0};
    
    double sum = 0.0;
    for (double value : data)
        sum += value;
    
    double mean = sum / data.size();
    
    auto minmax = std::minmax_element(data.begin(), data.end());
    double min = *minmax.first;
    double max = *minmax.second;
    
    return {mean, min, max};
}

// 返回操作结果和状态
std::pair<int, bool> SafeDivide(int a, int b)
{
    if (b == 0)
        return {0, false};
    return {a / b, true};
}

// 解析字符串
std::tuple<std::string, std::string, std::string> ParseName(const std::string& fullName)
{
    size_t firstSpace = fullName.find(' ');
    if (firstSpace == std::string::npos)
        return {fullName, "", ""};
    
    size_t lastSpace = fullName.rfind(' ');
    if (firstSpace == lastSpace)
        return {fullName.substr(0, firstSpace), fullName.substr(firstSpace + 1), ""};
    
    std::string first = fullName.substr(0, firstSpace);
    std::string middle = fullName.substr(firstSpace + 1, lastSpace - firstSpace - 1);
    std::string last = fullName.substr(lastSpace + 1);
    
    return {first, middle, last};
}

void MultipleReturnValuesDemo()
{
    std::cout << "=== Multiple Return Values Demo ===" << std::endl;
    
    // 统计计算
    std::vector<double> numbers{1.5, 2.8, 3.2, 1.1, 4.7, 2.3, 3.9};
    auto [mean, min, max] = CalculateStats(numbers);
    
    std::cout << "Statistics: mean=" << mean << ", min=" << min << ", max=" << max << std::endl;
    
    // 安全除法
    auto [result1, success1] = SafeDivide(10, 2);
    auto [result2, success2] = SafeDivide(10, 0);
    
    std::cout << "10 / 2 = " << result1 << " (success: " << success1 << ")" << std::endl;
    std::cout << "10 / 0 = " << result2 << " (success: " << success2 << ")" << std::endl;
    
    // 姓名解析
    auto [first1, middle1, last1] = ParseName("John Doe");
    auto [first2, middle2, last2] = ParseName("Mary Jane Smith");
    auto [first3, middle3, last3] = ParseName("Alice");
    
    std::cout << "Name 1: '" << first1 << "' '" << middle1 << "' '" << last1 << "'" << std::endl;
    std::cout << "Name 2: '" << first2 << "' '" << middle2 << "' '" << last2 << "'" << std::endl;
    std::cout << "Name 3: '" << first3 << "' '" << middle3 << "' '" << last3 << "'" << std::endl;
}

int main()
{
    MultipleReturnValuesDemo();
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <algorithm>

void ContainerIterationDemo()
{
    std::cout << "=== Container Iteration Demo ===" << std::endl;
    
    // Map迭代
    std::map<std::string, int> inventory{
        {"apples", 50},
        {"bananas", 30},
        {"oranges", 25}
    };
    
    std::cout << "Inventory:" << std::endl;
    for (const auto& [item, quantity] : inventory)
    {
        std::cout << "  " << item << ": " << quantity << std::endl;
    }
    
    // 修改map值
    for (auto& [item, quantity] : inventory)
    {
        if (item == "apples")
            quantity += 10;
    }
    
    std::cout << "\nAfter adding 10 apples:" << std::endl;
    for (const auto& [item, quantity] : inventory)
    {
        std::cout << "  " << item << ": " << quantity << std::endl;
    }
    
    // Unordered_map
    std::unordered_map<int, std::string> idToName{
        {1001, "Alice"},
        {1002, "Bob"},
        {1003, "Charlie"}
    };
    
    std::cout << "\nID to Name mapping:" << std::endl;
    for (const auto& [id, name] : idToName)
    {
        std::cout << "  ID " << id << ": " << name << std::endl;
    }
}

void AlgorithmDemo()
{
    std::cout << "\n=== Algorithm Demo ===" << std::endl;
    
    std::vector<int> numbers{5, 2, 8, 1, 9, 3};
    
    // 查找最小最大值
    auto [minIt, maxIt] = std::minmax_element(numbers.begin(), numbers.end());
    std::cout << "Min: " << *minIt << ", Max: " << *maxIt << std::endl;
    
    // 查找特定值
    auto [lower, upper] = std::equal_range(numbers.begin(), numbers.end(), 5);
    if (lower != numbers.end())
    {
        std::cout << "Found 5 at position: " << std::distance(numbers.begin(), lower) << std::endl;
    }
    
    // 分区操作
    auto partitionPoint = std::partition(numbers.begin(), numbers.end(), 
                                       [](int n) { return n % 2 == 0; });
    
    std::cout << "Even numbers: ";
    for (auto it = numbers.begin(); it != partitionPoint; ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    std::cout << "Odd numbers: ";
    for (auto it = partitionPoint; it != numbers.end(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void InsertionDemo()
{
    std::cout << "\n=== Insertion Demo ===" << std::endl;
    
    std::map<std::string, int> scores;
    
    // map的insert返回pair<iterator, bool>
    auto [it1, inserted1] = scores.insert({"Alice", 95});
    auto [it2, inserted2] = scores.insert({"Alice", 90}); // 重复键
    
    std::cout << "First insertion: " << (inserted1 ? "success" : "failed") << std::endl;
    std::cout << "Second insertion: " << (inserted2 ? "success" : "failed") << std::endl;
    std::cout << "Alice's score: " << it1->second << std::endl;
    
    // set的insert
    std::set<int> uniqueNumbers;
    auto [setIt1, setInserted1] = uniqueNumbers.insert(42);
    auto [setIt2, setInserted2] = uniqueNumbers.insert(42); // 重复值
    
    std::cout << "Set first insertion: " << (setInserted1 ? "success" : "failed") << std::endl;
    std::cout << "Set second insertion: " << (setInserted2 ? "success" : "failed") << std::endl;
}

int main()
{
    ContainerIterationDemo();
    AlgorithmDemo();
    InsertionDemo();
    
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

#include <iostream>
#include <tuple>

// 方法1：使用tuple_size和tuple_element特化
struct Point3D
{
    double x, y, z;
    
    Point3D(double x, double y, double z) : x(x), y(y), z(z) {}
};

// 为Point3D启用结构化绑定
namespace std
{
    template<>
    struct tuple_size<Point3D> : integral_constant<size_t, 3> {};
    
    template<>
    struct tuple_element<0, Point3D> { using type = double; };
    
    template<>
    struct tuple_element<1, Point3D> { using type = double; };
    
    template<>
    struct tuple_element<2, Point3D> { using type = double; };
}

// get函数重载
template<size_t I>
double& get(Point3D& p)
{
    if constexpr (I == 0) return p.x;
    else if constexpr (I == 1) return p.y;
    else if constexpr (I == 2) return p.z;
}

template<size_t I>
const double& get(const Point3D& p)
{
    if constexpr (I == 0) return p.x;
    else if constexpr (I == 1) return p.y;
    else if constexpr (I == 2) return p.z;
}

// 方法2：提供begin()和end()方法（类似数组）
class Vector3
{
private:
    double m_Data[3];
    
public:
    Vector3(double x, double y, double z) : m_Data{x, y, z} {}
    
    double* begin() { return m_Data; }
    double* end() { return m_Data + 3; }
    
    const double* begin() const { return m_Data; }
    const double* end() const { return m_Data + 3; }
    
    double& operator[](size_t index) { return m_Data[index]; }
    const double& operator[](size_t index) const { return m_Data[index]; }
};

// 方法3：转换为tuple
struct Color
{
    uint8_t r, g, b, a;
    
    Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) : r(r), g(g), b(b), a(a) {}
    
    // 提供到tuple的转换
    operator std::tuple<uint8_t&, uint8_t&, uint8_t&, uint8_t&>()
    {
        return std::tie(r, g, b, a);
    }
    
    operator std::tuple<const uint8_t&, const uint8_t&, const uint8_t&, const uint8_t&>() const
    {
        return std::tie(r, g, b, a);
    }
};

void CustomTypeBindingsDemo()
{
    std::cout << "=== Custom Type Bindings Demo ===" << std::endl;
    
    // Point3D示例
    Point3D point(1.0, 2.0, 3.0);
    auto [x, y, z] = point;
    std::cout << "Point3D: (" << x << ", " << y << ", " << z << ")" << std::endl;
    
    // 修改值
    auto& [rx, ry, rz] = point;
    rx = 10.0;
    std::cout << "Modified Point3D: (" << point.x << ", " << point.y << ", " << point.z << ")" << std::endl;
    
    // Vector3示例（注意：这种方法只适用于固定大小的容器）
    Vector3 vec(4.0, 5.0, 6.0);
    auto [vx, vy, vz] = vec;
    std::cout << "Vector3: (" << vx << ", " << vy << ", " << vz << ")" << std::endl;
    
    // Color示例
    Color color(255, 128, 64, 255);
    auto [r, g, b, a] = color;
    std::cout << "Color: RGBA(" << (int)r << ", " << (int)g << ", " << (int)b << ", " << (int)a << ")" << std::endl;
}

int main()
{
    CustomTypeBindingsDemo();
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <map>
#include <optional>

// 文件操作
std::tuple<bool, std::string> ReadFile(const std::string& filename)
{
    std::ifstream file(filename);
    if (!file.is_open())
        return {false, ""};
    
    std::stringstream buffer;
    buffer << file.rdbuf();
    return {true, buffer.str()};
}

// 解析CSV行
std::vector<std::string> ParseCSVLine(const std::string& line)
{
    std::vector<std::string> fields;
    std::stringstream ss(line);
    std::string field;
    
    while (std::getline(ss, field, ','))
    {
        fields.push_back(field);
    }
    
    return fields;
}

// 数据库查询模拟
std::tuple<bool, std::map<std::string, std::string>> QueryUser(int userId)
{
    // 模拟数据库查询
    static std::map<int, std::map<std::string, std::string>> database{
        {1, {{"name", "Alice"}, {"email", "alice@example.com"}, {"age", "25"}}},
        {2, {{"name", "Bob"}, {"email", "bob@example.com"}, {"age", "30"}}},
        {3, {{"name", "Charlie"}, {"email", "charlie@example.com"}, {"age", "35"}}}
    };
    
    auto it = database.find(userId);
    if (it != database.end())
        return {true, it->second};
    else
        return {false, {}};
}

// 网络请求模拟
std::tuple<int, std::string, std::map<std::string, std::string>> HttpRequest(const std::string& url)
{
    // 模拟HTTP请求
    if (url.find("api/users") != std::string::npos)
    {
        return {200, R"({"users": ["Alice", "Bob", "Charlie"]})", {{"Content-Type", "application/json"}}};
    }
    else if (url.find("api/error") != std::string::npos)
    {
        return {404, "Not Found", {{"Content-Type", "text/plain"}}};
    }
    else
    {
        return {200, "<html><body>Hello World</body></html>", {{"Content-Type", "text/html"}}};
    }
}

void PracticalExamplesDemo()
{
    std::cout << "=== Practical Examples Demo ===" << std::endl;
    
    // 文件读取
    auto [fileSuccess, fileContent] = ReadFile("example.txt");
    if (fileSuccess)
    {
        std::cout << "File content: " << fileContent.substr(0, 50) << "..." << std::endl;
    }
    else
    {
        std::cout << "Failed to read file" << std::endl;
    }
    
    // CSV解析
    std::string csvLine = "John,Doe,30,Engineer,New York";
    auto fields = ParseCSVLine(csvLine);
    if (fields.size() >= 5)
    {
        auto [firstName, lastName, age, job, city] = std::make_tuple(
            fields[0], fields[1], fields[2], fields[3], fields[4]);
        std::cout << "CSV: " << firstName << " " << lastName << ", " << age 
                  << " years old, " << job << " in " << city << std::endl;
    }
    
    // 数据库查询
    auto [querySuccess, userData] = QueryUser(1);
    if (querySuccess)
    {
        std::cout << "User data:" << std::endl;
        for (const auto& [key, value] : userData)
        {
            std::cout << "  " << key << ": " << value << std::endl;
        }
    }
    
    // HTTP请求
    auto [statusCode, responseBody, headers] = HttpRequest("api/users");
    std::cout << "HTTP Response: " << statusCode << std::endl;
    std::cout << "Body: " << responseBody.substr(0, 50) << "..." << std::endl;
    std::cout << "Headers:" << std::endl;
    for (const auto& [headerName, headerValue] : headers)
    {
        std::cout << "  " << headerName << ": " << headerValue << std::endl;
    }
}

int main()
{
    PracticalExamplesDemo();
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

#include <iostream>
#include <chrono>
#include <tuple>
#include <vector>

// 性能测试
void PerformanceComparison()
{
    std::cout << "=== Performance Comparison ===" << std::endl;
    
    const int iterations = 1000000;
    std::vector<std::tuple<int, double, std::string>> data;
    
    for (int i = 0; i < 1000; ++i)
    {
        data.emplace_back(i, i * 1.5, "item" + std::to_string(i));
    }
    
    // 传统方法
    auto start = std::chrono::high_resolution_clock::now();
    for (int iter = 0; iter < iterations; ++iter)
    {
        for (const auto& item : data)
        {
            int id = std::get<0>(item);
            double value = std::get<1>(item);
            const std::string& name = std::get<2>(item);
            
            // 模拟使用
            volatile int sum = id + static_cast<int>(value) + name.length();
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto traditional = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    // 结构化绑定
    start = std::chrono::high_resolution_clock::now();
    for (int iter = 0; iter < iterations; ++iter)
    {
        for (const auto& [id, value, name] : data)
        {
            // 模拟使用
            volatile int sum = id + static_cast<int>(value) + name.length();
        }
    }
    end = std::chrono::high_resolution_clock::now();
    auto structured = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    std::cout << "Traditional method: " << traditional.count() << " ms" << std::endl;
    std::cout << "Structured bindings: " << structured.count() << " ms" << std::endl;
    std::cout << "Performance difference: " << 
                 (structured.count() - traditional.count()) << " ms" << std::endl;
}

void BestPracticesDemo()
{
    std::cout << "\n=== Best Practices Demo ===" << std::endl;
    
    // 1. 使用const引用避免不必要的拷贝
    std::map<std::string, std::vector<int>> data{
        {"numbers", {1, 2, 3, 4, 5}},
        {"primes", {2, 3, 5, 7, 11}}
    };
    
    std::cout << "1. Use const references:" << std::endl;
    for (const auto& [key, values] : data)  // const引用，避免拷贝
    {
        std::cout << "  " << key << " has " << values.size() << " elements" << std::endl;
    }
    
    // 2. 明确的类型声明（当需要时）
    std::cout << "\n2. Explicit type declarations:" << std::endl;
    std::tuple<int, double, std::string> mixed{42, 3.14, "hello"};
    
    // 自动推导
    auto [a1, b1, c1] = mixed;
    
    // 明确类型（当需要特定类型时）
    auto [a2, b2, c2] = std::tuple<long, float, std::string_view>{mixed};
    
    std::cout << "  Auto: " << typeid(a1).name() << ", " << typeid(b1).name() << std::endl;
    std::cout << "  Explicit: " << typeid(a2).name() << ", " << typeid(b2).name() << std::endl;
    
    // 3. 忽略不需要的值
    std::cout << "\n3. Ignoring unused values:" << std::endl;
    auto [id, _, name] = std::tuple<int, double, std::string>{1, 999.0, "important"};
    std::cout << "  Using only id=" << id << " and name=" << name << std::endl;
    
    // 4. 嵌套结构化绑定（C++20）
    // std::tuple<std::pair<int, int>, std::string> nested{{1, 2}, "test"};
    // auto [[x, y], str] = nested;  // C++20特性
}

int main()
{
    PerformanceComparison();
    BestPracticesDemo();
    
    return 0;
}