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& tag ) noexcept;

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

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, /* args... */ );

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

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

void* operator new[]( std::size_t count,
                      std::align_val_t al, /* 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, /* args... */ );

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

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

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

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

Перегрузки (1-4) неявно объявляются в каждой единице трансляции, даже если заголовок <new> не включен.

Критерии выбора перегрузки см. в описании new-выражения.

Параметры

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

Исключения

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

Перегрузки (1-8) являются заменяемыми. Эффекты версий по умолчанию:

• Если попытка успешна, возвращает указатель на выделенную область памяти; память выровнена по фундаментальному выравниванию(до C++17)память выровнена по __STDCPP_DEFAULT_NEW_ALIGNMENT__(начиная с C++17).
• В противном случае, если в данный момент не установлен обработчик new, выбрасывает std::bad_alloc.
• В противном случае вызывает установленный в данный момент обработчик new.
  • Если обработчик new возвращает управление, начинает новую попытку выделения памяти.
  • В противном случае завершает текущий вызов.

• Если вызов завершается нормально, возвращает результат этого вызова.
• В противном случае возвращает нулевой указатель.

#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[] с дополнительными пользовательскими параметрами («формы размещения») могут, как обычно, объявляться в глобальной области видимости и вызываются соответствующими формами размещения new-выражений.

Невыделяющие формы размещения operator new стандартной библиотеки (9,10) нельзя заменять; их можно настроить, только если в размещающем new-выражении не использован синтаксис ::new, определив соответствующую по сигнатуре специфичную для класса функцию размещения new (19,20): void*T::operatornew(std::size_t,void*) или void*T::operatornew[](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). Когда размещающее 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, а не выделять буфер для чтения файла.

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

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

Ссылки

• Стандарт 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]

См. также