Introducción a los Punteros Compartidos

Al igual que un puntero único, un puntero compartido se utiliza para asignar y mantener la dirección de un objeto asignado dinámicamente. El principal factor diferenciador entre los dos tipos de punteros es que un puntero compartido es compartible por diseño. Puede tener de manera segura más de un propietario. De hecho, solo debe usarse cuando necesitas que un objeto tenga múltiples propietarios.

¿Cómo funcionan los punteros compartidos?

A diferencia de los punteros únicos, los punteros compartidos mantienen un conteo de referencias. El conteo de referencias de un puntero compartido rastrea el número de punteros compartidos que actualmente están haciendo referencia (poseyendo) al mismo objeto.

Cuando un puntero compartido sale del ámbito, o se restablece explícitamente, el contador de referencias se decrementa automáticamente. Tan pronto como el contador de referencias llega a 0, significa que ningún puntero compartido está haciendo referencia al objeto, y la memoria del objeto se desaloca automáticamente.

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 es una forma infalible de asegurar la propiedad compartida segura de datos dinámicos. Ya que, incluso al compartir datos, el programa es menos susceptible a fugas/corrupción de memoria, y no necesitas llamar manualmente a delete.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 3. Capítulo 1