如何正确使用全局运算符 new、new[]、delete 和 delete[]

伯努瓦·杜布勒伊

我有一个关于使用全局运算符 new、new[]、delete 和 delete[] 的问题（每个问题 1 个帖子，我吸取了教训...）但首先，我将描述情况。

在 Herb Sutter 的 Exceptional C++ 书中的第 12 项 - 编写异常安全代码 - 第 5 部分中，作者使用了以下代码段：

...
template <class T>
StackImpl<T>::StackImpl( size_t size )
    : v_( static_cast<T*>
            ( size == 0
            ? 0
            : operator new(sizeof(T)*size) ) ),
    vsize_(size),
    vused_(0)
{
} 

template <class T>
StackImpl<T>::~StackImpl()
{
    destroy( v_, v_+vused_ ); // this can't throw
    operator delete( v_ );
}
...

// construct() constructs a new object in
// a given location using an initial value
//
template <class T1, class T2>
void construct( T1* p, const T2& value )
{
    new (p) T1(value);
}

// destroy() destroys an object or a range
// of objects
//
template <class T>
void destroy( T* p )
{
    p->~T();
}

template <class FwdIter>
void destroy( FwdIter first, FwdIter last )
{
    while( first != last )
    {
        destroy( &*first );
        ++first;
    }
}

一开始没看懂，做了个小测试：

struct OperatorTest
{
    OperatorTest()
    {
        std::cout << "Constructor" << std::endl;
    }

    ~OperatorTest()
    {
        std::cout << "Destructor" << std::endl;
    }

    OperatorTest&  operator=(const OperatorTest& other)
    {
        std::cout << "Assignment" << std::endl;
        return *this;
    }
};

int main()
{
    // Operator new[]
    OperatorTest* test1 = static_cast<OperatorTest*>(operator new[](sizeof(OperatorTest) * 5)); // Only allocate memory
    new (&test1[0]) OperatorTest(); // Calls the constructor by doing a placement new
    test1[0].~OperatorTest(); // Calls the destructor
    operator delete[](test1); // Calls the destructor... again

    std::cout << std::endl;

    // Operator new
    OperatorTest* test2 = static_cast<OperatorTest*>(operator new(sizeof(OperatorTest) * 5)); // Only allocate memory
    new (&test2[0]) OperatorTest(); // Calls the constructor by doing a placement new
    test2[0].~OperatorTest(); // Calls the destructor
    operator delete(test2); // Calls the destructor... again

    std::cout << std::endl;

    {
        // How does the STL allocate memory?
        std::vector<OperatorTest> test3{ 3 }; // Allocate memory and calls the default constructor
    }

    std::cout << std::endl;

    // Manual new[] / delete[]
    OperatorTest* test4 = new OperatorTest[3];
    delete[] test4;

    return 0;
}

控制台中 main 函数的结果是：