Namespaces
Variants

std:: weak_ptr

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::weak_ptr
Défini dans l'en-tête <memory>
template < class T > class weak_ptr ;
(depuis C++11)

std::weak_ptr est un pointeur intelligent qui détient une référence non propriétaire ("faible") vers un objet géré par std::shared_ptr . Il doit être converti en std::shared_ptr pour accéder à l'objet référencé.

std::weak_ptr modélise la possession temporaire : lorsqu'un objet doit être accessible uniquement s'il existe, et qu'il peut être supprimé à tout moment par quelqu'un d'autre, std::weak_ptr est utilisé pour suivre l'objet, et il est converti en std::shared_ptr pour acquérir une possession temporaire. Si le std::shared_ptr original est détruit à ce moment, la durée de vie de l'objet est prolongée jusqu'à ce que le std::shared_ptr temporaire soit également détruit.

Une autre utilisation de std::weak_ptr est de rompre les cycles de références formés par des objets gérés par std::shared_ptr . Si un tel cycle est orphelin (c'est-à-dire qu'il n'y a pas de pointeurs partagés externes dans le cycle), les compteurs de références du shared_ptr ne peuvent pas atteindre zéro et la mémoire est fuite. Pour éviter cela, l'un des pointeurs dans le cycle peut être rendu faible .

Table des matières

Types membres

Type de membre Définition
element_type

T

(jusqu'en C++17)

std:: remove_extent_t < T >

(depuis C++17)

Fonctions membres

crée un nouveau weak_ptr
(fonction membre publique)
détruit un weak_ptr
(fonction membre publique)
assigne le weak_ptr
(fonction membre publique)
Modificateurs
libère la propriété de l'objet géré
(fonction membre publique)
échange les objets gérés
(fonction membre publique)
Observateurs
retourne le nombre d'objets shared_ptr qui gèrent l'objet
(fonction membre publique)
vérifie si l'objet référencé a déjà été supprimé
(fonction membre publique)
crée un shared_ptr qui gère l'objet référencé
(fonction membre publique)
fournit un ordonnancement basé sur le propriétaire des pointeurs faibles
(fonction membre publique)
(C++26)
fournit un hachage basé sur le propriétaire des pointeurs faibles
(fonction membre publique)
(C++26)
fournit une comparaison d'égalité basée sur le propriétaire des pointeurs faibles
(fonction membre publique)

Fonctions non membres

(C++11)
spécialise l'algorithme std::swap
(modèle de fonction)

Classes d'assistance

(C++20)
pointeur faible atomique
(spécialisation de modèle de classe)

Guides de déduction (depuis C++17)

Notes

Comme std::shared_ptr , une implémentation typique de weak_ptr stocke deux pointeurs :

  • un pointeur vers le bloc de contrôle ; et
  • le pointeur stocké du shared_ptr à partir duquel il a été construit.

Un pointeur stocké séparé est nécessaire pour garantir que la conversion d'un shared_ptr en weak_ptr puis de retour fonctionne correctement, même pour les shared_ptr aliasés. Il n'est pas possible d'accéder au pointeur stocké dans un weak_ptr sans le verrouiller dans un shared_ptr .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_smart_ptr_owner_equality 202306L (C++26) Permettre l'utilisation de std::weak_ptr comme clés dans les conteneurs associatifs non ordonnés

Exemple

Montre comment lock est utilisé pour garantir la validité du pointeur.

Exécuter ce code 
#include <iostream>
#include <memory>
std::weak_ptr<int> gw;
void observe()
{
    std::cout << "gw.use_count() == " << gw.use_count() << "; ";
    // we have to make a copy of shared pointer before usage:
    if (std::shared_ptr<int> spt = gw.lock())
        std::cout << "*spt == " << *spt << '\n';
    else
        std::cout << "gw is expired\n";
}
int main()
{
    {
        auto sp = std::make_shared<int>(42);
        gw = sp;
        observe();
    }
    observe();
}

Sortie : 

gw.use_count() == 1; *spt == 42
gw.use_count() == 0; gw is expired

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.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3001 C++17 element_type n'a pas été mis à jour pour la prise en charge des tableaux mis à jour

Voir aussi

(C++11)
pointeur intelligent avec sémantique de propriété exclusive d'objet
(modèle de classe)
(C++11)
pointeur intelligent avec sémantique de propriété partagée d'objet
(modèle de classe)