L'allocateur personnalisé peut être utilisé pour contr?ler le comportement d'allocation de mémoire des conteneurs C. 1. Le journal de journalisation dans l'exemple implémente la journalisation de l'opération de mémoire en surchargeant l'allocation, la transmission, la construction et la détruire des méthodes; 2. L'allocateur doit définir des modèles Value_Type et Rebind pour répondre aux exigences de conversion du type de conteneur STL; 3. L'allocateur déclenche la sortie du journal pendant la construction et la copie, ce qui est pratique pour suivre le cycle de vie; 4. Les applications pratiques comprennent des pools de mémoire, de la mémoire partagée, des outils de débogage et des systèmes intégrés; 5. Depuis C 17, la construction et la destruction peuvent être traitées par STD :: ALLOCATOR_TRAITS par défaut, mais les journaux personnalisés doivent toujours être explicitement surchargés; 6. L'allocateur doit être apatride autant que possible pour éviter les problèmes de compatibilité des STL; 7. L'allocation de conteneurs imbriqués peut être pris en charge en conjonction avec STD :: Scoped_Allocator_Adaptor. Ce mécanisme met en ?uvre entièrement le contr?le raffiné des opérations de mémoire vectorielle STD :: et détruit et libère correctement toutes les ressources à la fin du programme.

En C, un allocateur personnalisé vous permet de contr?ler la fa?on dont l'allocation de mémoire des conteneurs (comme std::vector , std::list , etc.). Ceci est utile lorsque des performances élevées, un regroupement de mémoire, une mémoire partagée ou une utilisation de la mémoire de débogage sont nécessaires.

Voici un exemple d'allocateur personnalisé simple pour std::vector , qui imprime les informations à chaque fois que l'on alloue et la publication, vous aidant à comprendre le fonctionnement de l'allocateur.

? Exemple d'allocation personnalisée de base: allocation avec le journal

 #include <iostream>
#include <Vector>
#include <mory>

modèle <typename t>
classe loggingallocator {
publique:
    Utilisation de valeur_type = t;

    // Rebind doit être fourni afin que le conteneur STL puisse utiliser cet allocateur pour d&#39;autres types Modèle <typEname U>
    struct rebind {
        Utilisation autre = loggingallocator <u>;
    };

    Loggingallocator () noexcept {
        std :: cout << "allocateur construit (type:" << typeId (t) .name () << ") \ n";
    }

    modèle <typename u>
    Loggingallocator (const loggingallocator <u> &) noexcept {
        std :: cout << "Copie d&#39;allocator construite à partir de type" << typeId (u) .name () << "\ n";
    }

    // allocation de la mémoire (sans construire des objets)
    T * allocation (std :: size_t n) {
        std :: cout << "allouant" << n << "éléments de taille" << sizeof (t) << "\ n";
        T * ptr = static_cast <t *> (:: opérateur new (n * sizeof (t)));
        retour ptr;
    }

    // mémoire libre (pas de destruction d&#39;objets)
    void deallocate (t * ptr, std :: size_t n) noexcept {
        std :: cout << "Deallocating" << n << "éléments à" << ptr << "\ n";
        :: Operator Delete (PTR);
    }

    // Construire le modèle d&#39;objet <typEname u, typename ... args>
    void construction (u * ptr, args && ... args) {
        std :: cout << "Construire l&#39;objet à" << ptr << "\ n";
        Nouveau (ptr) u (std :: Forward <args> (args) ..) ..);
    }

    // Destruct Object Template <typEname u>
    void destroy (u * ptr) noexcept {
        std :: cout << "Détruire l&#39;objet à" << ptr << "\ n";
        ptr-> ~ u ();
    }

    // Comparez si deux allocateurs sont équivalents (toutes les instances sont généralement considérées comme égales)
    Bool Operator == (const logggingallocator &) const noExcept {
        Retour Vrai;
    }

    Bool Operator! = (const logggingallocator & autre) const noexcept {
        return! (* this == autre);
    }
};

// Pour prendre en charge différents types de construction, un échange de non-membre de modèle, etc. est généralement nécessaire, mais omis ici

Utilisez un allocateur personnalisé

 int main () {
    // Créer un vecteur à l'aide d'allocateur personnalisé
    std :: vector <int, loggingallocator <nt>> vec;

    std :: cout << "Ajout d&#39;éléments ... \ n";
    Vec.push_back (10);
    Vec.push_back (20);
    Vec.push_back (30);
    Vec.push_back (40); // La réaffectation peut être déclenchée std :: cout << "Taille du vecteur:" << ve.size () << "\ n";

    retour 0;
}

? Exemple de sortie (possible):

 Allocateur construit (type: i)
Ajout d'éléments ...
Allouant 1 éléments de taille 4
Construire un objet à 0x1234000
Allouant 2 éléments de taille 4
Détruire l'objet à 0x1234000
Désactivation de 1 éléments à 0x1234000
Construire un objet à 0x1234010
Construire un objet à 0x1234014
Allouant 4 éléments de taille 4
Détruire l'objet à 0x1234010
Détruire l'objet à 0x1234014
Désactivation de 2 éléments à 0x1234010
Construire un objet à 0x1234020
Construire un objet à 0x1234024
Construire un objet à 0x1234028
Construire un objet à 0x123402c
Taille du vecteur: 4
Détruire l'objet à 0x123402c
Détruire l'objet à 0x1234028
Détruire l'objet à 0x1234024
Détruire l'objet à 0x1234020
Désactivation de 4 éléments à 0x1234020

Remarque: vector réalcoute la mémoire à mesure qu'il grandit, les anciens éléments sont copiés (ou déplacés), et l'ancienne mémoire est ensuite libérée.

? Scénarios d'utilisation pratiques

• Pool de mémoire : pré-allouer un grand morceau de mémoire et allocate les rendements de la piscine.
• Mémoire partagée : partagez des conteneurs STL entre plusieurs processus.
• Outils de débogage : détecter les fuites de mémoire, les limites, les doubles versions, etc.
• Systèmes intégrés : évitez d'utiliser les stratégies d'allocation déterministes new/delete par défaut.

?? Remarques

• L'allocateur personnalisé doit répondre aux exigences de dénomination de l'allocateur (la norme C 11/17/20 est légèrement différente).
• Depuis C 17, std::allocator<T>::construct a été obsolète, et il est recommandé d'utiliser std::allocator_traits .
• L'allocateur doit être sans état que possible, sinon il peut y avoir des problèmes dans certaines implémentations STL (telles que l'allocateur de n?ud list ).
• Si vous utilisez std::scoped_allocator_adaptor , les conteneurs imbriqués peuvent être pris en charge (tels que vector<string, Alloc> ).

? écriture plus moderne (C 17 recommandée)

 // Constructeur et détruire peuvent être omis et sont implémentés par défaut par allocator_traits // mais si vous souhaitez ajouter des journaux, vous devez toujours le recharger

Fondamentalement, c'est tout. Cet exemple montre comment rédiger un allocateur de journal le plus simple que vous pouvez étendre dans un pool de mémoire ou un pool d'objets sur cette base.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!