C++ named requirements: Allocator

Encapsule les stratégies pour l'accès/adressage, l'allocation/désallocation et la construction/destruction d'objets.

Chaque composant de la bibliothèque standard susceptible d'allouer ou de libérer de la mémoire, depuis std::string , std::vector , et tous les conteneurs , à l'exception de std::array (depuis C++11) et de std::inplace_vector (depuis C++26) , jusqu'à std::shared_ptr et std::function (jusqu'à C++17) , le fait via un Allocator : un objet de type classe qui satisfait aux exigences suivantes.

L'implémentation de nombreuses exigences d'allocateur est optionnelle car tous les AllocatorAwareContainer accèdent aux allocateurs indirectement via std::allocator_traits , et std::allocator_traits fournit l'implémentation par défaut de ces exigences.

Exigences

Étant donné

• T , un type non const et non référence (jusqu'en C++11) type d'objet non const (depuis C++11) (jusqu'en C++17) type d'objet non qualifié cv (depuis C++17) ,
• A , un type Allocator pour le type T ,
• a , un objet de type A ,
• B , le type Allocator correspondant pour un type d'objet non qualifié cv U (obtenu par rebind de A ),
• b , un objet de type B ,
• p , une valeur de type std:: allocator_traits < A > :: pointer , obtenue en appelant std:: allocator_traits < A > :: allocate ( ) ,
• cp , une valeur de type std:: allocator_traits < A > :: const_pointer , obtenue par conversion de p ,
• vp , une valeur de type std:: allocator_traits < A > :: void_pointer , obtenue par conversion de p ,
• cvp , une valeur de type std:: allocator_traits < A > :: const_void_pointer , obtenue par conversion de cp ou de vp ,
• xp , un pointeur déréférençable vers un type d'objet non qualifié cv X ,
• r , une lvalue de type T obtenue par l'expression * p ,
• n , une valeur de type std:: allocator_traits < A > :: size_type .

Notes :

1. ↑ Voir également fancy pointers ci-dessous.
2. ↑ rebind est uniquement optionnel (fourni par std::allocator_traits ) si cet allocateur est un modèle de la forme SomeAllocator<T, Args> , où Args représente zéro ou plusieurs paramètres de type template supplémentaires.

Étant donné

• x1 et x2 , objets de types (éventuellement différents) X::void_pointer , X::const_void_pointer , X::pointer , ou X::const_pointer

Alors, x1 et x2 sont des valeurs de pointeur équivalentes si et seulement si x1 et x2 peuvent être explicitement converties en deux objets correspondants px1 et px2 de type X::const_pointer , en utilisant une séquence de static_cast s utilisant uniquement ces quatre types, et l'expression px1 == px2 s'évalue à true .

Étant donné

• w1 et w2 , objets de type X::void_pointer

Ensuite, pour l'expression w1 == w2 et w1 ! = w2 l'un ou les deux objets peuvent être remplacés par un objet de valeur équivalente de type X::const_void_pointer sans modification de la sémantique.

Étant donné

• p1 et p2 , objets de type X::pointer

Ensuite, pour les expressions p1 == p2 , p1 ! = p2 , p1 < p2 , p1 <= p2 , p1 >= p2 , p1 > p2 , p1 - p2 , un ou les deux objets peuvent être remplacés par un objet de valeur équivalente de type X::const_pointer sans modification de la sémantique.

Les exigences ci-dessus permettent de comparer les Container iterator s et const_iterator s.

Allocateurs avec état et sans état

Chaque Allocator est soit stateful soit stateless . Généralement, un allocateur stateful peut avoir des valeurs inégales qui désignent des ressources mémoire distinctes, tandis qu'un allocateur stateless désigne une seule ressource mémoire.

Les instances d'un type d'allocateur sans état se comparent toujours égales. Les types d'allocateurs sans état sont généralement implémentés comme des classes vides et conviennent pour l'optimisation de classe de base vide .

Pointeurs sophistiqués

Lorsque le type membre pointer n'est pas un type pointeur brut, il est communément appelé « pointeur sophistiqué » . Ces pointeurs ont été introduits pour supporter les architectures à mémoire segmentée et sont utilisés aujourd'hui pour accéder à des objets alloués dans des espaces d'adressage différents de l'espace d'adressage virtuel homogène accessible par les pointeurs bruts. Un exemple de pointeur sophistiqué est le pointeur indépendant du mapping d'adresses boost::interprocess::offset_ptr , qui permet d'allouer des structures de données nodales telles que std::set dans la mémoire partagée et les fichiers mappés en mémoire situés à des adresses différentes dans chaque processus. Les pointeurs sophistiqués peuvent être utilisés indépendamment de l'allocateur qui les a fournis , via le modèle de classe std::pointer_traits (depuis C++11) . La fonction std::to_address peut être utilisée pour obtenir un pointeur brut à partir d'un pointeur sophistiqué. (depuis C++20)

Bibliothèque standard

Les composants suivants de la bibliothèque standard satisfont aux Allocator exigences :

Exemples

#include <cstdlib>
#include <iostream>
#include <limits>
#include <new>
#include <vector>
template<class T>
struct Mallocator
{
    typedef T value_type;
    Mallocator() = default;
    template<class U>
    constexpr Mallocator(const Mallocator <U>&) noexcept {}
    [[nodiscard]] T* allocate(std::size_t n)
    {
        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T))
            throw std::bad_array_new_length();
        if (auto p = static_cast<T*>(std::malloc(n * sizeof(T))))
        {
            report(p, n);
            return p;
        }
        throw std::bad_alloc();
    }
    void deallocate(T* p, std::size_t n) noexcept
    {
        report(p, n, 0);
        std::free(p);
    }
private:
    void report(T* p, std::size_t n, bool alloc = true) const
    {
        std::cout << (alloc ? "Alloc: " : "Dealloc: ") << sizeof(T) * n
                  << " bytes at " << std::hex << std::showbase
                  << reinterpret_cast<void*>(p) << std::dec << '\n';
    }
};
template<class T, class U>
bool operator==(const Mallocator <T>&, const Mallocator <U>&) { return true; }
template<class T, class U>
bool operator!=(const Mallocator <T>&, const Mallocator <U>&) { return false; }
int main()
{
    std::vector<int, Mallocator<int>> v(8);
    v.push_back(42);
}

Alloc: 32 bytes at 0x2020c20
Alloc: 64 bytes at 0x2023c60
Dealloc: 32 bytes at 0x2020c20
Dealloc: 64 bytes at 0x2023c60

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.

1. ↑ Les types membres reference et const_reference de std::allocator sont définis respectivement comme T& et const T& .
   • Si T est un type référence, reference et const_reference sont mal formés car une référence à une référence ne peut être formée (la compression de références a été introduite en C++11).
   • Si T est qualifié const, reference et const_reference sont identiques, et l'ensemble de surcharges de address() est mal formé.