Introdução aos Ponteiros Compartilhados

Assim como um ponteiro único, um ponteiro compartilhado é usado para alocar e manter o endereço de um objeto alocado dinamicamente. O principal fator de diferenciação entre os dois tipos de ponteiros é que um ponteiro compartilhado é projetado para ser compartilhável. Ele pode ter mais de um proprietário com segurança. Na verdade, ele só deve ser usado quando você precisa que um objeto tenha múltiplos proprietários.

Como Funcionam os Ponteiros Compartilhados?

Ao contrário dos ponteiros únicos, os ponteiros compartilhados mantêm uma contagem de referência. A contagem de referência de um ponteiro compartilhado rastreia o número de ponteiros compartilhados que estão atualmente referenciando (possuindo) o mesmo objeto.

Quando um ponteiro compartilhado sai do escopo, ou é explicitamente redefinido, a contagem de referências é automaticamente decrementada. Assim que a contagem de referências atinge 0, isso significa que nenhum ponteiro compartilhado está mais referenciando o objeto, e a memória do objeto é automaticamente desalocada.

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

Esta é uma maneira infalível de garantir a propriedade compartilhada segura de dados dinâmicos. Pois, mesmo ao compartilhar dados, o programa é menos suscetível a vazamentos/corrupção de memória, e você não precisa chamar manualmente delete.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 1