测试_第07章_容器.cpp

← 测试总览 · 目录

编译运行：clang++ -std=c++26 -Wall -Wextra -pthread 测试_第07章_容器.cpp -o t && ./t（需先 cd 测试/）

// 第7章测试：容器
#include <print>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <array>
#include <algorithm>
#include <numeric>
#include <string>
#include <span>

int failures = 0;
#define CHECK(expr)                                                         \
    do {                                                                    \
        if (!(expr)) {                                                      \
            ++failures;                                                     \
            std::println("FAIL 第{}行: {}", __LINE__, #expr);              \
        }                                                                   \
    } while (0)

int main() {
    // 7.1 vector 基础
    std::vector<int> v;
    v.push_back(10);
    v.push_back(20);
    CHECK(v[0] == 10 && v.at(1) == 20);
    CHECK(v.size() == 2);
    v.pop_back();
    CHECK(v.size() == 1);
    v.push_back(30);
    v.push_back(40);
    // 初始化方式
    std::vector<int> a{1, 2, 3};
    std::vector<int> c(5, 7);
    CHECK(c.size() == 5 && c[4] == 7);
    std::vector<int> d = a;
    d[0] = 99;
    CHECK(a[0] == 1);                                   // 拷贝独立

    // 7.2 遍历方式
    int sum = 0;
    for (int x : v) sum += x;                           // 10+30+40
    CHECK(sum == 80);
    for (int& x : v) x *= 2;
    CHECK(v[1] == 60);
    sum = 0;
    for (std::size_t i = 0; i < v.size(); ++i) sum += v[i];
    CHECK(sum == 160);

    // 7.3 map
    std::map<std::string, int> scores;
    scores["张三"] = 90;
    scores["李四"] = 85;
    CHECK(scores["张三"] == 90);
    CHECK(scores.contains("张三"));
    CHECK(!scores.contains("王五"));
    CHECK(scores["不存在"] == 0);                        // [] 会插入 0
    scores.erase("不存在");
    CHECK(scores.size() == 2);

    // map 遍历（有序：李四 在 张三 前，按字典序）
    std::string keys;
    for (const auto& [name, score] : scores) keys += name;
    CHECK(keys == "张三李四");
    // 注：中文字符串排序按字节序，这里顺序是固定的（UTF-8 字节序）

    // unordered_map
    std::unordered_map<std::string, int> um;
    um["x"] = 1;
    CHECK(um["x"] == 1);

    // 7.4 set
    std::set<int> s{3, 1, 2, 2, 3};
    CHECK(s.size() == 3);                               // 去重
    CHECK(s.contains(2));
    s.insert(4);
    s.erase(1);
    CHECK(s.size() == 3);

    // 7.5 pair / tuple / 结构化绑定
    std::pair<int, std::string> p{1, "一"};
    CHECK(p.first == 1 && p.second == "一");
    std::tuple<int, double, std::string> tup{1, 2.5, "x"};
    CHECK(std::get<0>(tup) == 1);
    CHECK(std::get<2>(tup) == "x");
    auto [n, dbl, str] = tup;
    CHECK(n == 1 && dbl == 2.5 && str == "x");

    // 7.6 其他容器
    std::deque<int> dq{1, 2, 3};
    dq.push_front(0);
    CHECK(dq[0] == 0 && dq.size() == 4);
    std::array<int, 3> arr{1, 2, 3};
    CHECK(arr.size() == 3);
    int raw[3] = {1, 2, 3};
    std::span<int> sp(raw);
    CHECK(sp.size() == 3);

    // 7.7 通用操作
    std::vector<int> u{5, 3, 1, 4, 2};
    std::sort(u.begin(), u.end());
    CHECK(std::is_sorted(u.begin(), u.end()));
    auto it = std::find(u.begin(), u.end(), 4);
    CHECK(it != u.end() && *it == 4);
    CHECK(std::find(u.begin(), u.end(), 99) == u.end());

    // 7.8 迭代器
    auto it2 = std::find(v.begin(), v.end(), 60);
    CHECK(it2 != v.end());
    // 迭代器失效演示：插入后旧迭代器不要再用
    std::vector<int> w{1, 2, 3};
    auto old = w.begin();
    (void)old;
    w.push_back(4);                                     // 可能触发扩容
    // 此时 old 已失效——再解引用是未定义行为，绝不能写
    CHECK(w.size() == 4);

    // 求和用算法
    CHECK(std::accumulate(v.begin(), v.end(), 0) == 160);

    if (failures == 0) std::println("全部通过");
    return failures;
}