operator delete, operator delete[]

 

C++

编译器支持

自由（freestanding）与宿主（hosted）

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

工具库

语言支持 类型支持（基本类型、RTTI） 库特性测试宏 (C++20) 程序工具 变参函数 initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) 协程支持 (C++20) 契约支持 (C++26) 三路比较 three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

通用工具 函数对象 位操作 (C++20) bitset hash (C++11) 关系运算符 (C++20 中弃用) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= 整数比较函数 cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) 交换与类型操作 swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) 常用词汇类型 pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

内存管理库

voidify (仅作说明*) 未初始化内存算法 uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) 受约束的未初始化 内存算法 ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::construct_at (C++20) ranges::destroy (C++20) ranges::destroy_n (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::uninitialized_default_construct_n (C++20)  ranges::uninitialized_value_construct_n (C++20) C 库 malloc calloc realloc aligned_alloc (C++17) free

分配器 allocator allocator_traits (C++11) allocation_result (C++23) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20)  scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) 内存资源 pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) 垃圾回收支持 declare_reachable (C++11)(直到 C++23) undeclare_reachable (C++11)(直到 C++23) declare_no_pointers (C++11)(直到 C++23) undeclare_no_pointers (C++11)(直到 C++23) pointer_safety (C++11)(直到 C++23) get_pointer_safety (C++11)(直到 C++23) 未初始化存储 raw_storage_iterator (直到 C++20*) get_temporary_buffer (直到 C++20*) return_temporary_buffer (直到 C++20*) 显式生命周期管理 start_lifetime_asstart_lifetime_as_array (C++23)(C++23)

智能指针 unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (直到 C++17*) owner_less (C++11) owner_less<void> (C++17) owner_hash (C++26) owner_equal (C++26) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) 低级内存 管理 operator new operator new[] operator delete operator delete[] get_new_handler (C++11) set_new_handler launder (C++17) bad_alloc bad_array_new_length (C++11) nothrow_t align_val_t (C++17) destroying_delete_t (C++20) new_handler nothrow 杂项 pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) is_sufficiently_aligned (C++26)

 

低级内存管理

函数

operator newoperator new[]

operator deleteoperator delete[]

get_new_handler (C++11)

set_new_handler

类

bad_alloc

bad_array_new_length (C++11)

align_val_t (C++17)

类型

new_handler

对象

nothrow

destroying_delete (C++20)

对象访问

launder (C++17)

 

定义于头文件 <new>
可替换的常规解除分配函数
	(1)
void operator delete  ( void* ptr ) throw();			(C++11 前)
void operator delete  ( void* ptr ) noexcept;			(C++11 起)
		(2)
void operator delete[]( void* ptr ) throw();				(C++11 前)
void operator delete[]( void* ptr ) noexcept;				(C++11 起)
void operator delete  ( void* ptr, std::align_val_t al ) noexcept;			(3)	(C++17 起)
void operator delete[]( void* ptr, std::align_val_t al ) noexcept;			(4)	(C++17 起)
void operator delete  ( void* ptr, std::size_t sz ) noexcept;			(5)	(C++14 起)
void operator delete[]( void* ptr, std::size_t sz ) noexcept;			(6)	(C++14 起)
void operator delete  ( void* ptr, std::size_t sz,                         std::align_val_t al ) noexcept;			(7)	(C++17 起)
void operator delete[]( void* ptr, std::size_t sz,                         std::align_val_t al ) noexcept;			(8)	(C++17 起)
可替换的定位解除分配函数
			(9)
void operator delete  ( void* ptr, const std::nothrow_t& tag ) throw();					(C++11 前)
void operator delete  ( void* ptr, const std::nothrow_t& tag ) noexcept;					(C++11 起)
				(10)
void operator delete[]( void* ptr, const std::nothrow_t& tag ) throw();						(C++11 前)
void operator delete[]( void* ptr, const std::nothrow_t& tag ) noexcept;						(C++11 起)
void operator delete  ( void* ptr, std::align_val_t al,                         const std::nothrow_t& tag ) noexcept;					(11)	(C++17 起)
void operator delete[]( void* ptr, std::align_val_t al,                         const std::nothrow_t& tag ) noexcept;					(12)	(C++17 起)
非分配定位解除分配函数
					(13)
void operator delete  ( void* ptr, void* place ) throw();							(C++11 前)
void operator delete  ( void* ptr, void* place ) noexcept;							(C++11 起)
						(14)
void operator delete[]( void* ptr, void* place ) throw();								(C++11 前)
void operator delete[]( void* ptr, void* place ) noexcept;								(C++11 起)
用户定义的定位解除分配函数
void operator delete  ( void* ptr, args... );							(15)
void operator delete[]( void* ptr, args... );							(16)
类特定的常规解除分配函数
void T::operator delete  ( void* ptr );							(17)
void T::operator delete[]( void* ptr );							(18)
void T::operator delete  ( void* ptr, std::align_val_t al );							(19)	(C++17 起)
void T::operator delete[]( void* ptr, std::align_val_t al );							(20)	(C++17 起)
void T::operator delete  ( void* ptr, std::size_t sz );							(21)
void T::operator delete[]( void* ptr, std::size_t sz );							(22)
void T::operator delete  ( void* ptr, std::size_t sz, std::align_val_t al );							(23)	(C++17 起)
void T::operator delete[]( void* ptr, std::size_t sz, std::align_val_t al );							(24)	(C++17 起)
类特定的定位解除分配函数
void T::operator delete  ( void* ptr, args... );							(25)
void T::operator delete[]( void* ptr, args... );							(26)
类特定的常规销毁解除分配函数
void T::operator delete( T* ptr, std::destroying_delete_t );							(27)	(C++20 起)
void T::operator delete( T* ptr, std::destroying_delete_t,                          std::align_val_t al );							(28)	(C++20 起)
void T::operator delete( T* ptr, std::destroying_delete_t, std::size_t sz );							(29)	(C++20 起)
void T::operator delete( T* ptr, std::destroying_delete_t,                          std::size_t sz, std::align_val_t al );							(30)	(C++20 起)

解除分配先前由匹配的 operator new 或 operator new[] 分配的存储。这些解除分配函数由 delete 和 delete[] 表达式以及 定位 new 表达式 调用，以在销毁（或未能构造）具有动态存储期的对象后解除分配内存。它们也可以使用常规函数调用语法进行调用。

1-12) 可替换的解除分配函数。标准库为这些函数提供了默认实现，默认实现的效果请参阅下方。

1-8) 由 delete 和 delete[] 表达式调用。使任何非空 ptr 失效。

9-12) 在初始化失败时由定位 new 表达式调用。operator delete[] 使任何非空 ptr 失效。

如果 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[] 的中间调用而失效。

13,14) 当表达式中的任何初始化部分因抛出异常而终止时，由调用 非分配定位分配函数 的定位 new 表达式调用。不执行任何操作。

15-30) 由 delete、delete[] 和定位 new 表达式调用的用户定义解除分配函数。

27-30) 如果定义，delete 表达式在调用 operator delete 之前不会执行 *ptr 的析构函数。相反，析构函数的直接调用，例如通过 ptr->~T();，成为此 operator delete 的责任。

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

有关选择重载的条件，请参阅 delete 表达式。

参数

ptr	-	指向要解除分配的内存块的指针或空指针
sz	-	传递给匹配的分配函数的大小
place	-	在匹配的定位 new 中用作定位参数的指针
tag	-	重载消歧标记，与非抛出 operator new 使用的标记匹配
al	-	已分配对象或数组元素的对齐方式
args	-	匹配定位分配函数的任意参数（可能包括 std::size_t 和 std::align_val_t）

异常

所有解除分配函数都是 noexcept(true)，除非在声明中另有规定。

(C++11 起)

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

全局替换

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

1) 如果 ptr 为空，则不执行任何操作。否则，回收先前调用 operator new 分配的存储。

2) 调用 operator delete(ptr)，如同重载 (1) 可以回收先前调用 operator new[] 分配的存储。

3) 同 (1)。

4) 调用 operator delete(ptr, al)，如同重载 (3) 可以回收先前调用 operator new[] 分配的存储。

5) 调用 operator delete(ptr)。

6) 调用 operator delete[](ptr)。

7) 调用 operator delete(ptr, al)。

8) 调用 operator delete[](ptr, al)。

9) 调用 operator delete(ptr)。

10) 调用 operator delete[](ptr)。

11) 调用 operator delete(ptr, al)。

12) 调用 operator delete[](ptr, al)。

全局 operators new/delete 替换

运行此代码

#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)

具有附加用户定义参数（“定位形式”，(15,16)）的 operator delete 和 operator delete[] 的重载可以在全局作用域中声明，并由 new 表达式的匹配定位形式调用，如果正在分配的对象的构造函数抛出异常。

标准库的 operator delete 和 operator delete[] 的定位形式 (13,14) 不能被替换，并且只能在定位 new 表达式未使用 ::new 语法的情况下进行自定义，方法是提供具有匹配签名的类特定定位 delete (25,26)：void T::operator delete(void*, void*) 或 void T::operator delete[](void*, void*)。

类特定重载

解除分配函数 (17-24) 可以定义为类的静态成员函数。如果提供，这些解除分配函数由 delete 表达式在删除此类对象 (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>
 
// sized class-specific deallocation functions
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

具有附加用户定义参数（“定位形式”，(25,26)）的 operator delete 和 operator delete[] 的重载也可以定义为类成员。当失败的定位 new 表达式查找要调用的相应定位 delete 函数时，它会在检查全局作用域之前从类作用域开始查找，并查找与定位 new 签名匹配的函数。

运行此代码

#include <cstddef>
#include <iostream>
#include <stdexcept>
 
struct X
{
    X() { throw std::runtime_error("X(): std::runtime_error"); }
 
    // custom 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);
    }
 
    // custom 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*，并且它必须有两个或更多参数。换句话说，只有定位形式可以是模板。无论其签名如何，模板实例都不是常规解除分配函数。模板 operator delete 的特化通过模板参数推导选择。

注意

在多态类上调用类特定的 T::operator delete 是静态成员函数通过动态调度调用的唯一情况。

以下函数必须是线程安全的 库版本的 operator new 和 operator delete 用户替换版本的全局 operator new 和 operator delete std::calloc、std::malloc、std::realloc、std::aligned_alloc(C++17 起)、std::free 对这些函数中分配或解除分配特定存储单元的调用以单一总顺序发生，并且每次解除分配调用都先于此顺序中的下一次分配（如果有）。

(C++11 起)

特性测试宏	值	标准	特性
__cpp_sized_deallocation	201309L	(C++14)	尺寸感知解除分配
__cpp_impl_destroying_delete	201806L	(C++20)	销毁式 operator delete（编译器支持）
__cpp_lib_destroying_delete	201806L	(C++20)	销毁式 operator delete（库支持）

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	发布时的行为	正确的行为
CWG 220	C++98	允许用户定义的解除分配函数抛出异常	从解除分配函数抛出异常 导致未定义行为
CWG 1438	C++98	任何使用无效指针值的行为都未定义	只有间接引用和解除分配是
LWG 206	C++98	替换 (2) 不影响 (10) 的默认行为	默认行为 相应改变
LWG 298	C++98	替换 (1) 不影响 (9) 的默认行为	默认行为 相应改变
LWG 404	C++98	可替换解除分配函数的替换 函数可以声明为 inline	禁止，无需诊断
LWG 2458	C++14	指定了接受 (void*, std::size_t, const std::nothrow_t&) 的重载，但从未被调用	移除了多余的重载

另请参阅

operator delete [static] (C++23)	解除分配先前从 operator new 获取的内存 (std::generator<Ref,V,Allocator>::promise_type 的公共静态成员函数)
operator newoperator new[]	分配函数 (函数)
return_temporary_buffer (在 C++17 中已弃用)(在 C++20 中已移除)	释放未初始化存储 (函数模板)
free	释放先前分配的内存 (函数)