Gemeinsame Zeiger und eindeutige Zeiger sind beide grundlegend für das moderne C++-Speichermanagement. Um zu entscheiden, wann man welchen verwenden sollte, ist es wichtig, ihre Unterschiede zu verstehen.

|           | <center>Gemeinsame Zeiger                               | <center>Eindeutige Zeiger                                      |
|------------------|-----------------------------------------------|-------------------------------------------------------|
| **Besitzmodell**  | Ermöglicht gemeinsamen Besitz über mehrere Bereiche | Erzwingt eindeutigen Besitz zu einem bestimmten Zeitpunkt             |
| **Referenzzähler**  | Verwendet Referenzzähler zur Verwaltung des Besitzes      | Verwendet keinen Referenzzähler                          |
| **Overhead**         | Moderater Overhead aufgrund der Referenzzählung   | Minimaler Overhead, da keine Referenzzählung erforderlich ist    |
| **Komplexität**       | Kann schwieriger zu verwalten sein aufgrund des gemeinsamen Besitzes und potenzieller zirkulärer Referenzen | Im Allgemeinen einfachere Besitzsemantik |
| **Anwendungsfälle**        | Verwenden, wenn mehrere Teile Zugriff auf dasselbe Objekt mit komplexer Lebensdauer benötigen | Verwenden für die meisten dynamischen Speicherszenarien, bei denen kein Teilen erforderlich ist |

Welchen Typ von intelligentem Zeiger sollten Sie verwenden, wenn Sie maximale Leistung wünschen und keine dynamischen Objekte teilen möchten?

C++ Smart Pointers sind Ihr Weg, die Macht des Speichermanagements freizuschalten. Entwickelt für erfahrene Programmierer bietet dieser Kurs einen tiefen Einblick in einen der wichtigsten Aspekte der modernen Entwicklung und überarbeitet Zeiger und Referenzen. Mit Smart Pointers lernen Sie, wie Sie die Speicherzuweisung und -freigabe effektiv verwalten und häufige Fallstricke wie Speicherlecks und hängende Zeiger vermeiden. Unsere erfahrenen Dozenten führen Sie durch die Feinheiten von unique_ptr, shared_ptr und weak_ptr und befähigen Sie, sichereren und robusteren Code zu schreiben.

Dieses Segment behandelt einen Überblick über Heap- und Stack-Speicher, die Notwendigkeit von Smart Pointern und deren praktische Anwendungen.

In diesem Abschnitt werden wir die Konzepte von Smart-Pointern und Referenzen in C++ einführen, darauf eingehen, warum sie so wichtig sind, und ihre Anwendungsfälle und Vorteile erkunden.

Dieser Abschnitt untersucht shared pointers, erforscht ihre Funktionalität, Vorteile, reale Anwendungen in der Programmierung und was sie von einzigartigen Zeigern unterscheidet

In diesem Abschnitt werden wir schwache Zeiger erkunden, ihre Natur verstehen, sie effektiv erstellen und nutzen, zirkuläre Referenzen durch schwache Zeiger auflösen und wichtige Funktionen im Zusammenhang mit schwachen Zeigern untersuchen.

Dieser Abschnitt behandelt die Unterschiede zwischen Referenzen und Zeigern und betont ihre Unterschiede und Gemeinsamkeiten. Er umfasst das Konzept von konstanten Referenzen und Unveränderlichkeit, bietet Anleitungen, wann Referenzen im Vergleich zu Smart-Pointern oder rohen Pointern verwendet werden sollten, und skizziert bewährte Praktiken für die Arbeit mit Referenzen in Programmierkontexten.

Dieser Abschnitt behandelt benutzerdefinierte Deleter für Smart-Pointer, reale Anwendungen von Smart-Pointern, Leistungsüberlegungen und einen detaillierten Vergleich von Shared-, Unique- und Weak-Pointern.

	Gemeinsame Zeiger	Eindeutige Zeiger
Besitzmodell	Ermöglicht gemeinsamen Besitz über mehrere Bereiche	Erzwingt eindeutigen Besitz zu einem bestimmten Zeitpunkt
Referenzzähler	Verwendet Referenzzähler zur Verwaltung des Besitzes	Verwendet keinen Referenzzähler
Overhead	Moderater Overhead aufgrund der Referenzzählung	Minimaler Overhead, da keine Referenzzählung erforderlich ist
Komplexität	Kann schwieriger zu verwalten sein aufgrund des gemeinsamen Besitzes und potenzieller zirkulärer Referenzen	Im Allgemeinen einfachere Besitzsemantik
Anwendungsfälle	Verwenden, wenn mehrere Teile Zugriff auf dasselbe Objekt mit komplexer Lebensdauer benötigen	Verwenden für die meisten dynamischen Speicherszenarien, bei denen kein Teilen erforderlich ist

C++ Smart Pointers

Gemeinsame Pointers vs Eindeutige Pointers