Pasar Punteros Únicos

Una de las principales razones por las que elegimos punteros y asignación de memoria dinámica sobre variables estáticas es la flexibilidad que ofrecen al pasar datos a través de diferentes secciones del código. Sin embargo, cuando se trata de punteros únicos, el paso se vuelve un poco complicado.

Al retornar desde funciones constructoras

Un caso de uso válido para pasar un puntero único es cuando se está retornando desde una función constructora (una función que existe solo para asignar/construir recursos).

unique_pointer_builder


              123456789101112131415
            
#include <iostream>
#include <memory>

std::unique_ptr<int> unique_ptr_builder() { return std::make_unique<int>(42); }

int main()
{
    // This will be the sole owner of the dynamically allocated integer 42
    std::unique_ptr<int> p_unique = unique_ptr_builder();

    if (p_unique)
        std::cout << "Value from unique pointer: " << *p_unique << std::endl;
    else
        std::cout << "Unique pointer is null." << std::endl;
}

Usando una función constructora para crear un puntero único a un valor int. Una vez que la función devuelve, el unique_ptr en la función main comienza a apuntar al valor entero dinámico.

Al Transferir la Propiedad

También se considera válido y seguro move un puntero único. Por ejemplo, puede transferir la propiedad de un puntero único de class A a class B.

transferring_ownership


              12345
            
// Create a unique pointer inside classA
classA->source_ptr = std::make_unique<int>(42);

// Later, move the ownership to classB, this is perfectly fine
classB->target_ptr = std::move(sourcePtr);

Cuándo no pasar Punteros Únicos

Compartir un std::unique_ptr con la intención de que múltiples partes lo posean no es adecuado. Esto rompe el concepto central de un puntero único, ya que debería tener solo un propietario.

Puedes crear una instancia de puntero único dentro de una clase y luego pasar su puntero crudo a una función de biblioteca externa. Tal compartición es insegura y puede llevar a problemas de memoria difíciles de depurar.

passing_raw_pointer


              12345
            
// Create a unique pointer.
std::unique_ptr<std::string> p_unique = std::make_unique<int>(33);

// Extract the raw pointer and pass it to an external class.
ExternalClass obj(p_unique.get()); // Never do this, not safe.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 2. Capítulo 4