安全放置新&显式析构函数调用

Question

这是我的代码的示例：

template <typename T> struct MyStruct {
    T object;
}

template <typename T> class MyClass {
    MyStruct<T>* structPool;
    size_t structCount;

    MyClass(size_t count) {
        this->structCount = count;
        this->structPool  = new MyStruct<T>[count];
        for( size_t i=0 ; i<count ; i++ ) {
            //placement new to call constructor
            new (&this->structPool[i].object) T(); 
        }
    }

    ~MyClass() {
        for( size_t i=0 ; i<this->structCount ; i++ ) {
            //explicit destructor call
            this->structPool[i].object.~T(); 
        }
        delete[] this->structPool;
    }
}

我的问题是，这是一种安全的方法吗？在某些情况下我会犯一些隐藏的错误吗？它适用于所有类型的对象（PO​​D 和非 POD）吗？

Answer 1

不，因为构造函数和析构函数都被调用了两次。因为你有这个：

template <typename T> struct MyStruct {
    T object;
}

当你构造 MyStruct 时，编译将构造内部 T ，当你删除对象时，内部 T将自动调用析构函数。

对于此示例，不需要放置 new 或显式析构函数调用。

如果您分配原始内存，则放置 new 会很有用。例如，如果您将 new 更改为：

this->structPool  = new char[sizeof(T) * count];

那么您将需要放置 new 和显式析构函数调用。

Answer 2

不，这肯定不是一种安全的方法。当您对非 POD T 执行 new MyStruct[count] 时，数组中的每个 MyStruct 对象已获得默认值-constructed，意味着object成员的构造函数被自动调用。然后，您尝试在此基础上执行就地构造（通过值初始化）。由此产生的行为是未定义的。

删除也存在同样的问题。

你想达到什么目的？只需执行 new MyStruct[count]() （注意额外的空 ()），它就已经为数组的每个元素执行值初始化（确切地说之后您要“手动”执行的操作）。为什么你觉得必须就地施工？

同样，当您执行

delete[] this->structPool;

此操作时，它会自动为数组中的每个 MyStruct::object 成员调用析构函数。无需手动执行。

Answer 3

1. 记住new总是会调用构造函数，无论它是否是放置的。

-- 所以你的代码使用了 new 两次。这将调用构造函数两次。如果你想避免这种情况，可以：

将第一个 new 更改为 malloc（或任何类型的 alloc）

删除第二个放置 new

2. 要删除数组中的对象，最好的方法是： 调用每个对象的析构函数；释放内存。

-- 因此，您可以执行以下任一操作：

如果您使用 new[]，则使用 delete[] 删除对象 如果

您使用 malloc 和放置 new，则调用每个析构函数并执行 C 风格的 free

Answer 4

template <typename T> class MyClass {
    void* structPool;
    size_t structCount;

    MyClass(size_t count)
      : structPool(new char[sizeof(T)*count], structCount(count)
    {
        //placement new to call constructor
        for( size_t i=0 ; i<count ; i++ )
            new (structPool+i*sizeof(T)) T(); 
    }

    ~MyClass() {
        //explicit destructor call
        for( size_t i=0 ; i<structCount ; i++ )
            reinterpret_cast<T*>(structPool+i*sizeof(T))->~T(); 
        delete[] structPool;
    }
}

请注意，这不是异常安全的：如果其中一个构造函数导致异常，它不会对已构造的对象调用析构函数，并且会泄漏内存。当其中一个析构函数抛出异常时，这也会失败。

查看您最喜欢的 std lib 实现中的 std::vector ，了解如何正确执行此操作。然而，这引出了一个问题：你为什么要这样做？
std::vector 已经完成了这一切，并且做得正确，您可以开箱即用地使用它，并且每个查看您的代码的人都会立即理解它：

template <typename T> class MyClass {
    std::vector<T> data_;
    MyClass(size_t count) : data() {data.resize(count);}
    //~MyClass() not needed
}