std::allocator<T>::deallocate
来自 cppreference.com
| void deallocate( T* p, std::size_t n ); |
(constexpr since C++20) | |
释放指针 p 所指向的存储空间，该指针必须是之前调用 allocate() 或 allocate_at_least()(since C++23) 获得的指针。
参数 n 必须等于最初生成 p 的 allocate() 调用中的第一个参数，或者在范围 [m, count] 内（可以等于任何一个边界），如果 p 是从调用返回 {p, count} 的 allocate_at_least(m) 获取的。(since C++23)；否则，行为未定义。
调用 ::operator delete(void*) 或 ::operator delete(void*, std::align_val_t)(since 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); // 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();
[编辑] 参见
| 分配未初始化存储空间 (公有成员函数) | |
| (C++23) |
分配至少与请求大小一样大的未初始化存储空间 (公有成员函数) |
| [静态] |
使用分配器释放存储空间 ( std::allocator_traits<Alloc> 的公有静态成员函数) |
