Namespaces
Variants

std::allocator<T>:: deallocate

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::allocator
void deallocate ( T * p, std:: size_t n ) ;
(constexpr seit C++20)

Gibt den Speicher frei, auf den der Zeiger p verweist, welcher durch einen vorherigen Aufruf von allocate() oder allocate_at_least() (since C++23) erhalten worden sein muss.

Das Argument n muss gleich dem ersten Argument des Aufrufs von allocate() sein, das ursprünglich p erzeugt hat , oder im Bereich [ m , count ] liegen, falls p von einem Aufruf von allocate_at_least ( m ) stammt, der { p, count } zurückgab (seit C++23) ; andernfalls ist das Verhalten undefiniert.

Ruft :: operator delete ( void * ) oder :: operator delete ( void * , std:: align_val_t ) (seit C++17) auf, aber es ist nicht spezifiziert, wann und wie es aufgerufen wird.

Bei der Auswertung eines konstanten Ausdrucks muss diese Funktion den Speicher freigeben, der innerhalb der Auswertung desselben Ausdrucks allokiert wurde.

(since C++20)

Inhaltsverzeichnis

Parameter

p - Zeiger, erhalten von allocate() oder allocate_at_least() (seit C++23)
n - Anzahl der Objekte, die zuvor an allocate() übergeben wurden , oder eine Zahl zwischen der angeforderten und der tatsächlich zugewiesenen Anzahl von Objekten über allocate_at_least() (kann gleich einer der beiden Grenzen sein) (seit C++23)

Rückgabewert

(keine)

Beispiel

Diesen Code ausführen 
#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); // kann werfen
        for (std::size_t i{}; i != n; ++i)
        {
        //  allocator.construct(&s[i], i + 42); // entfernt in C++20
            std::construct_at(&s[i], i + 42);   // seit 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'; }
}

Ausgabe: 

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

Siehe auch

reserviert nicht initialisierten Speicher
(öffentliche Elementfunktion)
(C++23)
reserviert nicht initialisierten Speicher in mindestens der angeforderten Größe
(öffentliche Elementfunktion)
[static]
gibt Speicher unter Verwendung des Allokators frei
(öffentliche statische Elementfunktion von std::allocator_traits<Alloc> )