operator new, operator new[]

定义于头文件 `<new>`
可替换的分配函数
void* operator new ( std::size_t count );	(1)
void* operator new[]( std::size_t count );	(2)
void* operator new ( std::size_t count, std::align_val_t al );	(3)	(自 C++17 起)
void* operator new[]( std::size_t count, std::align_val_t al );	(4)	(自 C++17 起)
可替换的非抛出分配函数
void* operator new ( std::size_t count, const std::nothrow_t& tag );	(5)	(自 C++11 起为 noexcept)
void* operator new[]( std::size_t count, const std::nothrow_t& tag );	(6)	(自 C++11 起为 noexcept)
void* operator new ( std::size_t count, std::align_val_t al, const std::nothrow_t& tag ) noexcept;	(7)	(自 C++17 起)
void* operator new[]( std::size_t count, std::align_val_t al, const std::nothrow_t& tag ) noexcept;	(8)	(自 C++17 起)
非分配定位分配函数
void* operator new ( std::size_t count, void* ptr );	(9)	(自 C++11 起为 noexcept) (自 C++26 起为 constexpr)
void* operator new[]( std::size_t count, void* ptr );	(10)	(自 C++11 起为 noexcept) (自 C++26 起为 constexpr)
用户定义的定位分配函数
void* operator new ( std::size_t count, /* args... */ );	(11)
void* operator new[]( std::size_t count, /* args... */ );	(12)
void* operator new ( std::size_t count, std::align_val_t al, /* args... */ );	(13)	(自 C++17 起)
void* operator new[]( std::size_t count, std::align_val_t al, /* args... */ );	(14)	(自 C++17 起)
类特定的分配函数
void* T::operator new ( std::size_t count );	(15)
void* T::operator new[]( std::size_t count );	(16)
void* T::operator new ( std::size_t count, std::align_val_t al );	(17)	(自 C++17 起)
void* T::operator new[]( std::size_t count, std::align_val_t al );	(18)	(自 C++17 起)
类特定的定位分配函数
void* T::operator new ( std::size_t count, /* args... */ );	(19)
void* T::operator new[]( std::size_t count, /* args... */ );	(20)
void* T::operator new ( std::size_t count, std::align_val_t al, /* args... */ );	(21)	(自 C++17 起)
void* T::operator new[]( std::size_t count, std::align_val_t al, /* args... */ );	(22)	(自 C++17 起)

尝试分配所请求的字节数，并且分配请求可能失败（即使请求的字节数为零）。这些分配函数由 new 表达式调用，以分配内存，随后新对象将在该内存中初始化。它们也可以使用常规函数调用语法来调用。

1-8) 可替换的分配函数。标准库为这些函数提供了默认实现，有关默认实现的效果，请参见下方.

9,10) 由标准定位 new 表达式调用。不执行任何操作并返回 ptr 不变。

如果此函数通过定位 new 并且 ptr 是空指针，则行为未定义。

11-22) 用户定义的分配函数，由 new 表达式调用。

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

参见 new 表达式以了解选择重载的标准。

参数

count	-	要分配的字节数
ptr	-	指向用于初始化对象的内存区域的指针
tag	-	用于选择非抛出重载的消歧义标签
al	-	使用的对齐方式，无效值将导致未定义行为

返回值

1-4) 若分配成功，则返回非空指针 p0 ，该指针指向大小至少为 size 且适当对齐的内存区域，且与任何先前返回的值 p1 均不相同，除非该值 p1 后续已被传递给可替换的解分配函数；若分配失败，则不返回（将抛出异常，详见下文）。

5-8) 与 ( 1-4 ) 相同，但若分配失败则返回空指针。

9,10) ptr

11-22) 若函数在分配失败时不返回，则与 ( 1-4 ) 相同，否则与 ( 5-8 ) 相同。

异常

1-4) 在分配内存失败时，抛出与类型 std::bad_alloc 的处理器相匹配的异常类型。

11-22) 若函数在分配失败时不返回，则与 ( 1-4 ) 相同，否则与 ( 5-8 ) 相同。

全局替换

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

1) 尝试分配请求的存储空间。该尝试是否涉及调用 std::malloc 或 std::aligned_alloc 是未指定的。

如果尝试成功，返回指向已分配存储的指针，存储对齐到基本对齐(直到 C++17)存储对齐到 __STDCPP_DEFAULT_NEW_ALIGNMENT__(自 C++17 起)。
否则，如果当前未安装 new-handler，则抛出 std::bad_alloc。
否则，调用当前安装的 new-handler。
- 如果 new-handler 返回，则开始另一次分配尝试。
- 否则，退出当前调用。

2) 返回 operator new(count)。

3) 与 (1) 相同，但返回的存储对齐到 al。

4) 返回 operator new(count, al)。

5-8) 分别调用 (1-4)，参数相同，但 tag 除外。

如果调用正常返回，则返回该调用的结果。
否则，返回空指针。

在独立实现上，默认版本的 (1-8) 是否满足上述要求的行为是由实现定义的。建议独立实现：如果这些默认版本中的任何一个满足托管实现的要求，则它们都应该满足。

(自 C++26 起)

全局 operatoroperator new/deletenew/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)

带有额外用户定义参数的 operator new 和 operator new[] 的重载（"置入形式"，版本 (11-14)）可以像往常一样在全局作用域声明，并由匹配的 new 置入形式的 new 表达式调用。

标准库的非分配置入形式的 operator new (9,10) 不可替换，并且只能在置入 new 表达式未使用 ::new 语法时通过提供具有匹配签名的类特定置入 new (19,20) 来自定义：void* T::operator new(std::size_t, void*) 或 void* T::operator new[](std::size_t, void*)。

置入形式 void* operator new(std::size_t, std::size_t) 是不允许的，因为解除分配函数的匹配签名 void operator delete(void*, std::size_t) 是普通的（非置入）解除分配函数。

(自 C++14 起)

类特定重载

单对象和数组分配函数都可以定义为类的公共静态成员函数（版本 (15-18)）。如果定义了这些分配函数，它们将由 new 表达式调用，用于为此类的单个对象和数组分配内存，除非 new 表达式使用了形式 ::new，这将绕过类作用域查找。关键字 static 对于这些函数是可选的：无论是否使用，分配函数都是静态成员函数。

new 表达式首先在类作用域中查找合适的分配函数名，然后在全局作用域中查找。注意，根据名称查找规则，在类作用域中声明的任何分配函数都会隐藏所有试图为此类对象分配内存的 new 表达式的全局分配函数。

当分配对齐要求超过 __STDCPP_DEFAULT_NEW_ALIGNMENT__ 的对象或对象数组时，重载解析执行两次：首先针对感知对齐的函数签名，然后针对不感知对齐的函数签名。这意味着，如果具有 new-扩展对齐的类有一个不感知对齐的类特定分配函数，那么将调用该函数，而不是全局的感知对齐分配函数。这是有意的：类成员应该最了解如何处理该类。

(自C++17起)

当分配对齐要求不超过 __STDCPP_DEFAULT_NEW_ALIGNMENT__ 的对象或对象数组时，重载解析执行两次：首先针对不感知对齐的函数签名，然后针对感知对齐的函数签名。

(自C++20起)

运行此代码

#include <cstddef>
#include <iostream>

// class-specific allocation functions
struct X
{
    static void* operator new(std::size_t count)
    {
        std::cout << "custom new for size " << count << '\n';
        return ::operator new(count);
    }
    
    static void* operator new[](std::size_t count)
    {
        std::cout << "custom new[] for size " << count << '\n';
        return ::operator new[](count);
    }
};

int main()
{
    X* p1 = new X;
    delete p1;
    X* p2 = new X[10];
    delete[] p2;
}

可能的输出：

custom new for size 1
custom new[] for size 10

operator new 和 operator new[] 的重载带有额外的用户定义参数（“placement形式”），也可以定义为类成员 (19-22))。当具有匹配签名的 placement new 表达式查找要调用的相应分配函数时，它首先在类作用域中查找，然后才检查全局作用域，如果提供了类特定的 placement new，则调用它。

当分配对齐要求超过 __STDCPP_DEFAULT_NEW_ALIGNMENT__ 的对象或对象数组时，placement形式的重载解析也像常规形式一样执行两次：首先针对感知对齐的函数签名，然后针对不感知对齐的函数签名。

(自C++17起)

当分配对齐要求不超过 __STDCPP_DEFAULT_NEW_ALIGNMENT__ 的对象或对象数组时，placement形式的重载解析也像常规形式一样执行两次：首先针对不感知对齐的函数签名，然后针对感知对齐的函数签名。

(自C++20起)

运行此代码

#include <cstddef>
#include <iostream>
#include <stdexcept>

struct X
{
    X() { throw std::runtime_error(""); }
    
    // custom placement new
    static void* operator new(std::size_t count, bool b)
    {
        std::cout << "custom placement new called, b = " << b << '\n';
        return ::operator new(count);
    }
    
    // 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&)
    {}
}

输出：

custom placement new called, b = 1
custom placement delete called, b = 1

如果类级别的 operator new 是模板函数，则其返回类型必须是 void*，第一个参数必须是 std::size_t，并且它必须有两个或更多参数。换句话说，只有placement形式可以是模板。

注释

尽管不可替换的非分配布置 new ( 9,10 ) ，但如上所述可以在类作用域定义具有相同签名的函数。此外，允许存在形似布置 new 但以非void指针类型作为第二参数的全局重载，因此需要确保调用真正布置 new 的代码（例如 std::allocator::construct ），必须使用 :: new 并将指针强制转换为 void * 。

如果解分配函数的行为不满足默认约束，则行为是未定义的。

以下函数要求是线程安全的：

库版本的 operator new 和 operator delete
全局 operator new 和 operator delete 的用户替换版本
std::calloc , std::malloc , std::realloc , std::aligned_alloc (since C++17) , std::free

对这些函数分配或释放特定存储单元的调用以单一全序发生，且每个这样的释放调用先于该顺序中的下一个分配调用（如果存在）。

(since C++11)

未指定库版本的 operator new 是否会调用 std::malloc 或 std::aligned_alloc (C++17 起) 。

对于加载大型文件，通过操作系统特定函数进行文件映射，例如在POSIX系统上的 mmap 或在Windows系统上的 CreateFileMapping ( A / W )结合 MapViewOfFile ，相较于分配缓冲区进行文件读取更为可取。

功能测试宏	值	标准	功能
`__cpp_lib_freestanding_operator_new`	`202306L`	(C++26)	独立环境对可替换 operator new ^[1] 的支持
`__cpp_lib_freestanding_operator_new`	`0`	(C++26)	无独立环境支持
`__cpp_lib_constexpr_new`	`202406L`	(C++26)	constexpr placement new 与 new [ ]

↑ 严格来说，当所有可替换全局分配函数的默认版本满足托管实现要求时，该宏展开为 202306L 。

缺陷报告

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

缺陷报告	适用版本	发布时行为	正确行为
CWG 521	C++98	任何派生自 std::bad_alloc 的类都可能被抛出，即使 std::bad_alloc 基类存在二义性或不可访问	抛出的异常应当匹配 std::bad_alloc 类型的异常处理器
LWG 9	C++98	多次分配零字节的调用可能返回相同指针	仅当所有此前返回的指针均已传递给解分配函数时才允许
LWG 206	C++98	替换可替换分配函数不会影响对应可替换非抛出版本分配函数的默认行为	默认行为相应改变
LWG 404	C++98	可替换分配函数的替换版本可被声明为 inline	禁止，不要求诊断

参考文献

C++23 标准 (ISO/IEC 14882:2024):

17.7 动态内存管理 [support.dynamic]

C++20 标准 (ISO/IEC 14882:2020):

17.6 动态内存管理 [support.dynamic]

C++17 标准 (ISO/IEC 14882:2017):

21.6 动态内存管理 [support.dynamic]

C++14 标准 (ISO/IEC 14882:2014):

18.6 动态内存管理 [support.dynamic]

C++11 标准 (ISO/IEC 14882:2011):

18.6 动态内存管理 [support.dynamic]

C++03 标准 (ISO/IEC 14882:2003):

18.4 动态内存管理 [lib.support.dynamic]

C++98 标准 (ISO/IEC 14882:1998):

18.4 动态内存管理 [lib.support.dynamic]

参见

operator new [static] (C++23)	使用 `Allocator` 分配内存 ( `std::generator<Ref,V,Allocator>::promise_type` 的公开静态成员函数)
operator delete operator delete[]	释放函数 (函数)
get_new_handler (C++11)	获取当前 new 处理程序 (函数)
set_new_handler	注册 new 处理程序 (函数)
get_temporary_buffer (deprecated in C++17) (removed in C++20)	获取未初始化存储空间 (函数模板)
malloc	分配内存 (函数)
aligned_alloc (C++17)	分配对齐内存 (函数)

[1] 严格来说，当所有可替换全局分配函数的默认版本满足托管实现要求时，该宏展开为 202306L 。

[1]

编译器支持
独立式与托管式
语言
标准库
标准库头文件
具名要求
功能测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

zh.cppreference.net

Namespaces

Variants

operator new, operator new[]

目录

参数

返回值

异常

全局替换

类特定重载

注释

缺陷报告

参考文献

参见