Einführung in Shared Pointers

Genau wie ein einzigartiger Zeiger wird ein Shared Pointer verwendet, um die Adresse eines dynamisch zugewiesenen Objekts zuzuweisen und zu halten. Der Hauptunterschied zwischen den beiden Zeigertypen besteht darin, dass ein Shared Pointer von Natur aus teilbar ist. Er kann sicher mehr als einen Besitzer haben. Tatsächlich sollte er nur verwendet werden, wenn ein Objekt mehrere Besitzer haben muss.

Wie funktionieren Shared Pointers?

Im Gegensatz zu einzigartigen Zeigern halten Shared Pointers eine Referenzanzahl. Die Referenzanzahl eines Shared Pointers verfolgt die Anzahl der Shared Pointers, die derzeit auf dasselbe Objekt verweisen (es besitzen).

Wenn ein Shared Pointer außer Reichweite gerät oder explizit zurückgesetzt wird, wird der Referenzzähler automatisch dekrementiert. Sobald der Referenzzähler 0 erreicht, bedeutet dies, dass kein Shared Pointer mehr auf das Objekt verweist und der Speicher des Objekts automatisch freigegeben wird.

shared_pointer


              1234567891011121314151617181920212223242526272829303132333435363738394041
            
#include <iostream>

template <typename T>
class SharedPointer {
public:
    explicit SharedPointer(T* ptr = nullptr) 
        : pointer(ptr), reference_count(new int(1)) {}

    SharedPointer(const SharedPointer& other)
        : pointer(other.pointer), reference_count(other.reference_count) 
    {
        (*reference_count)++;
    }

    SharedPointer& operator=(const SharedPointer& other) {
        if (this != &other) {
            if (--(*reference_count) == 0) {
                delete pointer;
                delete reference_count;
            }
            pointer = other.pointer;
            reference_count = other.reference_count;
            (*reference_count)++;
        }
        return *this;
    }

    ~SharedPointer() 
    {
        if (--(*reference_count) == 0) {
            delete pointer;
            delete reference_count;
        }
    }

    T* operator->() const { return pointer; }
    T& operator*() const { return *pointer; }
private:
    T* pointer;
    int* reference_count;
};

Dies ist eine narrensichere Methode, um eine sichere gemeinsame Nutzung dynamischer Daten zu gewährleisten. Denn selbst bei der gemeinsamen Nutzung von Daten ist das Programm weniger anfällig für Speicherlecks/-beschädigungen, und Sie müssen nicht manuell delete aufrufen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 1