operator delete, operator delete[]

void operator delete  ( void* ptr ) throw();

void operator delete  ( void* ptr ) noexcept;

void operator delete[]( void* ptr ) throw();

void operator delete[]( void* ptr ) noexcept;

void operator delete  ( void* ptr, std::align_val_t al ) noexcept;

void operator delete[]( void* ptr, std::align_val_t al ) noexcept;

void operator delete  ( void* ptr, std::size_t sz ) noexcept;

void operator delete[]( void* ptr, std::size_t sz ) noexcept;

void operator delete  ( void* ptr, std::size_t sz,
                        std::align_val_t al ) noexcept;

void operator delete[]( void* ptr, std::size_t sz,
                        std::align_val_t al ) noexcept;

void operator delete  ( void* ptr, const std::nothrow_t& tag ) throw();

void operator delete  ( void* ptr, const std::nothrow_t& tag ) noexcept;

void operator delete[]( void* ptr, const std::nothrow_t& tag ) throw();

void operator delete[]( void* ptr, const std::nothrow_t& tag ) noexcept;

void operator delete  ( void* ptr, std::align_val_t al,
                        const std::nothrow_t& tag ) noexcept;

void operator delete[]( void* ptr, std::align_val_t al,
                        const std::nothrow_t& tag ) noexcept;

void operator delete  ( void* ptr, void* place ) throw();

void operator delete  ( void* ptr, void* place ) noexcept;

void operator delete[]( void* ptr, void* place ) throw();

void operator delete[]( void* ptr, void* place ) noexcept;

void operator delete  ( void* ptr, args... );

void operator delete[]( void* ptr, args... );

void T::operator delete  ( void* ptr );

void T::operator delete[]( void* ptr );

void T::operator delete  ( void* ptr, std::align_val_t al );

void T::operator delete[]( void* ptr, std::align_val_t al );

void T::operator delete  ( void* ptr, std::size_t sz );

void T::operator delete[]( void* ptr, std::size_t sz );

void T::operator delete  ( void* ptr, std::size_t sz, std::align_val_t al );

void T::operator delete[]( void* ptr, std::size_t sz, std::align_val_t al );

void T::operator delete  ( void* ptr, args... );

void T::operator delete[]( void* ptr, args... );

void T::operator delete( T* ptr, std::destroying_delete_t );

void T::operator delete( T* ptr, std::destroying_delete_t,
                         std::align_val_t al );

void T::operator delete( T* ptr, std::destroying_delete_t, std::size_t sz );

void T::operator delete( T* ptr, std::destroying_delete_t,
                         std::size_t sz, std::align_val_t al );

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

Во всех случаях, если ptr является указателем null, стандартные функции освобождения не выполняют никаких действий. Если указатель, переданный стандартной функции освобождения, не был получен из соответствующей стандартной функции выделения, поведение не определено.

После возвращения стандартной функции освобождения все указатели, ссылающиеся на любую часть освобожденной памяти, становятся недействительными.

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

Параметры

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

(нет)

Исключения

Если функция освобождения завершается сбрасыванием исключения, поведение является неопределённым, даже если она объявлена с noexcept(false)(с C++11).

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

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

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

Реализации стандартной библиотеки для версий (9,10) без исключений напрямую вызывают соответствующие версии с исключениями (1,2). Реализации стандартной библиотеки для функций освобождения с учётом размера (5-8) напрямую вызывают соответствующие функции освобождения без учёта размера (1-4). Реализации стандартной библиотеки для функций освобождения без учёта размера для массивов с исключениями (2,4) напрямую вызывают соответствующие однообъектные формы (1,3). Таким образом, замена функций освобождения с исключениями для одного объекта (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 delete и operator delete[] с дополнительными пользовательскими параметрами ("размещаемые формы", (15,16)) могут быть объявлены на глобальном уровне как обычно и вызываются соответствующими размещаемыми формами выражений new, если конструктор объекта, который выделяется, выбрасывает исключение.

Размещаемые формы operator delete (13,14) в стандартной библиотеке не могут быть заменены и могут быть настраиваемы только если выражение placement new не использовало синтаксис ::new, предоставив специфическую для класса функцию placement delete (25,26) с соответствующей сигнатурой: void T::operator delete(void*, void*) или void T::operator delete[](void*, void*).

Функции освобождения для конкретных классов

Функции освобождения (17-24) могут быть определены как статические член-функции класса. Эти функции освобождения, если предоставлены, вызываются выражениями delete при удалении объектов (17,19,21) и массивов (18,20,22) этого класса, если выражение delete не использовало форму ::delete, которая опускает поиск в области видимости класса. Ключевое слово static необязательно для этих объявлений функций: независимо от того, используется оно или нет, функция освобождения всегда является статической член-функцией.

Выражение delete ищет соответствующую функцию освобождения, начиная с области видимости класса (массивная форма ищет в области видимости класса элемента массива) и переходит к глобальному пространству имён, если члены не найдены, как обычно. Обратите внимание, что в соответствии с правилами поиска имен, любые функции освобождения, объявленные в области видимости класса, скрывают все глобальные функции освобождения.

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

Если одноаргументная перегрузка (17,18) не предоставлена, но перегрузка с учётом размера, принимающая std::size_t в качестве второго параметра (21,22) предоставлена, то форма с учётом размера вызывается для нормального освобождения, и C++ среда выполняет передачу размера освобождаемого объекта в качестве второго аргумента. Если обе формы определены, вызывается версия без учёта размера.

#include <cstddef>
#include <iostream>
 
// sized class-specific deallocation functions
struct X
{
    static void operator delete(void* ptr, std::size_t sz)
    {
        std::cout << "custom delete for size " << sz << '\n';
        ::operator delete(ptr);
    }
 
    static void operator delete[](void* ptr, std::size_t sz)
    {
        std::cout << "custom delete for size " << sz << '\n';
        ::operator delete[](ptr);
    }
};
 
int main()
{
    X* p1 = new X;
    delete p1;
 
    X* p2 = new X[10];
    delete[] p2;
}

custom delete for size 1
custom delete for size 18

Перегрузки operator delete и operator delete[] с дополнительными параметрами, заданными пользователем («формы размещения», (25,26)), также могут быть определены как члены класса. Когда не удаётся выполнить выражение размещённого выделения памяти, поиск соответствующей функции размещённого удаления начинается в области видимости класса перед исследованием глобальной области видимости, и функция ищется с подписью, соответствующей размещённому выделению памяти:

#include <cstddef>
#include <iostream>
#include <stdexcept>
 
struct X
{
    X() { throw std::runtime_error("X(): std::runtime_error"); }
 
    // custom placement new
    static void* operator new(std::size_t sz, bool b)
    {
        std::cout << "custom placement new called, b = " << b << '\n';
        return ::operator new(sz);
    }
 
    // 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& ex)
    {
        std::cout << ex.what() << '\n';
    }
}

custom placement new called, b = 1
custom placement delete called, b = 1
X(): std::runtime_error

Если operator delete на уровне класса — это шаблонная функция, она должна иметь возвращаемый тип void, первый аргумент void*, и она должна иметь два или более параметра. Другими словами, только формы размещения могут быть шаблонами. Экземпляр шаблона никогда не является обычной функцией освобождения, независимо от её подписи. Специализация оператора удаления шаблона выбирается с помощью вывода аргументов шаблона.

Примечания

Вызов класса T::operator delete для полиморфного класса — единственный случай, когда статическая член-функция вызывается через динамическую диспетчеризацию.

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

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

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

См. также