解除分配函数禁止使用带有两个参数的分配

Question

这是来自3.7.4.2的N3797:

全局操作符delete[]只有两个参数，第二个参数的类型是std::size_t，这是一个常见的解除分配函数。37

37）此解除分配函数排除使用分配函数空运算符new（std::size_t，std::size_t）作为位置分配函数

这个说明对我来说不清楚。我想看看这种排除的真正例子。编译器将引发警告，或者我们遇到运行时错误？我一直在尝试编写如下内容：

using std::cout;
struct A
{
    int a;
    A(){ a = 5; }
    void * operator new(std::size_t t, std::size_t)
    {
        void *p = ::operator new(t);
        return p;
    }
};

int main(){ }

我不知道能反映这种排除的例子。你能帮我提供一个吗？

Answer 1

如果构造函数在新调用期间抛出异常，则将调用具有相同参数的类似声明的delete。因此，placement new和delete应始终以匹配对声明。

在这种情况下，delete将具有与数组delete相同的签名，编译器将无法在它们之间进行选择。

已编辑以添加示例代码和输出。

您的代码没有实现禁止的全局数组放置 new：

void * operator new( size_t bytes, size_t )

这个程序将演示如何调用全局的new和delete。

#include <stdint.h>
#include <malloc.h>
#include <iostream>
#include <stdexcept>

using namespace std;

struct A
{
    int a;

    A( void )
        : a( 1 )
    {
        cout << __LINE__ << " : A::A()" << endl;
        throw logic_error( "That is .. illogical" );
    }
};

// Placement new with size_t parameter
void * operator new( size_t bytes, size_t )
{
    cout << __LINE__ << " : void * A::operator new( size_t bytes = " << bytes << ", size_t )";
    void *p = malloc( bytes );
    cout << " -> " << p << endl;
    return p;
}

// C++11 : Array placement delete with size_t parameter
// C++14 : Array delete
void operator delete( void *p, std::size_t n ) 
{
    cout << __LINE__ << " : void A::operator delete( void *p = " << p << ", size_t n = " << n << " )" << endl;
    if (p)
        free( p );
}

// Non-array new
void * operator new( size_t bytes )
{
    cout << __LINE__ << " : void * A::operator new( size_t bytes = " << bytes << " )";
    void *p = malloc( bytes );
    cout << " -> " << p << endl;
    return p;
}

// Non-array delete
void operator delete( void *p ) noexcept
{
    cout << __LINE__ << " : void A::operator delete( void *p = " << p << " )" << endl;
    if (p)
        free( p );
}

// Array new
void * operator new[]( size_t bytes )
{
    cout << __LINE__ << " : void * A::operator new[]( size_t bytes = " << bytes << " )";
    void *p = malloc( bytes );
    cout << " -> " << p << endl;
    return p;
}

// Array placement new with size_t parameter
void * operator new[]( size_t bytes, size_t n )
{
    cout << __LINE__ << " : void * A::operator new[]( size_t bytes = " << bytes << ", size_t n = " << n << " )";
    void *p = malloc( bytes );
    cout << " -> " << p << endl;
    return p;
}

// C++11 : Array placement delete with size_t parameter
// C++14 : Array delete
void operator delete[]( void *p, std::size_t n ) 
{
    cout << __LINE__ << " : void A::operator delete[]( void *p = " << p << ", size_t n = " << n << " )" << endl;
    if (p)
        free( p );
}

int main( int, char ** )
{

    A *p = nullptr;
#if 1
    try
    {
        cout << __LINE__ << " : ===== Array placement new allocate with size_t parameter. =====" << endl;
        p = new( (size_t)4 ) A[ 3 ];

        cout << __LINE__ << " : ===== Array placement new succeeded. =====" << endl;
    }
    catch (...)
    {
    }

    cout << __LINE__ << " : ===== Array placement delete. =====" << endl;
    delete[] p;
    p = nullptr;

#endif

    try
    {
        cout << __LINE__ << " : ===== Array new. =====" << endl;
        p = new A[ 3 ];

        cout << __LINE__ << " : ===== Array new succeeded. =====" << endl;
    }
    catch (...)
    {
    }

    cout << __LINE__ << " : ===== Array delete. =====" << endl;
    delete[] p;
    p = nullptr;

    cout << __LINE__ << " : ===== Complete. =====" << endl;

    return 0;
}

使用clang 3.4.2为C 11进行编译得到以下结果：

$ clang++ --std=c++11 -o replace_new main.cpp && ./replace_new
88 : ===== Array placement new allocate with size_t parameter. =====
66 : void * A::operator new[]( size_t bytes = 12, size_t n = 4 ) -> 0x80048358
14 : A::A()
40 : void * A::operator new( size_t bytes = 33 ) -> 0x800483d8
76 : void A::operator delete[]( void *p = 0x80048358, size_t n = 4 )
49 : void A::operator delete( void *p = 0x800483d8 )
97 : ===== Array placement delete. =====
105 : ===== Array new. =====
57 : void * A::operator new[]( size_t bytes = 12 ) -> 0x80048358
14 : A::A()
40 : void * A::operator new( size_t bytes = 33 ) -> 0x800483d8
49 : void A::operator delete( void *p = 0x80048358 )
49 : void A::operator delete( void *p = 0x800483d8 )
114 : ===== Array delete. =====
118 : ===== Complete. =====

33字节的分配是例外。使用相同的删除函数删除异常和数组。

使用C 14规则编译会给出以下结果：

$ clang++ --std=c++1y -o replace_new main.cpp && ./replace_new
main.cpp:89:17: error: 'new' expression with placement arguments refers to non-placement 'operator delete'
            p = new( (size_t)4 ) A[ 3 ];
                ^    ~~~~~~~~~
main.cpp:74:10: note: 'operator delete[]' declared here
    void operator delete[]( void *p, std::size_t n )
         ^
1 error generated.

禁用无效部分并使用C 14规则编译会得到以下结果：

$ clang++ --std=c++1y -o replace_new main.cpp && ./replace_new
105 : ===== Array new. =====
57 : void * A::operator new[]( size_t bytes = 12 ) -> 0x80048358
14 : A::A()
40 : void * A::operator new( size_t bytes = 33 ) -> 0x800483d8
76 : void A::operator delete[]( void *p = 0x80048358, size_t n = 12 )
49 : void A::operator delete( void *p = 0x800483d8 )
114 : ===== Array delete. =====
118 : ===== Complete. =====

请注意，现在使用不同的删除函数删除数组。当编译为C 11时，删除数组放置新的与第76行的删除函数相同。