如何处理自定义容器中的对象销毁？

Question

我正在编写一个自定义 Stack 容器，它将其元素存储在一个固定大小的数组中：

template<typename T, uint32 TCapacity>
class Stack {
    // Member functions omitted
    T mData[TCapacity];
    uint32 mSize;
};

当一个元素从堆栈中弹出时，我可以减小它的大小。但是，我认为如果项目从堆栈中弹出，您还希望在对象上调用析构函数。

所以，我可以在弹出对象时手动调用析构函数，如下所示：

void Pop() { 
    assert(mSize > 0);
    mSize--;
    mData[mSize].~T();
}

但是，当 Stack 对象本身被破坏时，这不会导致为 mData 中的每个对象再次调用析构函数，从而有效地“双重破坏”某些元素吗？双重破坏所有类型可能不安全，所以这似乎不是一个好主意。

我想另一种方法是构造一个新对象来覆盖以前的对象，但这似乎有点效率低下：

void Pop() { 
    assert(mSize > 0);
    mSize--;
    mData[mSize] = T();
}

我唯一能想到的另一件事是让数据数组只是一个字节数组（无符号字符），然后处理在该原始内存中构造/破坏对象的额外复杂性。哪个看起来不太理想，但也许才是真正的解决方案？

有没有人知道解决这个问题的好方法？我想像 std::vector 这样的内置容器也必须处理这个问题（当然，在这种情况下，数据内存是从堆中分配的）。

Answer 1

如 cmets 中所述，关键是没有 T 类型的数组。你想要一个像optional<T> 这样的数组，即一个可以保存T 或什么都不保存的类型。但是在这种情况下，容器知道填充了哪些项目，因此optional<T> 内部知道它是否持有T 是不必要的。

例如，下面的类可选类型应该可以工作：

template <typename T>
union storage
{
    char no_value_ = {};
    T value_;

    constexpr void assign(T&& obj)
        noexcept(std::is_nothrow_move_constructible_v<T>)
    {
        this->value_ = std::move(obj);
    }

    constexpr void assign(const T& obj)
        noexcept(std::is_nothrow_copy_constructible_v<T>)
    {
        this->value_ = obj;
    }

    constexpr void reset() noexcept
    {
        this->value_.T::~T();
        this->no_value_ = {};
    }
};

但是这种类型本身很难用，因为它不知道自己是否持有值。

所以，在容器中使用时，一定要特别小心：

template <typename T, std::size_t Capacity>
class stack
{
public:
    constexpr stack() noexcept = default;

    constexpr stack(const stack& other) noexcept
        requires std::is_copy_constructible_v<storage<T>>
        = default;

    constexpr stack(const stack& other)
        noexcept(std::is_nothrow_copy_constructible_v<T>)
        : size_{other.size_}
    {
        for (std::size_t i = 0; i < size_; ++i)
            data_[i].assign(other.data_[i].value_);
    }

    constexpr stack(stack&& other) noexcept
        requires std::is_move_constructible_v<storage<T>>
        = default;

    constexpr stack(stack&& other)
        noexcept(std::is_nothrow_move_constructible_v<T>)
        : size_{std::exchange(other.size_, 0)}
    {
        for (std::size_t i = 0; i < size_; ++i)
        {
            data_[i].assign(std::move(other.data_[i].value_));
            other.data_[i].reset();
        }
    }

    constexpr ~stack()
        requires std::is_destructible_v<storage<T>>
        = default;

    constexpr ~stack()
    {
        for (std::size_t i = 0; i < size_; ++i)
            data_[i].reset();
    }

    constexpr void push(T&& obj)
        noexcept(std::is_nothrow_move_constructible_v<T>)
    {
        assert(size_ < Capacity);
        data_[size_++].assign(std::move(obj));
    }
    constexpr void push(const T& obj)
        noexcept(std::is_nothrow_copy_constructible_v<T>)
    {
        assert(size_ < Capacity);
        data_[size_++].assign(obj);
    }

    constexpr T& top() noexcept
    {
        assert(size_ > 0);
        return data_[size_-1].value_;
    }

    constexpr const T& top() const noexcept
    {
        assert(size_ > 0);
        return data_[size_-1].value_;
    }

    constexpr void pop()
    {
        assert(size_ > 0);
        data_[size_--].reset();
    }

private:
    std::size_t size_ = 0;
    storage<T> data_[Capacity];
};

查看full example。