如何让C++容器固定大小，新增元素时自动删除队首旧元素？

嘿，这个需求本质上是要一个支持滑动窗口/自动淘汰旧元素的固定容量容器，咱们来逐个分析你的问题：

1. 用std::vector能不能实现？ #

可以，但不算最优解。vector本身没有原生支持“满了自动删队首”的特性，但你可以手动封装逻辑来实现：

每次往vector尾部新增元素后，检查当前大小是否超过你设定的最大容量，如果超过就删除队首元素。不过要注意：vector::erase(begin())会导致后面所有元素前移，时间复杂度是O(n)，数据量越大，这个操作的开销就越高。

给个简单的封装函数示例：

#include <vector>

template <typename T>
void push_with_limit(std::vector<T>& vec, const size_t max_size, const T& value) {
    vec.push_back(value);
    if (vec.size() > max_size) {
        vec.erase(vec.begin()); // 超出容量时删除队首
    }
}

适合场景：数据量小、对性能要求不高的简单场景。

2. 更合适的替代容器 #

如果想要更高效的实现，推荐下面几种方案：

方案一：std::deque封装 #

std::deque的队首删除操作pop_front()是**O(1)**时间复杂度，比vector高效得多。同样可以封装逻辑来实现自动淘汰：

#include <deque>

template <typename T>
void push_with_limit(std::deque<T>& dq, const size_t max_size, const T& value) {
    dq.push_back(value);
    if (dq.size() > max_size) {
        dq.pop_front(); // 高效删除队首
    }
}

适合场景：中等数据量、需要平衡开发成本和性能的场景，不用自己造轮子，用标准库容器就能搞定。

方案二：自定义循环缓冲区（Circular Buffer） #

如果你的场景对性能要求极高（比如高频写入、大数据量），可以自己实现一个基于vector的循环缓冲区，所有操作都是**O(1)**时间复杂度。核心思路是用索引标记队首和队尾，循环利用底层存储空间，满了之后直接覆盖旧元素：

#include <vector>
#include <stdexcept>

template <typename T>
class CircularBuffer {
private:
    std::vector<T> buf_;
    size_t head_ = 0;
    size_t tail_ = 0;
    const size_t capacity_;
    bool is_full_ = false;

public:
    explicit CircularBuffer(const size_t cap) : capacity_(cap), buf_(cap) {}

    // 新增元素，满了自动覆盖队首
    void push(const T& value) {
        buf_[tail_] = value;
        tail_ = (tail_ + 1) % capacity_;
        
        if (is_full_) {
            head_ = (head_ + 1) % capacity_; // 满了之后队首跟着移动
        } else if (tail_ == head_) {
            is_full_ = true; // 第一次填满缓冲区
        }
    }

    // 取出队首元素
    T pop_front() {
        if (empty()) {
            throw std::out_of_range("CircularBuffer is empty");
        }
        const T value = buf_[head_];
        head_ = (head_ + 1) % capacity_;
        is_full_ = false;
        return value;
    }

    // 判断是否为空
    bool empty() const {
        return !is_full_ && (head_ == tail_);
    }

    // 当前元素数量
    size_t size() const {
        if (is_full_) {
            return capacity_;
        } else if (tail_ >= head_) {
            return tail_ - head_;
        } else {
            return capacity_ - head_ + tail_;
        }
    }
};

适合场景：高性能需求场景，比如日志缓存、实时数据窗口分析等，自定义实现可以完全适配你的需求。

总结 #

• 小数据量、快速实现：用std::vector封装；
• 中等场景、平衡效率和成本：用std::deque封装；
• 高性能需求：自定义循环缓冲区。

内容的提问来源于stack exchange，提问作者Severus Tux