如何实现有容量上限且永不分配内存的类vector容器？

一、能否用allocator实现？ #

可以，但复杂度较高且存在使用限制，不推荐。

具体思路是自定义一个不执行动态分配的allocator：

• 让allocator关联到编译期固定大小的缓冲区（比如作为容器的成员变量，allocator通过指针绑定到该缓冲区）。
• 实现allocator核心接口：
  • allocate(n)：检查请求内存是否在剩余缓冲区范围内，直接返回可用起始地址（需满足内存对齐要求）。
  • deallocate(p, n)：空实现，因为内存是预分配的无需释放。
  • 补充rebind、构造/析构等标准要求的接口。

但这种方式的问题很明显：

• std::vector的默认逻辑是容量不足时自动扩容，此时会调用allocator的allocate方法，你必须严格保证永远不会触发扩容（依赖用户自身约束），否则会直接内存越界。
• 带状态的allocator需要处理相等性比较（同类型allocator指向同一缓冲区才视为相等），否则容器部分操作会出现未定义行为。
• 强行让动态扩容的std::vector适配固定容量场景，本质上是违背其设计初衷，反而容易出错。

二、最优方案：自定义固定容量容器，最大化复用标准库代码 #

直接实现类似std::vector但固定容量的模板类（比如命名为static_vector<T, N>），内部用std::array做缓冲区，复用标准库的迭代器、算法和内存操作工具，既满足面向对象封装，又能复用成熟的标准库代码。

核心实现示例 #

#include <array>
#include <algorithm>
#include <memory>
#include <cassert>

template <typename T, std::size_t N>
class static_vector {
public:
    // 复用std::array的随机访问迭代器，自动兼容所有标准库算法
    using iterator = typename std::array<T, N>::iterator;
    using const_iterator = typename std::array<T, N>::const_iterator;
    using value_type = T;
    using size_type = std::size_t;

    static_vector() = default;

    // 析构时销毁已构造的元素
    ~static_vector() {
        clear();
    }

    // 禁用拷贝（若需支持可自行实现元素拷贝逻辑）
    static_vector(const static_vector&) = delete;
    static_vector& operator=(const static_vector&) = delete;

    // 移动构造/赋值
    static_vector(static_vector&& other) noexcept {
        for (size_type i = 0; i < other.size_; ++i) {
            std::construct_at(&buffer_[i], std::move(other.buffer_[i]));
            std::destroy_at(&other.buffer_[i]);
        }
        size_ = other.size_;
        other.size_ = 0;
    }

    static_vector& operator=(static_vector&& other) noexcept {
        if (this != &other) {
            clear();
            for (size_type i = 0; i < other.size_; ++i) {
                std::construct_at(&buffer_[i], std::move(other.buffer_[i]));
                std::destroy_at(&other.buffer_[i]);
            }
            size_ = other.size_;
            other.size_ = 0;
        }
        return *this;
    }

    // push_back：构造元素到缓冲区尾部
    void push_back(const T& value) {
        assert(size_ < N);
        std::construct_at(&buffer_[size_], value);
        ++size_;
    }

    void push_back(T&& value) {
        assert(size_ < N);
        std::construct_at(&buffer_[size_], std::move(value));
        ++size_;
    }

    // insert：插入元素到指定位置，复用std::move_backward处理元素后移
    iterator insert(iterator pos, const T& value) {
        const auto idx = pos - begin();
        assert(size_ < N && idx <= size_);
        std::move_backward(pos, end(), end() + 1);
        std::construct_at(&buffer_[idx], value);
        ++size_;
        return begin() + idx;
    }

    iterator insert(iterator pos, T&& value) {
        const auto idx = pos - begin();
        assert(size_ < N && idx <= size_);
        std::move_backward(pos, end(), end() + 1);
        std::construct_at(&buffer_[idx], std::move(value));
        ++size_;
        return begin() + idx;
    }

    // erase：删除指定位置元素，复用std::move处理元素前移
    iterator erase(iterator pos) {
        const auto idx = pos - begin();
        assert(idx < size_);
        std::destroy_at(&buffer_[idx]);
        std::move(pos + 1, end(), pos);
        --size_;
        return begin() + idx;
    }

    // sort：直接复用std::sort，依赖随机访问迭代器特性
    void sort() {
        std::sort(begin(), end());
    }

    // 基础容器接口，直接复用std::array的底层操作
    iterator begin() noexcept { return buffer_.begin(); }
    const_iterator begin() const noexcept { return buffer_.begin(); }
    iterator end() noexcept { return buffer_.begin() + size_; }
    const_iterator end() const noexcept { return buffer_.begin() + size_; }

    T& operator[](size_type idx) noexcept { return buffer_[idx]; }
    const T& operator[](size_type idx) const noexcept { return buffer_[idx]; }

    T& front() noexcept { return buffer_[0]; }
    const T& front() const noexcept { return buffer_[0]; }

    T& back() noexcept { return buffer_[size_ - 1]; }
    const T& back() const noexcept { return buffer_[size_ - 1]; }

    size_type size() const noexcept { return size_; }
    constexpr size_type capacity() const noexcept { return N; }
    bool empty() const noexcept { return size_ == 0; }

    // 清空容器，销毁所有已构造元素
    void clear() noexcept {
        for (size_type i = 0; i < size_; ++i) {
            std::destroy_at(&buffer_[i]);
        }
        size_ = 0;
    }

private:
    std::array<T, N> buffer_;
    size_type size_ = 0;
};

复用标准库的关键点 #

• 迭代器：直接复用std::array的随机访问迭代器，让std::sort、std::find等所有标准库算法可以直接调用。
• 内存操作：用std::construct_at和std::destroy_at安全处理元素的构造/析构，避免手动管理内存布局的错误。
• 元素移动/拷贝：用std::move_backward、std::move等标准算法处理元素的位置调整，减少手写循环的冗余和错误。

这种方案完全符合固定容量、不分配内存的需求，同时实现了面向对象封装，最大化复用了标准库的成熟代码。

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