CKTIS / C++
std::shared_ptr — propriété partagée
std::shared_ptr<T> de <memory> permet de partager la propriété d’un objet. Les copies le maintiennent en vie et la libération du dernier propriétaire déclenche son nettoyage. std::weak_ptr observe l’objet sans prolonger sa durée de vie.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <memory>
std::shared_ptr<T> p = std::make_shared<T>(args...);
std::shared_ptr<T> q = p;
p.reset();std::shared_ptr<T> de <memory> représente une propriété partagée. La copie partage la propriété de l’objet au lieu de le copier. reset() libère la part d’un propriétaire ; le dernier propriétaire déclenche la suppression de l’objet géré ou l’appel du deleter approprié. get() expose uniquement le pointeur stocké — il ne transfère pas la propriété.
Créez un objet avec std::make_shared<T>(args...), qui transmet les arguments à son constructeur. Ne construisez pas un std::shared_ptr indépendant à partir de p.get() : cela crée un groupe de propriétaires distinct et peut provoquer une double suppression. Avant tout déréférencement, assurez-vous que le pointeur stocké désigne un objet vivant.
Des cycles de références fortes peuvent maintenir des objets en vie indéfiniment. Rompez un cycle avec std::weak_ptr, qui ne prolonge pas la durée de vie de l’objet. lock() renvoie un std::shared_ptr qui partage la propriété s’il reste au moins un propriétaire dans le groupe observé. Si le groupe a expiré, lock() renvoie un std::shared_ptr vide, même si l’objet est encore en vie, par exemple parce que le deleter ne fait rien.
Une gestion sûre de la propriété ne synchronise pas les données de l’objet. Des instances différentes qui partagent la propriété peuvent être utilisées simultanément ; modifier la même instance nécessite une synchronisation, par exemple avec std::atomic<std::shared_ptr<T>>. L’accès à l’objet lui-même nécessite une protection distincte lorsqu’une course de données est possible. use_count() n’est pas un mécanisme de synchronisation.
L’exemple montre que q maintient l’objet en vie après p.reset(), et que l’observateur expire à la fin du bloc. Cette entrée vise C++23 ; le projet de norme fourni est mis à jour et peut contenir des fonctionnalités ultérieures. Un indicateur du compilateur dans le dépôt ne garantit pas l’environnement d’exécution de production.
Exemples
#include <iostream>
#include <memory>
int main() {
auto p = std::make_shared<int>(42);
std::weak_ptr<int> observer = p;
{
std::shared_ptr<int> q = p;
p.reset();
std::cout << *q << '\n';
std::cout << std::boolalpha << observer.expired() << '\n';
}
std::cout << observer.expired() << '\n';
}
Résultat
42 false true
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.