std::allocator<T>::deallocate
来自cppreference.com
| |
(C++20 起为 constexpr) |
|
解分配指针 p 所引用的存储，指针必须是通过先前调用 allocate() 或 allocate_at_least()(C++23 起) 获得的指针。
实参 n 必须等于对原先生成 p 的 allocate() 调用的首个实参，或若 p 由返回 {p, count} 的调用 allocate_at_least(m) 获得，则在范围 [m, 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();
参阅
| 分配未初始化的存储 (公开成员函数) | |
(C++23) |
分配与请求的大小至少一样大的未初始化存储 (公开成员函数) |
[静态] |
用分配器解分配存储 ( std::allocator_traits<Alloc> 的公开静态成员函数)
|