std:: allocator

La classe template std::allocator est l'allocateur par défaut Allocator utilisé par tous les conteneurs de la bibliothèque standard si aucun allocateur spécifié par l'utilisateur n'est fourni. L'allocateur par défaut est sans état, c'est-à-dire que toutes les instances d'un allocateur donné sont interchangeables, se comparent égales et peuvent désallouer la mémoire allouée par toute autre instance du même type d'allocateur.

Types membres

Fonctions membres

Fonctions non membres

Notes

La classe template membre rebind fournit un moyen d'obtenir un allocateur pour un type différent. Par exemple, std:: list < T, A > alloue des nœuds d'un certain type interne Node<T> , en utilisant l'allocateur A::rebind<Node<T>>::other (jusqu'à C++11) std:: allocator_traits < A > :: rebind_alloc < Node < T >> , qui est implémenté en termes de A::rebind<Node<T>>::other si A est un std::allocator (depuis C++11) .

Le type membre is_always_equal est déprécié via LWG issue 3170 , car il fait que les allocateurs personnalisés dérivés de std::allocator sont traités comme toujours égaux par défaut. std:: allocator_traits < std :: allocator < T >> :: is_always_equal n'est pas déprécié et sa constante membre value vaut true pour tout T .

Exemple

#include <iostream>
#include <memory>
#include <string>
int main()
{
    // allocateur par défaut pour les entiers
    std::allocator<int> alloc1;
    // démonstration des quelques membres directement utilisables
    static_assert(std::is_same_v<int, decltype(alloc1)::value_type>);
    int* p1 = alloc1.allocate(1); // espace pour un entier
    alloc1.deallocate(p1, 1);     // et il est libéré
    // Même ceux-ci peuvent être utilisés via les traits, donc pas besoin
    using traits_t1 = std::allocator_traits<decltype(alloc1)>; // Le trait correspondant
    p1 = traits_t1::allocate(alloc1, 1);
    traits_t1::construct(alloc1, p1, 7);  // construit l'entier
    std::cout << *p1 << '\n';
    traits_t1::deallocate(alloc1, p1, 1); // désalloue l'espace pour un entier
    // allocateur par défaut pour les chaînes
    std::allocator<std::string> alloc2;
    // traits correspondants
    using traits_t2 = std::allocator_traits<decltype(alloc2)>;
    // Le rebind de l'allocateur utilisant le trait pour les chaînes donne le même type
    traits_t2::rebind_alloc<std::string> alloc_ = alloc2;
    std::string* p2 = traits_t2::allocate(alloc2, 2); // espace pour 2 chaînes
    traits_t2::construct(alloc2, p2, "foo");
    traits_t2::construct(alloc2, p2 + 1, "bar");
    std::cout << p2[0] << ' ' << p2[1] << '\n';
    traits_t2::destroy(alloc2, p2 + 1);
    traits_t2::destroy(alloc2, p2);
    traits_t2::deallocate(alloc2, p2, 2);
}

7
foo bar

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi