Passando Ponteiros Únicos

Uma das principais razões pelas quais escolhemos ponteiros e alocação dinâmica de memória em vez de variáveis estáticas é a flexibilidade que eles oferecem ao passar dados por diferentes seções do código. No entanto, quando se trata de ponteiros únicos, a passagem se torna um pouco complicada.

Quando Retornando de Funções Builder

Um caso de uso válido para passar um ponteiro único é quando você está retornando de uma função builder (uma função que existe apenas para alocar/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 uma função construtora para criar um ponteiro único para um valor int. Assim que a função retorna, o unique_ptr na função main começa a apontar para o valor inteiro dinâmico.

Ao Transferir Propriedade

Também é considerado válido e seguro move um ponteiro único. Por exemplo, você pode transferir a propriedade de um ponteiro único da class A para 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);

Quando não Passar Ponteiros Únicos

Compartilhar um std::unique_ptr com a intenção de múltiplas partes possuírem não é adequado. Isso quebra o conceito central de um ponteiro único, pois ele deve ter apenas um proprietário.

Você pode criar uma instância de ponteiro único dentro de uma classe e então passar seu ponteiro bruto para uma função de biblioteca externa. Tal compartilhamento é inseguro e pode levar a problemas de memória difíceis 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.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 2. Capítulo 4