operator new, operator new[]

void* operator new  ( std::size_t count );

void* operator new[]( std::size_t count );

void* operator new  ( std::size_t count, std::align_val_t al );

void* operator new[]( std::size_t count, std::align_val_t al );

void* operator new  ( std::size_t count, const std::nothrow_t& tag );

void* operator new[]( std::size_t count, const std::nothrow_t& tag );

void* operator new  ( std::size_t count,
                      std::align_val_t al, const std::nothrow_t& );

void* operator new[]( std::size_t count,
                      std::align_val_t al, const std::nothrow_t& );

void* operator new  ( std::size_t count, void* ptr );

void* operator new[]( std::size_t count, void* ptr );

void* operator new  ( std::size_t count, user-defined-args... );

void* operator new[]( std::size_t count, user-defined-args... );

void* operator new  ( std::size_t count,
                      std::align_val_t al, user-defined-args... );

void* operator new[]( std::size_t count, 
                      std::align_val_t al, user-defined-args... );

void* T::operator new  ( std::size_t count );

void* T::operator new[]( std::size_t count );

void* T::operator new  ( std::size_t count, std::align_val_t al );

void* T::operator new[]( std::size_t count, std::align_val_t al );

void* T::operator new  ( std::size_t count, user-defined-args... );

void* T::operator new[]( std::size_t count, user-defined-args... );

void* T::operator new  ( std::size_t count,
                         std::align_val_t al, user-defined-args... );

void* T::operator new[]( std::size_t count,
                         std::align_val_t al, user-defined-args... );

Попытки выделить запрошенное количество байтов, и запрос выделения памяти может завершиться неудачей (даже если запрошенное количество байтов равно нулю). Эти функции выделения вызываются выражениями new для выделения памяти, в которой затем будет инициализирован новый объект. Они также могут быть вызваны с использованием обычной синтаксической конструкции вызова функций.

Параметры

Возвращаемое значение

Исключение

Глобальные замены

Версии (1-4) неявно объявляются в каждом файле трансляции, даже если заголовок <new> не включен. Версии (1-8) заменяемые: пользовательская функция без указания класса с той же сигнатурой, определённая где-либо в программе, в любом исходном файле, заменяет стандартную версию. Её объявление не обязательно видно.

Программа некорректна (без диагностики), если более чем одна замена предоставлена в программе для любой из заменяемых функций выделения или если замена объявлена с inline спецификатором. Программа некорректна, если замена определена в пространстве имён, отличном от глобального пространства имён, или если она определена как статическая функция без указания класса на глобальном уровне.

Реализации стандартной библиотеки для версий без исключений (5-8) напрямую вызывают соответствующие версии с исключениями (1-4). Реализация стандартной библиотеки для версий выделения массивов с исключениями (2,4) напрямую вызывает соответствующие версии выделения одиночного объекта (1,3). Таким образом, замена функций выделения одиночного объекта с исключениями достаточно для обработки всех выделений.

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

Невыделяющие формы размещения operator new (9,10) в стандартной библиотеке не могут быть заменены и могут быть настроены только если выражение placement 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>
 
// 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). Когда выражение placement new с соответствующей сигнатурой ищет соответствующую функцию выделения для вызова, оно начинает в области видимости класса, прежде чем проверять глобальную область видимости, и если предоставлена класс-специфическая форма размещения new, она вызывается.

#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 какие-либо вызовы std::malloc или std::aligned_alloc(с C++17).

Для загрузки большого файла предпочтительнее использовать отображение файла с помощью функций операционной системы, например, mmap на POSIX или CreateFileMapping(A/W) вместе с MapViewOfFile на Windows, а не выделять буфер для чтения файла.

1. Формально, эта макрокоманда расширяется до 202306L если все стандартные реализации замещаемых глобальных функций выделения удовлетворяют требованиям хостированной реализации.

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2023):
• 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]

См. также