shared_ptr und weak_ptr: geteilte Besitzverhältnisse
Teilen Sie Besitz per Referenzzählung und durchbrechen Sie Zyklen mit weak_ptr.
shared_ptr und weak_ptr: geteilte Besitzverhältnisse ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Ein Objekt gemeinsam nutzen
Manchmal müssen mehrere Programmteile ein Objekt am Leben halten. std::shared_ptr<T> verwaltet gemeinsamen Besitz mithilfe der Referenzzählung.
shared_ptr erstellen
Verwenden Sie std::make_shared – es reserviert den Steuerblock und das Objekt in einer einzigen Speicherbelegung.
#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count(); // 1Kopieren teilt den Besitz
Beim Kopieren eines shared_ptr wird der Referenzzähler erhöht. Beim Zerstören oder Neuzuweisen wird er verringert. Wenn der Zähler 0 erreicht, wird das Objekt gelöscht.
auto a = std::make_shared<Widget>();
auto b = a; // ref count is now 2
std::cout << a.use_count(); // 2Funktionsweise im Hintergrund
Ein shared_ptr enthält zwei Pointer: einen auf das Objekt und einen auf einen Steuerblock mit dem oder den Referenzzählern. Der Steuerblock wird auf dem Heap angelegt.
Atomarer Referenzzähler
Der Referenzzähler verwendet atomare Operationen, damit shared_ptrs sicher zwischen Threads kopiert werden können. Das referenzierte Objekt selbst ist dadurch jedoch nicht automatisch threadsicher.
Zurücksetzen und neu zuweisen
Beim Zuweisen eines neuen Werts wird der alte Referenzzähler verringert und der neue erhöht. reset() setzt den shared_ptr auf leer.
shared_ptr aus Raw Pointer (vermeiden)
Erzeugen Sie nicht zwei shared_ptrs aus demselben Raw Pointer – beide hätten ihren eigenen Kontrollblock. Verwenden Sie immer make_shared.
// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw); // disaster: two control blocksDas Zyklusproblem
Zwei shared_ptrs, die aufeinander verweisen, bilden einen Zyklus – der Referenzzähler keines von beiden erreicht null, und keines wird freigegeben. Speicherleck.
struct Node {
std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a; // cycle — never freedZyklen mit weak_ptr aufbrechen
std::weak_ptr<T> beobachtet einen shared_ptr, ohne am Referenzzähler teilzunehmen. Verwenden Sie eine Seite der Beziehung als weak, um den Zyklus aufzubrechen.
struct Node {
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // weak — does not own
};weak_ptr verwenden
Sie können einen weak_ptr nicht direkt dereferenzieren. Rufen Sie lock() auf, um einen shared_ptr zu erhalten – oder einen leeren shared_ptr, falls das Objekt nicht mehr existiert.
std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
p->use(); // safe — we have a shared_ptr now
} else {
std::cout << "object expired";
}Kosten im Vergleich zu unique_ptr
shared_ptr ist größer (zwei Zeiger plus Kontrollblock) und langsamer (atomarer Referenzzähler). Verwenden Sie ihn nur, wenn der Besitz tatsächlich geteilt werden muss.
Schnelltest
Was ist der typische Anwendungsfall für std::weak_ptr?
Zusammenfassung
shared_ptr verfolgt den Besitz mit einem atomaren Referenzzähler. Verwenden Sie make_shared, achten Sie auf Zyklen und brechen Sie diese mit weak_ptr auf. Bevorzugen Sie unique_ptr, wenn kein geteilter Besitz erforderlich ist.
Häufig gestellte Fragen
Ist die Lektion „shared_ptr und weak_ptr: geteilte Besitzverhältnisse“ kostenlos?
Ja — der vollständige Text von „shared_ptr und weak_ptr: geteilte Besitzverhältnisse“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „shared_ptr und weak_ptr: geteilte Besitzverhältnisse“?
Teilen Sie Besitz per Referenzzählung und durchbrechen Sie Zyklen mit weak_ptr. Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C++ Academy zu starten?
Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „shared_ptr und weak_ptr: geteilte Besitzverhältnisse“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?
Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Warum Smart Pointer rohe new- und delete-Operatoren ersetzen
- unique_ptr und exklusiver Besitz
- shared_ptr und weak_ptr: geteilte Besitzverhältnisse
- Benutzerdefinierte Deleter und Make-Funktionen