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

CKTIS / C++

Mémoire : propriété, copies et durée de vie des objets

Distingue l’espace mémoire, l’objet qui l’occupe et la responsabilité de libérer la ressource. Découvre les durées de stockage automatique et dynamique, la copie, le placement new, la destruction explicite et les règles d’aliasing strict.

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

Syntaxe

T copy = original; T* alias = &original; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();

Le stockage accueille des données ; la durée de vie concerne l’objet qui l’occupe. Elle débute en général quand un espace assez grand et bien aligné est disponible et que l’initialisation est terminée. Pour un objet de classe, elle prend fin au début de l’appel du destructeur, ou si l’espace est libéré ou réutilisé. Une adresse valide ne suffit pas pour accéder à l’objet.

Durée de stockage. Elle détermine la disponibilité de l’espace. Une variable locale ordinaire a un stockage automatique, jusqu’à la sortie du bloc. Un objet créé par new avec allocation a un stockage dynamique et peut survivre au bloc. Un std::unique_ptr local peut avoir un stockage automatique et son objet un stockage dynamique. Pile et tas sont des modèles d’implémentation usuels, pas des définitions.

Propriété. Le propriétaire libère la ressource. Utilise RAII : son destructeur fait le nettoyage. std::unique_ptr se déplace mais ne se copie pas. Copier un pointeur brut ne copie que l’adresse, ni l’objet ni la responsabilité de le supprimer. Par défaut, une classe se copie membre par membre : un pointeur garde sa cible. La copie n’est pas forcément profonde ; deux propriétaires indépendants d’une adresse risquent une double suppression.

Placement new. Dans ::new (storage) T{args}, le :: initial limite la recherche de la fonction d’allocation à la portée globale, mais n’impose pas le choix de la surcharge standard qui prend un void*. Une surcharge globale qui correspond mieux au type de storage peut allouer de la mémoire. L’exemple utilise la forme ::new (static_cast<void*>(storage)) T{args} avec le type Item : la surcharge standard sans allocation est sélectionnée et l’objet est construit dans l’espace fourni. La conversion en void* ne suffit pas à garantir ce choix pour tout T. Si l’alignement de T dépasse l’alignement par défaut de new (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__), la résolution de surcharge tient d’abord compte d’un argument de type std::align_val_t placé avant l’argument de placement. Une surcharge globale viable operator new(std::size_t, std::align_val_t, void*) peut alors être sélectionnée à la place de la surcharge standard sans allocation. Cet espace doit être assez grand et correctement aligné. p->~T() détruit explicitement l’objet sans libérer l’espace. Pas de delete pour un objet placé dans un tampon local. Ne détruis pas un objet deux fois : après destruction explicite d’une variable locale ordinaire à destructeur non trivial, reconstruis correctement un objet du type initial avant la destruction automatique.

Aliasing strict. Il limite les types utilisables pour lire ou modifier la valeur d’un objet. reinterpret_cast n’autorise pas l’accès via un type incompatible. char, unsigned char et std::byte donnent accès à la représentation sans écarter les règles de durée de vie. L’exemple utilise un sous-ensemble compatible C++23 ; l’URL de la norme mène au brouillon évolutif, pas à l’édition C++23 figée.

Identifiants de référence couverts par cette entrée : Object lifetime, placement new, explicit destruction and strict aliasing, Automatic and dynamic storage duration.

Exemples

#include <cstddef>
#include <iostream>
#include <memory>
#include <new>

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

int main() {
    Item original{7};
    Item copy = original;
    Item* alias = &original;
    alias->value = 9;

    auto owner = std::make_unique<Item>();
    owner->value = 11;

    alignas(Item) std::byte storage[sizeof(Item)];
    Item* placed = ::new (static_cast<void*>(storage)) Item{13};

    std::cout << original.value << ' ' << copy.value << ' '
              << owner->value << ' ' << placed->value << '\n';

    placed->~Item();
}

Résultat

9 7 11 13

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