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 depuis C++20)

Libère le stockage référencé par le pointeur p , qui doit être un pointeur obtenu par un appel antérieur à allocate() ou allocate_at_least() (depuis C++23) .

L'argument n doit être égal au premier argument de l'appel à allocate() qui a initialement produit p , ou dans l'intervalle [ m , count ] si p est obtenu d'un appel à allocate_at_least ( m ) qui a retourné { p, count } (depuis C++23) ; sinon, le comportement est indéfini.

Appelle :: operator delete ( void * ) ou :: operator delete ( void * , std:: align_val_t ) (depuis C++17) , mais il n'est pas spécifié quand et comment il est appelé.

Lors de l'évaluation d'une expression constante, cette fonction doit désallouer le stockage alloué durant l'évaluation de la même expression.

(since C++20)

Table des matières

Paramètres

p - pointeur obtenu à partir de allocate() ou allocate_at_least() (depuis C++23)
n - nombre d'objets précédemment passé à allocate() , ou un nombre entre le nombre demandé et le nombre réellement alloué via allocate_at_least() (peut être égal à l'une ou l'autre limite) (depuis C++23)

Valeur de retour

(aucun)

Exemple

Exécuter ce code 
#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); // peut lever une exception
        for (std::size_t i{}; i != n; ++i)
        {
        //  allocator.construct(&s[i], i + 42); // supprimé en C++20
            std::construct_at(&s[i], i + 42);   // depuis 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'; }
}

Sortie : 

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

Voir aussi

alloue un stockage non initialisé
(fonction membre publique)
(C++23)
alloue un stockage non initialisé d'au moins la taille demandée
(fonction membre publique)
[static]
libère le stockage en utilisant l'allocateur
(fonction membre publique statique de std::allocator_traits<Alloc> )