Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Pools d’objets, arènes et réutilisation de pointeurs périmés

Les pools et les arènes gèrent le stockage, mais une adresse ne définit pas l’identité d’un objet. La réutilisation d’un emplacement peut laisser un pointeur sans cible vivante ou le faire désigner un autre objet. Distinguez la durée de stockage, la durée de vie de l’objet et la validité des handles côté application.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

alignas(T) unsigned char storage[sizeof(T)]; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();

Pool ou arène

Un pool d’objets réutilise généralement des emplacements individuels ; une arène regroupe les allocations et récupère le stockage en une seule fois. std::pmr::unsynchronized_pool_resource gère des blocs mémoire, pas des objets applicatifs. std::pmr::monotonic_buffer_resource représente une stratégie d’arène : une désallocation individuelle ne récupère pas d’espace. Une ressource mémoire n’appelle pas elle-même les destructeurs des objets qui y sont stockés.

Stockage et objet

L’Item illustré nécessite une taille suffisante, un alignement correct et une initialisation achevée. placement new construit un objet à l’emplacement fourni ; appeler le destructeur termine sa durée de vie sans libérer l’emplacement. Lire stale->value entre la destruction et la reconstruction entraîne un comportement indéfini.

Même adresse, identité différente

Dans l’exemple, un nouvel Item complet remplace exactement l’objet complet précédent, non const et de même type. Le remplacement transparent s’applique : stale désigne automatiquement le nouvel objet et sa lecture donne 20. Cela est valide selon le langage, mais peut contredire l’attente de l’application selon laquelle un handle désigne toujours l’élément d’origine. Ne généralisez pas cela à des types ou sous-objets quelconques. std::launder a des préconditions ; il ne fait pas revivre un objet détruit et ne valide pas l’identité logique.

Règles d’implémentation

Utilisez le pointeur renvoyé par la construction. Si les anciens handles doivent être rejetés, vérifiez l’occupation de l’emplacement et une génération, avec une stratégie empêchant les collisions après le bouclage du compteur. Gérez les exceptions des constructeurs, détruisez les objets nécessitant un nettoyage avant de réinitialiser une arène et synchronisez les accès concurrents. L’exemple montre un emplacement, pas un pool complet. La cible de compilation est C++23 ; un environnement d’exécution de production n’est pas attesté. Les sources fournies sont un projet de travail évolutif, et non une édition C++23 figée.

Identifiants de référence couverts par cette entrée : Object pools, arenas and stale pointer reuse.

Exemples

#include <iostream>
#include <new>

struct Item {
    int value;
    ~Item() noexcept {}
};

int main() {
    alignas(Item) unsigned char slot[sizeof(Item)];
    Item* first = ::new (static_cast<void*>(slot)) Item{10};
    Item* stale = first;
    std::cout << first->value << '\n';

    first->~Item();
    // Do not access stale->value here: no live Item exists.

    Item* current = ::new (static_cast<void*>(slot)) Item{20};
    std::cout << current->value << '\n';
    // Transparent replacement: stale now denotes the new Item.
    std::cout << stale->value << '\n';

    current->~Item();
}

Résultat

10
20
20

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources