Namespaces
Variants

std::allocator<T>:: deallocate

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::allocator
void deallocate ( T * p, std:: size_t n ) ;
(constexpr начиная с C++20)

Освобождает хранилище, на которое ссылается указатель p , который должен быть указателем, полученным предыдущим вызовом allocate() или allocate_at_least() (since C++23) .

Аргумент n должен быть равен первому аргументу вызова allocate() , который изначально создал p , или находиться в диапазоне [ m , count ] если p получен из вызова allocate_at_least ( m ) , который вернул { p, count } (since C++23) ; в противном случае поведение не определено.

Вызывает :: operator delete ( void * ) или :: operator delete ( void * , std:: align_val_t ) (начиная с C++17) , однако не определено, когда и как это происходит.

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

(since C++20)

Содержание

Параметры

p - указатель, полученный из allocate() или allocate_at_least() (since C++23)
n - количество объектов, ранее переданных в allocate() , или число между запрошенным и фактически выделенным количеством объектов через allocate_at_least() (может быть равно любой из границ) (since C++23)

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

(нет)

Пример

Запустить этот код 
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <memory>
#include <string>
class S
{
    inline static int n{1};
    int m{};
    void pre() const { std::cout << "#" << m << std::string(m, ' '); }
public:
    S(int x) : m{n++} { pre(); std::cout << "S::S(" << x << ");\n"; }
    ~S() { pre(); std::cout << "S::~S();\n"; }
    void id() const { pre(); std::cout << "S::id();\n"; }
};
int main()
{
    constexpr std::size_t n{4};
    std::allocator<S> allocator;
    try
    {
        S* s = allocator.allocate(n); // может выбросить исключение
        for (std::size_t i{}; i != n; ++i)
        {
        //  allocator.construct(&s[i], i + 42); // удалено в C++20
            std::construct_at(&s[i], i + 42);   // начиная с C++20
        }
        std::for_each_n(s, n, [](const auto& e) { e.id(); });
        std::destroy_n(s, n);
        allocator.deallocate(s, n);
    }
    catch (std::bad_array_new_length const& ex) { std::cout << ex.what() << '\n'; }
    catch (std::bad_alloc const& ex) { std::cout << ex.what() << '\n'; }
}

Вывод: 

#1 S::S(42);
#2  S::S(43);
#3   S::S(44);
#4    S::S(45);
#1 S::id();
#2  S::id();
#3   S::id();
#4    S::id();
#1 S::~S();
#2  S::~S();
#3   S::~S();
#4    S::~S();

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

выделяет неинициализированную память
(публичная функция-член)
(C++23)
выделяет неинициализированную память размером не менее запрошенного
(публичная функция-член)
[static]
освобождает память с использованием аллокатора
(публичная статическая функция-член std::allocator_traits<Alloc> )