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) являются заменяемыми. Действия версий по умолчанию:

#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) стандартной библиотеки не могут быть заменены и могут быть настроены только в том случае, если размещающее 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)). Когда выражение 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 и должна иметь два или более параметров. Другими словами, шаблонами могут быть только размещающие формы.

Примечания

Хотя неразмещающий placement new ( 9,10 ) не может быть заменён, функция с такой же сигнатурой может быть определена в области видимости класса, как описано выше. Кроме того, разрешены глобальные перегрузки, которые выглядят как placement new , но принимают тип не-void указателя в качестве второго аргумента. Поэтому код, который хочет гарантировать вызов настоящего placement new (например, std::allocator::construct ), должен использовать :: new и также приводить указатель к void * .

Если поведение функции освобождения не удовлетворяет стандартным ограничениям, поведение не определено.

Не определено, вызывают ли библиотечные версии operator new какие-либо вызовы std::malloc или std::aligned_alloc (начиная с C++17) .

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

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

Отчеты о дефектах

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

Ссылки

Смотрите также