Fonctions Importantes des Weak Pointers

La fonction expired()

Avant d'appeler lock(), vous pouvez vérifier si un weak pointer est toujours valide en utilisant la méthode expired(). Cette fonction retourne true si l'objet a été détruit et false sinon.

expired_function


              1234567891011
            
// Call `expired()` before `lock()`
if (!p_weak.expired()) 
{
    // Lock only if the object is still alive
    auto p_shared = p_weak.lock();
    p_shared->update();
}
else
{
    std::cout << "Object no longer exists" << std::endl;
}

Appeler expired() avant de verrouiller le weak pointer aide à déterminer si l'objet référencé existe toujours.

La fonction use_count()

Bien qu'un pointeur faible n'affecte pas le compteur de références d'un objet, il peut être utile de savoir combien d'instances de std::shared_ptr gèrent le même objet. La fonction use_count() renvoie ce nombre.

use_count_function


              12345
            
std::shared_ptr<int> p_shared = std::make_shared<int>(42);
std::weak_ptr<int> p_weak(sharedPtr);

// Should output one
std::cout << p_weak.use_count() << std::endl;

La fonction reset()

Pour libérer un pointeur faible de l'observation d'un objet, utilisez la fonction reset(). Cela rend le pointeur faible vide, ce qui signifie qu'il ne pointe plus vers aucun objet.

reset_function


              1234
            
std::weak_ptr<int> p_weak(sharedPtr);

// After this, `p_weak` no longer observes the `p_shared` object
p_weak.reset();

La fonction swap()

La fonction swap() peut être utilisée pour échanger le contenu de deux pointeurs faibles. Cela est particulièrement utile lorsque vous souhaitez changer les objets que les deux pointeurs faibles observent, sans altérer la propriété ou la durée de vie des objets dynamiques.

swap_function


              12345678
            
std::shared_ptr<int> p_shared_A = std::make_shared<int>(10);
std::shared_ptr<int> p_shared_B = std::make_shared<int>(20);

std::weak_ptr<int> p_weak_A(p_shared_A);
std::weak_ptr<int> p_weak_B(p_shared_B);

// Swaps the objects `p_weak_A` and `p_weak_B`
p_weak_A.swap(weakPtrB);

initialement p_weak_A observe l'objet géré par p_shared_A, tandis que p_weak_B observe l'objet géré par p_shared_B.

Après avoir appelé swap(), p_weak_A commence à observer l'objet géré par p_shared_B, et p_weak_B observe l'objet géré par p_shared_A.

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 4