如何以异常安全的方式使用 placement new？

Question

假设我有一个 MyStack class 它公开了：

class MyStack {
public:

template <typename T>
T* Push() {
    Reserve(sizeof(T)); // Make sure that the buffer can hold an additional sizeof(T) bytes , realloc if needed
    auto prev= _top;
    _top += sizeof(T);
    new (prev) T();
    return reinterpret_cast<T*>(prev);
}

template <typename T>
T* Pop() {
    _top -= sizeof(T);
    return return reinterpret_cast<T*>(_top);
}

bool Empty() const {
    return _bottom == _top;
}

private:
    char* _bottom;
    char* _top;
};

// Assumes all stack elements have the same type
template <typename T>
void ClearStack(MyStack& stack) {
    while (!stack.Empty()) {
        stack.template Pop<T>()->~T();
    }
}

这里有一个隐藏的错误。在 MyStack::Push() 中构造 T 可能会抛出异常，这会使堆栈缓冲区处于未定义状态（分配的 space 将包含垃圾）。稍后，当 ClearStack 被调用时，它将尝试将垃圾重新解释为 T 并调用其可能导致访问冲突的析构函数。

有没有办法只修改 MyStack::Push() 来修复这个错误？（限制是因为这是一个外部代码，我们更愿意进行最小的更改，因此更新库相对容易）

我考虑过将 MyStack::Push 更改为：

T* Push() {
    auto prev = _top;
    T t();
    Reserve(sizeof(T)); 
    _top += sizeof(T);
    reinterpret_cast<T*>(prev) = std::move(t);
    return prev;
}

但它看起来很糟糕，我什至不确定它不会调用任何 UB（并且还强制 T 有一个移动构造函数）

这里有更好的解决方案来防止抛出构造函数吗？（最好是里面的小改动MyStack::Push()）

Answer 1

这里的问题真的是你的设计有误。您正在创建一个行为有点像 std::vector 的类型，但它没有 "capacity" 的实际概念。因此，当它 Reserve 的内存时，它真正希望 _top 在此过程完成后指向分配存储的末尾。因此，如果不是，则该类型处于无效状态。

这意味着，如果发生异常，您必须撤消对Reserve的调用：重新分配旧的存储大小并将内容移入那存储回来¹。一个更像 vector 的实现有 3 个指针：一个指向开始的指针，一个指向第一个未使用的内存字节的指针，以及一个指向已分配存储空间末尾的指针。这样，如果您 Reserve 但遇到异常，您只是得到了一些额外的存储空间。

¹：仅供参考：您似乎正在尝试做的事情很可能行不通。或者至少，不是大多数用户定义的 C++ 类型。您的 Reserve 调用分配新存储并对其执行 memcpy 并且从不调用这些对象的析构函数的可能性很大（因为您 不知道 什么类型他们是）。好吧，这仅对 memcpy 是有效操作的对象合法。即，TriviallyCopyable 类型。然而，您的 Push 函数没有任何东西可以防止非 TriviallyCopyable 类型。

更不用说如果有人拥有指向旧对象的指针，每次 Push 调用都会 使该指针无效 。由于您不记得任何对象的类型，因此无法重构它们。

Answer 2

这段代码怎么样：

template <typename T>
T* Push() {
    Reserve(sizeof(T));
    auto prev= _top;
    _top += sizeof(T);
    try {
        new (prev) T();
        return reinterpret_cast<T*>(prev);
    }
    catch (...) {
        Unreserve(sizeof(T)); //release the memory, optional?
        _top = prev;            
        throw;
    }
}

Answer 3

你可以使用三分球实现：

begin指向第一个元素。
end指向最后一个元素
reserved 指向保留 space 之后的一个元素。
begin=end=reserved(=nullptr)表示未分配容器。
begin+1=end=reserved表示用一个元素填充的容器。
begin+1=end;begin+4=reserved 表示包含 1 个元素的容器，space 表示另外 2 个元素。

那么您的 Push 方法将如下所示：

template <typename T>
T* Push() {
    if(end==reserved)
        //relocate, ensure that begin<=end<reserved
    new (end) T();
    end+=sizeof(T);
    return reinterpret_cast<T*>(end-1);
}

如何以异常安全的方式使用 placement new？

How to use placement new in an exception safe way?

c++

new-operator