Beste Praktiken für die Verwendung von Shared Pointers

Verwenden Sie nur Shared Pointers, wenn Sie keine Unique verwenden können

Unique Pointers sollten immer Ihre erste Überlegung sein, wenn Sie ein dynamisches Objekt zuweisen. Greifen Sie nur auf Shared Pointers zurück, wenn Sie die Notwendigkeit der gemeinsamen Nutzung rechtfertigen können.

Initialisieren Sie Shared Pointers zum Zeitpunkt der Deklaration

Um die Lesbarkeit und Wartbarkeit des Codes zu verbessern, wird empfohlen, einen Shared Pointer zu initialisieren, wenn Sie ihn deklarieren. Diese Praxis stellt sicher, dass der Shared Pointer von Anfang an auf ein gültiges Objekt zeigt und verringert die Wahrscheinlichkeit, auf einen null oder nicht initialisierten Pointer zuzugreifen.

good

bad


              12345678910
            
#include <memory>

int main()
{
    // Initializing the shared pointer when declaring it
    std::shared_ptr<int> ptr = std::make_shared<int>(10);

    // Now, the shared pointer points to a valid object and can be safely dereferenced
    *ptr += 5;
}

Minimieren Sie den gemeinsamen Gültigkeitsbereich

Obwohl es im Allgemeinen sicher ist, gemeinsam genutzte Zeiger zu verwenden, ist Vorsicht geboten, wenn Sie sie teilen. Versuchen Sie, den Gültigkeitsbereich von gemeinsam genutzten Zeigern so eng wie möglich zu halten. Dies stellt sicher, dass sie freigegeben werden, sobald sie nicht mehr benötigt werden.

Vorsicht vor zirkulären Referenzen

Zirkuläre Referenzen treten auf, wenn eine Gruppe von gemeinsam genutzten Zeigern eine Schleife bildet. Jeder gemeinsam genutzte Zeiger verweist auf den nächsten, und der letzte gemeinsam genutzte Zeiger in der Schleife geht zurück zum ersten. Dies führt zu einem geschlossenen Kreis von Referenzen, bei dem der Referenzzähler niemals auf 0 geht. Betrachten Sie das folgende Beispiel:

main


              1234567891011121314151617181920212223242526272829
            
#include <iostream>
#include <memory>

class Node {
public:
	//shared pointer to the next element
    std::shared_ptr<Node> next; 
	//the constructor
    Node() {
        std::cout << "Node constructed." << std::endl;
    }
	//the destructor
    ~Node() {
        std::cout << "Node destructed." << std::endl;
    }
};

int main() {
	//creating three Node objects
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();
    std::shared_ptr<Node> node3 = std::make_shared<Node>();

    // Creating a circular reference
    node1->next = node2;
    node2->next = node3;
    node3->next = node1;
    // Destructors will not get called because of circular references
}

Im obigen Code haben wir drei Node-Objekte, die verbundene Elemente in einer verketteten Liste darstellen. Jedes Node hat ein next-Mitglied, das ein Shared Pointer ist, der auf das nächste Element in der verketteten Liste zeigt.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 5