operator delete , operator delete[]

释放先前由匹配的 operator new 或 operator new[] 分配的存储空间。这些释放函数通过 delete 和 delete [ ] 表达式 以及 placement new 表达式 调用，用于在析构（或构造失败）具有动态存储期的对象后释放内存。也可以通过常规函数调用语法来调用这些函数。

如果 ptr 不是空指针且满足以下任一条件，则行为未定义：

• 对于 operator delete ， ptr 的值不表示通过先前调用（可能被替换的） operator new ( std:: size_t ) （对于重载 (1,5,9) ）或 operator new ( std:: size_t , std:: align_val_t ) （对于重载 (3,7,11) ）所分配的内存块地址，且该地址未被中间对 operator delete 的调用所失效。
• 对于 operator delete [ ] ， ptr 的值不表示通过先前调用（可能被替换的） operator new [ ] ( std:: size_t ) （对于重载 (2,6,10) ）或 operator new [ ] ( std:: size_t , std:: align_val_t ) （对于重载 (4,8,12) ）所分配的内存块地址，且该地址未被中间对 operator delete [ ] 的调用所失效。

重载版本 ( 1-8 ) 在每个翻译单元中隐式声明，即使未包含 <new> 头文件。

请参阅 delete 表达式 了解选择重载的标准。

参数

异常

如果解分配函数因抛出异常而终止，则行为未定义 ，即使它被声明为 noexcept ( false ) (C++11 起) 。

全局替换

重载版本 ( 1-12 ) 是 可替换的 。默认版本的效果如下：

#include <cstdio>
#include <cstdlib>
#include <new>
// no inline, required by [replacement.functions]/3
void* operator new(std::size_t sz)
{
    std::printf("1) new(size_t), size = %zu\n", sz);
    if (sz == 0)
        ++sz; // avoid std::malloc(0) which may return nullptr on success
    if (void *ptr = std::malloc(sz))
        return ptr;
    throw std::bad_alloc{}; // required by [new.delete.single]/3
}
// no inline, required by [replacement.functions]/3
void* operator new[](std::size_t sz)
{
    std::printf("2) new[](size_t), size = %zu\n", sz);
    if (sz == 0)
        ++sz; // avoid std::malloc(0) which may return nullptr on success
    if (void *ptr = std::malloc(sz))
        return ptr;
    throw std::bad_alloc{}; // required by [new.delete.single]/3
}
void operator delete(void* ptr) noexcept
{
    std::puts("3) delete(void*)");
    std::free(ptr);
}
void operator delete(void* ptr, std::size_t size) noexcept
{
    std::printf("4) delete(void*, size_t), size = %zu\n", size);
    std::free(ptr);
}
void operator delete[](void* ptr) noexcept
{
    std::puts("5) delete[](void* ptr)");
    std::free(ptr);
}
void operator delete[](void* ptr, std::size_t size) noexcept
{
    std::printf("6) delete[](void*, size_t), size = %zu\n", size);
    std::free(ptr);
}
int main()
{
    int* p1 = new int;
    delete p1;
    int* p2 = new int[10]; // guaranteed to call the replacement in C++11
    delete[] p2;
}

// Compiled with GCC-5 in C++17 mode to obtain the following:
1) op new(size_t), size = 4
4) op delete(void*, size_t), size = 4
2) op new[](size_t), size = 40
5) op delete[](void* ptr)

具有额外用户定义参数的 operator delete 和 operator delete [ ] 重载版本（“placement 形式”， ( 15,16 ) ）可以像常规函数一样在全局作用域中声明，当正在分配对象的构造函数抛出异常时，会被匹配的 new 表达式的 placement 形式调用。

标准库中 operator delete 和 operator delete [ ] 的布置形式 ( 13,14 ) 不可被替换，且仅当布置 new 表达式未使用 :: new 语法时，才能通过提供具有匹配签名的类特定布置删除函数 ( 25,26 ) 进行自定义： void T :: operator delete ( void * , void * ) 或 void T :: operator delete [ ] ( void * , void * ) 。

类特定重载

释放函数 ( 17-24 ) 可定义为类的静态成员函数。当删除此类对象 ( 17,19,21 ) 和数组 ( 18,20,22 ) 时，若存在这些释放函数，则会被 delete 表达式调用，除非使用了 :: delete 形式的删除表达式（该形式会绕过类作用域查找）。关键字 static 在这些函数声明中是可选的：无论是否使用该关键字，释放函数始终是静态成员函数。

delete 表达式从类作用域开始查找适当的解分配函数名称（数组形式则在数组元素类的作用域中查找），若未找到成员函数则按常规方式继续在全局作用域查找。请注意，根据 名称查找规则 ，在类作用域中声明的任何解分配函数都会隐藏所有全局解分配函数。

如果被删除对象的静态类型与其动态类型不同（例如通过基类指针删除 多态 对象时），且静态类型中的析构函数为虚函数，则delete的单对象形式会从最终覆盖其虚析构函数的定义点开始查找解分配函数的名称。无论运行时实际执行哪个解分配函数，静态可见版本的 operator delete 必须可访问才能通过编译。其他情况下，当通过基类指针删除数组，或通过基类指针删除具有非虚析构函数的对象时，其行为是未定义的。

如果未提供单参数重载 ( 17,18 ) ，但提供了以 std::size_t 作为第二个参数的感知大小重载 ( 21,22 ) ，则正常释放内存时将调用感知大小版本，C++运行时会将被释放对象的大小作为第二个参数传递。如果同时定义了两个版本，则调用不感知大小的版本。

#include <cstddef>
#include <iostream>
// 特定大小的类专属释放函数
struct X
{
    static void operator delete(void* ptr, std::size_t sz)
    {
        std::cout << "custom delete for size " << sz << '\n';
        ::operator delete(ptr);
    }
    static void operator delete[](void* ptr, std::size_t sz)
    {
        std::cout << "custom delete for size " << sz << '\n';
        ::operator delete[](ptr);
    }
};
int main()
{
    X* p1 = new X;
    delete p1;
    X* p2 = new X[10];
    delete[] p2;
}

custom delete for size 1
custom delete for size 18

具有额外用户定义参数的 operator delete 和 operator delete [ ] 重载版本（"placement 形式"， ( 25,26 ) ）也可以定义为类的成员函数。当失败的 placement new 表达式寻找对应的 placement delete 函数进行调用时，会在检查全局作用域之前先从类作用域开始查找，并寻找与 placement new 签名匹配的函数：

#include <cstddef>
#include <iostream>
#include <stdexcept>
struct X
{
    X() { throw std::runtime_error("X(): std::runtime_error"); }
    // 自定义 placement new
    static void* operator new(std::size_t sz, bool b)
    {
        std::cout << "custom placement new called, b = " << b << '\n';
        return ::operator new(sz);
    }
    // 自定义 placement delete
    static void operator delete(void* ptr, bool b)
    {
        std::cout << "custom placement delete called, b = " << b << '\n';
        ::operator delete(ptr);
    }
};
int main()
{
    try
    {
        [[maybe_unused]] X* p1 = new (true) X;
    }
    catch (const std::exception& ex)
    {
        std::cout << ex.what() << '\n';
    }
}

custom placement new called, b = 1
custom placement delete called, b = 1
X(): std::runtime_error

如果类级别的 operator delete 是模板函数，其返回类型必须为 void ，第一个参数必须为 void * ，且必须具有两个或更多参数。换言之，只有 placement 形式的 operator delete 才能作为模板。无论其签名如何，模板实例永远不会成为常规的释放函数。模板 operator delete 的特化版本通过 模板实参推导 进行选择。

注释

对多态类调用特定类的 T :: operator delete 是通过动态分派调用静态成员函数的唯一场景。

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

参见