显式析构函数

Question

下面的代码只是用来说明我的问题。

template<class T>
class array<T>
{
 public:
    // constructor
    array(cap = 10):capacity(cap)
    {element = new T [capacity]; size =0;}

    // destructor
    ~array(){delete [] element;}
    void erase(int i);
    private:
      T *element;
      int capacity;
      int size;
};



template<class T>
void class array<T>::erase(int i){
     // copy
     // destruct object
    element[i].~T();  ////
    // other codes
} 

如果我有 array; arr 在 main.cpp 中。当我使用erase(5)时，element[5]的对象被销毁，但element[5]的空间不会被释放，我可以使用 element[5] = "abc" 在这里输入一个新值吗？或者我应该使用placement new 将新值放入element [5] 的空间中？

当程序结束时，arr将调用它自己的析构函数，该析构函数也调用delete [] element。所以string的析构函数会先销毁对象，然后释放空间。但由于我已经显式地析构了 element[5]，析构函数（由 arr 的析构函数调用）运行两次来析构 element[5] 有关系吗？我知道空间不能被释放两次，那么对象呢​​？我做了一些测试，发现如果我只是破坏对象两次而不是释放空间两次似乎没问题。

更新

答案是：

(1)如果我显式调用析构函数，则必须使用placement new。

(2) 重复析构对象被定义为未定义的行为，大多数系统都可以接受，但应尽量避免这种做法。

Answer 1

您需要使用placement-new语法：

new (element + 5) string("abc");

element[5] = "abc"; 是不正确的；这将调用 element[5] 上的 operator=，它不是一个有效的对象，从而产生未定义的行为。

当程序结束时，arr将调用它自己的析构函数，该析构函数也调用delete []元素。

这是错误的：您最终将调用已调用析构函数的对象的析构函数（例如，上述示例中的 elements[5]）。这也会产生未定义的行为。

考虑使用 std::allocator 及其接口。它使您可以轻松地将分配与构造分开。它由 C++ 标准库容器使用。

Answer 2

只是为了进一步准确地解释 UD 可能会如何咬你......

如果你 erase() 一个元素 - 显式调用析构函数 - 该析构函数可能会执行诸如减少引用计数器 + 清理、删除之类的操作指针等..当你的数组<>然后析构函数执行一个删除[]元素，它将依次调用每个元素的析构函数，对于擦除的元素，这些析构函数可能会重复它们的引用计数维护、指针删除等，但这一次初始状态并不像他们预期的那样，他们的行为可能会导致程序崩溃。

因此，正如 Ben 在对 James 的回答的评论中所说，在调用数组的析构函数之前，您绝对必须使用放置 new 替换已删除的元素，这样析构函数将具有一些可以从中进行析构的合法状态。

说明此问题的最简单的 T 类型是：

struct T
{
    T() : p_(new int) { }
    ~T() { delete p_; }
    int* p_;
};

这里，由 new 设置的 p_ 值将在 erase( )，并且如果 ~array() 运行时未发生变化。要解决此问题，必须将 p_ 更改为在 ~array() 之前 delete 有效的内容 - 通过某种方式将其清除为 0 或指向 new 返回的另一个指针。最明智的方法是通过放置 new，它将构造一个新对象，为 p_ 获取新的有效值，覆盖旧的无用的内存内容。

也就是说，您可能认为可以构造重复析构函数安全的类型：例如，通过在 delete 之后将 p_ 设置为 0。这可能适用于大多数系统，但我很确定标准中有一些内容说调用析构函数两次是 UD 无论如何。