C++中std::vector Vs std::deque VS std::list的对比分析

for (auto it = c.begin(); it != c.end(); ) {
    if (should_erase(*it)) it = c.erase(it); // erase 返回下一个迭代器（C++11 起）
    else ++it;
}

for (auto it = l.begin(); it != l.end(); ) {
    if (cond) it = l.erase(it); // O(1)，其他迭代器不受影响
    else ++it;
}

v.erase(std::remove_if(v.begin(), v.end(), pred), v.end());

std::vector<MyType> v;
v.reserve(1000);           // 预分配，避免扩容导致的整体移动
for (...) v.emplace_back(...); // in-place 构造，避免拷贝

// vector / deque
for (auto it = v.begin(); it != v.end(); ) {
    if (need_erase(*it)) it = v.erase(it);
    else ++it;
}

// list
for (auto it = l.begin(); it != l.end(); ) {
    if (need_erase(*it)) it = l.erase(it); // 只使被删节点的迭代器失效
    else ++it;
}

std::list<int> a{1,2,3,4}, b{10,11};
// 把 a 中的 [2,4) 移到 b 的开头
auto first = std::next(a.begin()); // 指向 2
auto last  = std::next(first, 2);  // 指向 4 (不含)
b.splice(b.begin(), a, first, last); // O(1)

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <chrono>

// 线程安全队列
template <typename T>
class ThreadSafeQueue {
public:
    void push(T value) {
        {
            std::lock_guard<std::mutex> lock(mtx_);
            queue_.push(std::move(value));
        }
        cv_.notify_one(); // 唤醒一个等待的消费者
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.wait(lock, [this]{ return !queue_.empty() || done_; });
        if (queue_.empty()) {
            return T(); // 若结束且队列空，返回默认值
        }
        T value = std::move(queue_.front());
        queue_.pop();
        return value;
    }

    void shutdown() {
        {
            std::lock_guard<std::mutex> lock(mtx_);
            done_ = true;
        }
        cv_.notify_all(); // 唤醒所有等待线程
    }

private:
    std::queue<T> queue_;
    std::mutex mtx_;
    std::condition_variable cv_;
    bool done_ = false;
};

// ------------------- 生产者/消费者测试 -------------------
void producer(ThreadSafeQueue<int>& q, int id, int count) {
    for (int i = 0; i < count; i++) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时
        int value = id * 100 + i;
        q.push(value);
        std::cout << "[Producer " << id << "] produced: " << value << "\n";
    }
}

void consumer(ThreadSafeQueue<int>& q, int id) {
    while (true) {
        int value = q.pop();
        if (value == 0 && q.pop() == 0) break; // 简单退出条件（可换为特殊结束标记）
        if (value != 0) {
            std::cout << "    [Consumer " << id << "] consumed: " << value << "\n";
        }
    }
}

int main() {
    ThreadSafeQueue<int> q;

    // 启动多个生产者和消费者
    std::thread p1(producer, std::ref(q), 1, 5);
    std::thread p2(producer, std::ref(q), 2, 5);

    std::thread c1(consumer, std::ref(q), 1);
    std::thread c2(consumer, std::ref(q), 2);

    // 等生产者结束
    p1.join();
    p2.join();

    // 通知消费者结束
    q.shutdown();

    c1.join();
    c2.join();

    std::cout << "All threads finished.\n";
    return 0;
}

[Producer 1] produced: 100
[Producer 2] produced: 200
    [Consumer 1] consumed: 100
    [Consumer 2] consumed: 200
[Producer 1] produced: 101
[Producer 2] produced: 201
    [Consumer 1] consumed: 101
    [Consumer 2] consumed: 201
...
All threads finished.