C++ 队列大小限制的最佳实践

创作时间:

作者:

@小白创作中心

C++ 队列大小限制的最佳实践

引用

来源

https://code-examples.net/cn/q/4b16d8d

在C++编程中，队列是一种常用的数据结构，遵循先入先出（FIFO）的原则。然而，标准的std::queue并没有直接限制大小的功能。本文将介绍两种限制队列大小的方法：自定义队列类和生产者-消费者模型，并提供详细的代码示例。

C++ 中限制 Queue 大小

理解 Queue

在 C++ 中，Queue<T> 是一个常用的容器适配器，它遵循先入先出（FIFO）的原则。这意味着，先插入的元素将先被取出。

限制 Queue 大小

标准的 Queue<T> 并没有直接限制大小的功能。然而，我们可以通过一些方法来实现：

方法 1：自定义队列类

继承 std::deque：

创建一个自定义的队列类，继承自 std::deque。
添加一个成员变量 max_size 来存储最大容量。
在 push 操作中，检查队列是否已满，如果满了，则删除队首元素。

#include <deque>
template <typename T>
class LimitedQueue {
public:
    LimitedQueue(int maxSize) : max_size_(maxSize) {}
    void push(const T& value) {
        if (size() == max_size_) {
            pop();
        }
        queue_.push_back(value);
    }
    // 其他操作（pop, front, back, empty, size）与 std::queue 相似
private:
    std::deque<T> queue_;
    int max_size_;
};

方法 2：使用条件变量和互斥量

创建生产者-消费者模型：

使用条件变量和互斥量来控制队列的入队和出队操作。
生产者线程在入队时，如果队列已满，则等待条件变量。
消费者线程在出队时，如果队列为空，则等待条件变量。

#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
std::queue<int> queue;
std::mutex mtx;
std::condition_variable cv;
int max_size = 10;
void producer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return queue.size() < max_size; });
        queue.push(rand());
        cv.notify_one();
    }
}
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return !queue.empty(); });
        int value = queue.front();
        queue.pop();
        cv.notify_one();
        // 处理 value
    }
}

方法 2 适用于更复杂的场景，需要精确控制队列的大小和线程之间的同步。
方法 1 适用于简单的限制大小需求，不需要复杂的线程同步。

解析示例代码

示例 1：自定义队列类

#include <deque>
template <typename T>
class LimitedQueue {
public:
    LimitedQueue(int maxSize) : max_size_(maxSize) {}
    void push(const T& value) {
        if (size() == max_size_) {
            pop();
        }
        queue_.push_back(value);
    }
    // 其他操作（pop, front, back, empty, size）与 std::queue 相似
private:
    std::deque<T> queue_;
    int max_size_;
};

解释

继承 std::deque
基于 std::deque 实现自定义队列，利用其高效的插入和删除操作。
限制大小 max_size_
定义一个成员变量 max_size_ 来存储最大容量。
push 操作

检查容量
如果队列已满，先移除队首元素。
插入元素
使用 queue_.push_back 将元素插入队尾。

示例 2：生产者-消费者模型

#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
std::queue<int> queue;
std::mutex mtx;
std::condition_variable cv;
int max_size = 10;
void producer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return queue.size() < max_size; }); // 等待队列不满
        queue.push(rand());
        cv.notify_one(); // 通知消费者
    }
}
void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return !queue.empty(); }); // 等待队列非空
        int value = queue.front();
        queue.pop();
        cv.notify_one(); // 通知生产者
        // 处理 value
    }
}