Wichtige Schwache Pointerfunktionen

Die Funktion expired()

Bevor Sie lock() aufrufen, können Sie überprüfen, ob ein Weak Pointer noch gültig ist, indem Sie die Methode expired() verwenden. Diese Funktion gibt true zurück, wenn das Objekt zerstört wurde, und false andernfalls.

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;
}

Das Aufrufen von expired() vor dem Sperren des Weak Pointers hilft festzustellen, ob das referenzierte Objekt noch existiert.

Die Funktion use_count()

Obwohl ein schwacher Zeiger die Referenzanzahl eines Objekts nicht beeinflusst, kann es nützlich sein zu wissen, wie viele std::shared_ptr Instanzen dasselbe Objekt verwalten. Die Funktion use_count() gibt diese Anzahl zurück.

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;

Die Funktion reset()

Um einen schwachen Zeiger von der Beobachtung eines Objekts zu lösen, verwenden Sie die Funktion reset(). Dadurch wird der schwache Zeiger geleert, was bedeutet, dass er auf kein Objekt mehr zeigt.

reset_function


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

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

Die Funktion swap()

Die Funktion swap() kann verwendet werden, um den Inhalt von zwei schwachen Zeigern auszutauschen. Dies ist besonders nützlich, wenn Sie die Objekte ändern möchten, die die beiden schwachen Zeiger beobachten, ohne die Eigentümerschaft oder Lebensdauer der dynamischen Objekte zu verändern.

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);

anfangs beobachtet p_weak_A das von p_shared_A verwaltete Objekt, während p_weak_B das von p_shared_B verwaltete Objekt beobachtet.

Nach dem Aufruf von swap() beginnt p_weak_A, das von p_shared_B verwaltete Objekt zu beobachten, und p_weak_B beobachtet das von p_shared_A verwaltete Objekt.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 4. Kapitel 4