ฉันต้องการคอนเทนเนอร์ C++ ที่มีข้อกำหนดต่อไปนี้:

• คอนเทนเนอร์สามารถจัดเก็บวัตถุที่ไม่สามารถคัดลอกและไม่สามารถเคลื่อนย้ายได้ในหน่วยความจำต่อเนื่อง สำหรับ std::vector วัตถุจะต้องคัดลอกหรือเคลื่อนย้ายได้
• capacity ของคอนเทนเนอร์เป็นที่รู้จักในระหว่างการก่อสร้าง ณ รันไทม์ และคงที่จนกว่าจะถูกทำลาย พื้นที่หน่วยความจำที่จำเป็นทั้งหมดได้รับการจัดสรรระหว่างการก่อสร้าง สำหรับ boost::static_vector ทราบความจุ ณ เวลาคอมไพล์
• ขนาดของคอนเทนเนอร์สามารถเพิ่มขึ้นเมื่อเวลาผ่านไปเมื่อมีองค์ประกอบเพิ่มขึ้น emplace_back รายการในคอนเทนเนอร์ แต่ไม่ควรเกิน capacity
• เนื่องจากวัตถุไม่สามารถคัดลอกหรือเคลื่อนย้ายได้ จึงไม่อนุญาตให้มีการจัดสรรใหม่

ดูเหมือนว่าทั้ง STL และ BOOST ไม่มีประเภทคอนเทนเนอร์ที่ฉันต้องการ ฉันได้ค้นหาในด้านนี้อย่างกว้างขวางแต่ไม่พบคำตอบ ดังนั้นฉันจึงได้ดำเนินการอย่างใดอย่างหนึ่ง

#include <memory>

template<class T>
class FixedCapacityVector {
private:
    using StorageType = std::aligned_storage_t<sizeof(T), alignof(T)>;
    static_assert(sizeof(StorageType) == sizeof(T));
public:
    FixedCapacityVector(FixedCapacityVector const&) = delete;
    FixedCapacityVector& operator=(FixedCapacityVector const&) = delete;
    FixedCapacityVector(size_t capacity = 0):
        capacity_{ capacity },
        data_{ std::make_unique<StorageType[]>(capacity) }
    { }
    ~FixedCapacityVector()
    {
        for (size_t i = 0; i < size_; i++)
            reinterpret_cast<T&>(data_[i]).~T();
    }
    template<class... Args>
    T& emplace_back(Args&&... args) 
    {
        if (size_ == capacity_)
            throw std::bad_alloc{};
        new (&data_[size_]) T{ std::forward<Args>(args)... };
        return reinterpret_cast<T&>(data_[size_++]);
    }
    T& operator[](size_t i) 
    { return reinterpret_cast<T&>(data_[i]); }
    T const& operator[](size_t i) const 
    { return reinterpret_cast<T const&>(data_[i]); }
    size_t size() const { return size_; }
    size_t capacity() const { return capacity_; }
    T* data() { return reinterpret_cast<T*>(data_.get()); }
    T const* data() const { return reinterpret_cast<T const*>(data_.get()); }
private:
    size_t const capacity_;
    std::unique_ptr<StorageType[]> const data_;
    size_t size_{ 0 };
};

คำถามของฉันคือ:

• ทำไมฉันถึงทำเช่นนี้ด้วยมือ? ฉันไม่พบภาชนะมาตรฐาน หรือบางทีฉันอาจไม่ได้ดูที่ที่ถูกต้อง? หรือเพราะสิ่งที่ฉันพยายามทำนั้นไม่ธรรมดา?
• มีการใช้คอนเทนเนอร์ที่เขียนด้วยลายมือถูกต้องหรือไม่ แล้วความปลอดภัยของข้อยกเว้น ความปลอดภัยของหน่วยความจำ ฯลฯ ล่ะ?