Saya memerlukan wadah C++ dengan persyaratan berikut:

• Wadah dapat menyimpan objek yang tidak dapat disalin DAN tidak dapat dipindahkan dalam memori berkelanjutan. Untuk std::vector objek harus dapat disalin atau dipindahkan.
• capacity kontainer diketahui selama konstruksi pada saat run-time, dan diperbaiki hingga kehancuran. Semua ruang memori yang dibutuhkan dialokasikan selama konstruksi. Untuk boost::static_vector kapasitasnya diketahui pada waktu kompilasi.
• Ukuran penampung dapat bertambah seiring waktu ketika emplace_back lebih banyak elemen dalam penampung, tetapi tidak boleh melebihi capacity.
• Karena objek tidak dapat disalin atau dipindahkan, realokasi tidak diperbolehkan.

Tampaknya baik STL maupun BOOST tidak memiliki tipe container yang saya perlukan. Saya juga telah mencari di sisi ini secara ekstensif tetapi tidak menemukan jawaban. Jadi saya telah menerapkannya.

#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 };
};

Pertanyaan saya adalah:

• Mengapa saya melakukan ini dengan tangan? Saya tidak dapat menemukan wadah standar. Atau mungkin saya tidak melihat tempat yang tepat? Atau karena apa yang saya coba lakukan tidak konvensional?
• Apakah wadah tulisan tangan diterapkan dengan benar? Bagaimana dengan keamanan pengecualian, keamanan memori, dll.?