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 表达式调用。

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

有关选择重载的标准，请参见 new 表达式。

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 是未指定的。

如果尝试成功，则返回指向已分配存储空间的指针。
否则，如果当前未安装 new-handler，则抛出 std::bad_alloc。
否则，调用当前安装的 new-handler。
- 如果 new-handler 返回，则开始另一次分配尝试。
- 否则，退出当前调用。

2) 返回 operator new(count)。

3) 与 (1) 相同。

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

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

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

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

(自 C++26 起)

全局 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)

带有附加用户定义参数（“就地形式”，版本 (11-14)）的 operator new 和 operator 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__ 的对象和对象数组时，重载解析会执行两次：首先，针对感知对齐的函数签名，然后针对不感知对齐的函数签名。这意味着，如果具有扩展对齐方式的类具有不感知对齐的类特定分配函数，则将调用该函数，而不是全局感知对齐的分配函数。这是故意的：类成员应该最了解如何处理该类。

(自 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[] 的重载也可以定义为类成员 (19-22)）。当具有匹配签名的就地 new 表达式查找要调用的相应分配函数时，它首先在类作用域中开始查找，然后再检查全局作用域，并且如果提供了类特定的就地 new，则会调用它。

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

(自 C++17 起)

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

(自 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，并且必须具有两个或多个参数。换句话说，只有就地形式可以是模板。

[编辑] 注解

即使非分配就地 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（自 C++17 起）, std::free

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

（自 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 就地 new 和 new[]

↑ 正式地，如果所有可替换的全局分配函数的默认版本都满足宿主实现的要求，则此宏展开为 202306L。

[编辑] 缺陷报告

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

DR	应用于	已发布行为	正确行为
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 [静态] （C++23）	使用 `Allocator` 分配内存（`std::generator<Ref,V,Allocator>::promise_type` 的公共静态成员函数） [编辑]
operator deleteoperator delete[]	释放函数（函数） [编辑]
get_new_handler (C++11)	获取当前 new 处理函数（函数） [编辑]
set_new_handler	注册新的处理函数（函数） [编辑]
get_temporary_buffer （在 C++17 中弃用）（在 C++20 中移除）	获取未初始化的存储（函数模板） [编辑]
malloc	分配内存（函数） [编辑]
aligned_alloc (C++17)	分配对齐的内存（函数） [编辑]

[1] 正式地，如果所有可替换的全局分配函数的默认版本都满足宿主实现的要求，则此宏展开为 202306L。

[1]

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

cppreference.cn

命名空间

变体

视图

操作

operator new, operator new[]

目录

[编辑] 参数

[编辑] 返回值

[编辑] 异常

[编辑] 全局替换

[编辑] 类特定的重载

[编辑] 注解

[编辑] 缺陷报告

[编辑] 参考文献

[编辑] 参见

导航

工具箱

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