类是否应该能够抵御双重破坏

我遇到一种情况，即并发访问容器的分配器需要同时调用放置 new 和析构函数。

template< class U > void destroy(U* p){
p->~U();
}

事实上，我最终可以反复调用破坏。 这让我想到这样的事情是否应该可以。

std::vector<int>* p = (std::vector<int>*)malloc(sizeof(std::vector<int>));
::new (*p) std::vector<int>(30);
(*p)[10] = 5;
p->~std::vector<int>();
p->~std::vector<int>();
free(p);

我认为只要销毁std::vector将数据指针设置为 null 或 size 设置为零，并且再次调用时没有双重释放，这将起作用。

那么，是否应该将类设置为意外(或良性)双重销毁应等同于单次销毁？

换句话说，销毁是否应该是一种幂等操作？

(请注意，为简单起见，此示例中的析构函数不是虚拟的)

我发现这个问题类似于如何允许稍后销毁移动类的问题。

一些答案将运行时成本用于反对支持双重销毁的理由。 有成本，但它们类似于移动物体的成本。 换句话说，如果移动便宜，那么允许双重破坏是便宜的(如果DD首先不是UB，因为其他原因，例如标准)。

具体来说：

class dummyvector{
int* ptr;
public:
dummyvector() : ptr(new int[10]){}
dummyvector(dummyvector const& other) = delete; // for simplicity
dummyvector(dummyvector&& other) : ptr(other.ptr){
other.ptr = nullptr; // this makes the moved object unusable (e.g. set) but still destructable 
}
dummyvector& operator=(dummyvector const&) = delete; // for simplicity
void set(int val){for(int i = 0; i != 10; ++i) ptr[i]=val;}
int sum(){int ret = 0; for(int i = 0; i != 10; ++i) ret += ptr[i]; return ret;}
~dummyvector(){
delete[] ptr;
ptr = nullptr; // this is the only extra cost for allowing double free (if it was not UB)
// ^^ this line commented would be fine in general but not for double free (not even in principle)
}
};