C++ STL 问题：容器使用不当导致的错误

C++ 标准模板库（STL）为开发者提供了强大且灵活的数据结构工具，但容器使用不当往往会引发隐蔽且危险的错误。这些错误可能在开发阶段难以察觉，却在生产环境中导致程序崩溃、数据损坏或难以追踪的异常行为。本文将深入剖析 STL 容器使用中的典型错误模式，并提供切实可行的解决方案。

第一类错误：迭代器失效

迭代器失效是 STL 容器使用中最常见也是最危险的问题之一。当容器结构发生变化时，原有的迭代器可能变得无效，继续使用将导致未定义行为。

向量（vector）扩容导致的失效

vector 在容量不足时会重新分配内存，将原有元素复制到新的存储区域。此时，所有指向原有元素的迭代器、指针和引用都会失效。

std::vector<int> numbers = {1, 2, 3, 4, 5};
auto it = numbers.begin() + 2;  // 指向元素 3

numbers.push_back(6);  // 可能触发扩容
numbers.push_back(7);  // 继续添加，可能再次扩容

// 此时 it 已经失效，访问它将导致崩溃
std::cout << *it << std::endl;  // 未定义行为！

正确做法：在修改容器后，重新获取迭代器。

std::vector<int> numbers = {1, 2, 3, 4, 5};
auto it = numbers.begin() + 2;

numbers.push_back(6);
numbers.push_back(7);

// 重新获取迭代器
it = numbers.begin() + 2;
std::cout << *it << std::endl;  // 正确输出 3

删除元素导致的迭代器失效

在容器遍历过程中删除元素，如果处理不当，会导致后续迭代器失效。

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 错误做法：删除偶数元素
for (auto it = data.begin(); it != data.end(); ++it) {
    if (*it % 2 == 0) {
        data.erase(it);  // 删除后 it 失效，且循环无法正确继续
    }
}

正确做法 1：使用 erase 返回的迭代器。

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (auto it = data.begin(); it != data.end(); ) {
    if (*it % 2 == 0) {
        it = data.erase(it);  // erase 返回指向下一个元素的迭代器
    } else {
        ++it;
    }
}

正确做法 2：使用 remove-erase 惯用法。

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
data.erase(
    std::remove_if(data.begin(), data.end(), [](int x) {
        return x % 2 == 0;
    }),
    data.end()
);

各容器迭代器失效规则速查

第二类错误：遍历方式不当

范围 for 循环中修改容器

基于范围的 for 循环使用迭代器实现，在循环体内修改容器可能导致迭代器失效。

std::vector<int> items = {1, 2, 3, 4, 5};

// 错误做法
for (auto& item : items) {
    if (item % 2 == 0) {
        items.push_back(item * 10);  // 可能导致迭代器失效
    }
}

正确做法：先收集需要操作的数据，或者使用索引方式。

std::vector<int> items = {1, 2, 3, 4, 5};
std::vector<int> to_add;

for (auto& item : items) {
    if (item % 2 == 0) {
        to_add.push_back(item * 10);
    }
}

// 循环结束后统一添加
for (auto& item : to_add) {
    items.push_back(item);
}

关联容器的 key 约束

std::set 和 std::map 要求 key 值必须保持稳定，修改正在存储的元素会导致未定义行为。

struct Item {
    int id;
    std::string name;
    bool operator<(const Item& other) const {
        return id < other.id;
    }
};

std::set<Item> items;
items.insert({1, "first"});
items.insert({2, "second"});

auto it = items.begin();
// 错误做法：修改元素的 key 值
it->id = 10;  // 破坏了 set 的有序性，可能导致各种问题

正确做法：删除旧元素，插入新元素。

Item old_item = *it;
items.erase(it);
old_item.id = 10;
items.insert(old_item);

第三类错误：内存管理失误

容器析构时的资源泄漏

STL 容器管理的是元素的副本，但如果容器存储的是指针，需要手动释放内存。

// 错误做法：内存泄漏
std::vector<int*> numbers;
for (int i = 0; i < 100; ++i) {
    numbers.push_back(new int(i));
}
// 程序结束前这些内存永远不会被释放

正确做法：使用智能指针或手动释放。

// 方案一：使用智能指针
std::vector<std::unique_ptr<int>> numbers;
for (int i = 0; i < 100; ++i) {
    numbers.push_back(std::make_unique<int>(i));
}
// unique_ptr 自动管理内存

// 方案二：手动释放
std::vector<int*> numbers;
for (int i = 0; i < 100; ++i) {
    numbers.push_back(new int(i));
}
for (auto* p : numbers) {
    delete p;
}
numbers.clear();

不恰当的容量预分配

未预分配容量的 vector 在 push_back 时会多次重新分配内存，影响性能。

// 低效做法
std::vector<std::string> lines;
for (int i = 0; i < 100000; ++i) {
    lines.push_back("line content " + std::to_string(i));
}

正确做法：如果知道大致规模，提前 reserve。

std::vector<std::string> lines;
lines.reserve(100000);  // 提前分配足够的内存
for (int i = 0; i < 100000; ++i) {
    lines.push_back("line content " + std::to_string(i));
}

第四类错误：容器适配器误用

stack 和 queue 的遍历限制

std::stack 和 std::queue 是适配器，默认基于 deque 实现，但它们不提供遍历接口。试图遍历这些容器是编译错误。

std::stack<int> s;
s.push(1);
s.push(2);
s.push(3);

// 错误做法：stack 没有 begin() 和 end()
// for (auto x : s) { }  // 编译错误

正确做法：如果需要遍历功能，直接使用底层容器或选择其他容器。

// 方案：使用 deque 或 vector 直接实现栈
std::deque<int> stack;
stack.push_back(1);
stack.push_back(2);
stack.push_back(3);

for (auto x : stack) {
    // 正常遍历
}

priority_queue 的访问限制

std::priority_queue 只能访问顶部元素，无法按索引访问或遍历。

std::priority_queue<int> pq;
pq.push(5);
pq.push(2);
pq.push(8);

// 错误做法：无法遍历
// for (auto x : pq) { }  // 编译错误

// 错误做法：无法随机访问
// std::cout << pq[0];   // 编译错误

正确做法：如果需要这些功能，使用其他容器或自行实现。

第五类错误：哈希表相关问题

自定义类型的哈希计算

将自定义类型存入 std::unordered_set 或 std::unordered_map 时，必须提供哈希函数和相等比较函数。

struct Point {
    int x, y;
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};

// 错误做法：没有提供哈希函数
std::unordered_set<Point> points;  // 编译错误

正确做法：提供自定义哈希函数。

struct Point {
    int x, y;
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};

struct PointHash {
    std::size_t operator()(const Point& p) const {
        return std::hash<int>()(p.x) ^ (std::hash<int>()(p.y) << 1);
    }
};

std::unordered_set<Point, PointHash> points;
points.insert({1, 2});
points.insert({3, 4});

哈希冲突与性能

哈希表的性能高度依赖于哈希函数的质量，糟糕的哈希函数会导致严重的性能退化。

// 错误做法：所有 key 哈希到相同值
struct BadHash {
    std::size_t operator()(int x) const {
        return 0;  // 所有整数都返回 0，退化为链表
    }
};

std::unordered_set<int, BadHash> data;
for (int i = 0; i < 10000; ++i) {
    data.insert(i);
}
// 所有操作都变成 O(n)

正确做法：使用标准库提供的良好哈希函数，或确保自定义哈希函数分布均匀。

第六类错误：线程安全问题

STL 容器本身不是线程安全的，多个线程同时读写同一容器会导致数据竞争。

std::vector<int> shared_data;

// 错误做法：多线程无保护读写
void producer() {
    for (int i = 0; i < 100; ++i) {
        shared_data.push_back(i);  // 多个线程同时写入
    }
}

void consumer() {
    for (int i = 0; i < 100; ++i) {
        int value = shared_data[i];  // 读取时可能正在写入
    }
}

正确做法：使用互斥锁保护容器访问。

std::vector<int> shared_data;
std::mutex data_mutex;

void safe_producer() {
    for (int i = 0; i < 100; ++i) {
        std::lock_guard<std::mutex> lock(data_mutex);
        shared_data.push_back(i);
    }
}

void safe_consumer() {
    for (int i = 0; i < 100; ++i) {
        std::lock_guard<std::mutex> lock(data_mutex);
        if (i < shared_data.size()) {
            int value = shared_data[i];
        }
    }
}

总结与建议

掌握这些常见错误模式及其解决方案，能够显著提升 C++ 程序的稳定性和可维护性。在使用 STL 容器时，养成良好的编码习惯：优先使用安全的高层接口，在修改容器时注意迭代器状态，及时释放动态分配的资源，并在多线程环境下实施适当的同步措施。