std::allocator::deallocate
Материал из cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev ">
</tbody><tbody>
</tbody>
void deallocate( T* p, std::size_t n ); |
(до C++20) | |
constexpr void deallocate( T* p, std::size_t n ); |
(начиная с 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); // может сгенерировать исключение
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();
Смотрите также
| выделяет неинициализированное хранилище (public функция-элемент) | |
(C++23) |
выделяет неинициализированное хранилище как минимум такого же размера, как запрошенный размер (public функция-элемент) |
[static] |
освобождает память с помощью аллокатора (public static функция-элемент std::allocator_traits)
|