std::allocator<T>::deallocate

void deallocate( T* p, std::size_t n );

(constexpr с C++20)

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

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

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

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

(с C++20)

Параметры

p	-	указатель, полученный в результате вызова `allocate()` или `allocate_at_least()`(с C++23)
n	-	количество объектов, ранее переданное в `allocate()`, или число в диапазоне от запрошенного до фактически выделенного количества объектов с помощью `allocate_at_least()` (может совпадать с любой из границ)(с 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); // may throw
        for (std::size_t i{}; i != n; ++i)
        {
        //  allocator.construct(&s[i], i + 42); // removed in C++20
            std::construct_at(&s[i], i + 42);   // since 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();

См. также

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

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/memory/allocator/deallocate