std::shared_ptr<T>:: use_count

Retourne le nombre d'instances différentes de shared_ptr (incluant * this ) gérant l'objet actuel. S'il n'y a pas d'objet géré, ​ 0 ​ est retourné.

Dans un environnement multithreadé, use_count récupère atomiquement le nombre d'instances (les implémentations typiques utilisent un chargement memory_order_relaxed ).

Paramètres

(aucun)

Valeur de retour

Le nombre d'instances std::shared_ptr gérant l'objet actuel ou ​ 0 ​ s'il n'y a pas d'objet géré.

Notes

Les cas d'utilisation courants incluent

• comparaison avec ​ 0 ​ . Si use_count renvoie zéro, le pointeur partagé est vide et ne gère aucun objet (que son pointeur stocké soit nullptr ou non).
• comparaison avec 1 . Si use_count renvoie 1, il n'y a pas d'autres propriétaires. La fonction membre obsolète (depuis C++17) unique() est fournie pour ce cas d'utilisation. (jusqu'à C++20)

Dans un environnement multithread

La valeur retournée par use_count doit être considérée comme approximative, car le nombre de propriétaires partagés peut changer dans d'autres threads entre la récupération atomique et l'utilisation significative de la valeur. Lorsque use_count retourne 1, cela n'implique pas que l'objet peut être modifié en toute sécurité car les accès à l'objet géré par d'anciens propriétaires partagés peuvent ne pas être terminés, et parce que de nouveaux propriétaires partagés peuvent être introduits simultanément, comme par std::weak_ptr::lock . Seulement lorsque use_count retourne 0, le compte est précis.

Exemple

#include <iostream>
#include <memory>
void fun(std::shared_ptr<int> sp)
{
    std::cout << "in fun(): sp.use_count() == " << sp.use_count()
              << " (object @ " << sp << ")\n";
}
int main()
{
    auto sp1 = std::make_shared<int>(5);
    std::cout << "in main(): sp1.use_count() == " << sp1.use_count()
              << " (object @ " << sp1 << ")\n";
    fun(sp1);
}

in main(): sp1.use_count() == 1 (object @ 0x20eec30)
in fun(): sp.use_count() == 2 (object @ 0x20eec30)

Voir aussi