# std::allocator<T>::deallocate

< cpp‎ | memory‎ | allocator

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` 必须等于对原先生成 `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();

### 参阅

allocate | 分配未初始化的存储 (公开成员函数)
allocate_at_least (C++23) | 分配与请求的大小至少一样大的未初始化存储 (公开成员函数)
deallocate [静态] | 用分配器解分配存储 (`std::allocator_traits<Alloc>` 的公开静态成员函数)