operator new , operator new[]

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

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

参见 new expression 了解选择重载的标准。

参数

返回值

异常

全局替换

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

#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;
}

// 使用 GCC-5 在 C++17 模式下编译获得以下结果：
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)

具有额外用户定义参数（"placement forms"，版本 ( 11-14 ) ）的 operator new 和 operator new[] 重载可以在全局作用域中正常声明，并通过匹配的 placement 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 * ) 。

类特定重载

单对象和数组分配函数均可定义为类的公共静态成员函数（版本 ( 15-18 ) ）。若已定义，则 new 表达式将调用这些分配函数来为此类的单对象及数组分配内存，除非 new 表达式使用了跳过类作用域查找的 :: new 形式。对于这些函数，关键字 static 是可选的：无论是否使用该关键字，分配函数均为静态成员函数。

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

#include <cstddef>
#include <iostream>
// 类特定的分配函数
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

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

#include <cstddef>
#include <iostream>
#include <stdexcept>
struct X
{
    X() { throw std::runtime_error(""); }
    // 自定义 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);
    }
    // 自定义 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 形式的 operator new 才能作为模板函数。

注释

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

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

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

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

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

缺陷报告

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

参考文献

参见