Przejdź do głównej zawartości

std::allocator<T>::deallocate

Since C++20
constexpr void deallocate( T* p, std::size_t n );
Until C++20
void deallocate( T* p, std::size_t n );

Deallocates the storage referenced by the pointer p, which must be a pointer obtained by an earlier call to allocate() or allocate_at_least()  (od C++23).

The argument n must be equal to the first argument of the call to allocate() that originally produced p,
or in the range [m, count] if p is obtained from a call to allocate_at_least(m) which returned {p, count}  (od C++23)
otherwise, the behavior is undefined.

Calls ::operator delete(void*) or ::operator delete(void*, std::align_val_t)  (od C++17), but it is unspecified when and how it is called .
In evaluation of a constant expression, this function must deallocate storage allocated within the evaluation of the same expression.  (od C++20)

Parameters

p - pointer obtained from allocate() or allocate_at_least()  (od C++23)
n - number of objects earlier passed to allocate() , or a number between requested and actually allocated number of objects via allocate_at_least() (may be equal to either bound) (od C++23)

Return value

(none)

Example

#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'; }
}
Result
#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();

std::allocator<T>::deallocate

Since C++20
constexpr void deallocate( T* p, std::size_t n );
Until C++20
void deallocate( T* p, std::size_t n );

Deallocates the storage referenced by the pointer p, which must be a pointer obtained by an earlier call to allocate() or allocate_at_least()  (od C++23).

The argument n must be equal to the first argument of the call to allocate() that originally produced p,
or in the range [m, count] if p is obtained from a call to allocate_at_least(m) which returned {p, count}  (od C++23)
otherwise, the behavior is undefined.

Calls ::operator delete(void*) or ::operator delete(void*, std::align_val_t)  (od C++17), but it is unspecified when and how it is called .
In evaluation of a constant expression, this function must deallocate storage allocated within the evaluation of the same expression.  (od C++20)

Parameters

p - pointer obtained from allocate() or allocate_at_least()  (od C++23)
n - number of objects earlier passed to allocate() , or a number between requested and actually allocated number of objects via allocate_at_least() (may be equal to either bound) (od C++23)

Return value

(none)

Example

#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'; }
}
Result
#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();