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

// 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[] с дополнительными пользовательскими параметрами ("placement forms", версии ( 11-14 ) ) могут быть объявлены в глобальной области видимости как обычно и вызываются соответствующими placement forms выражений 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[] с дополнительными пользовательскими параметрами ("placement forms") также могут быть определены как члены класса ( 19-22 ) ). Когда выражение размещения new с соответствующей сигнатурой ищет соответствующую функцию выделения памяти для вызова, оно начинает поиск в области видимости класса перед изучением глобальной области видимости, и если предоставлен специфичный для класса placement 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++.

Ссылки

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