Como posso passar std :: unique_ptr para uma função

Como posso passar um std::unique_ptrem uma função? Digamos que eu tenha a seguinte aula:

class A
{
public:
    A(int val)
    {
        _val = val;
    }

    int GetVal() { return _val; }
private:
    int _val;
};

O seguinte não compila:

void MyFunc(unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(ptr);

    return 0;
}

Por que não posso passar um std::unique_ptrpara uma função? Certamente este é o objetivo principal do construto? Ou o comitê de C ++ pretendia que eu voltasse às dicas de estilo C brutas e as passasse assim:

MyFunc(&(*ptr)); 

E o mais estranho de tudo, por que essa é uma maneira OK de passar isso? Parece terrivelmente inconsistente:

MyFunc(unique_ptr<A>(new A(1234)));

Existem basicamente duas opções aqui:

Passe o ponteiro inteligente por referência

void MyFunc(unique_ptr<A> & arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(ptr);
}

Mova o ponteiro inteligente para o argumento da função

Observe que, neste caso, a declaração será válida!

void MyFunc(unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(move(ptr));
    assert(ptr == nullptr)
}

Você está passando por valor, o que implica fazer uma cópia. Isso não seria muito original, seria?

Você pode mover o valor, mas isso implica passar a propriedade do objeto e o controle de sua vida útil para a função.

Se for garantido que o tempo de vida do objeto existirá durante o tempo de vida da chamada para MyFunc, basta passar um ponteiro bruto via ptr.get().

Por que não posso passar um unique_ptrpara uma função?

Você não pode fazer isso porque unique_ptrtem um construtor de movimento, mas não um construtor de cópia. De acordo com o padrão, quando um construtor de movimento é definido, mas um construtor de cópia não é definido, o construtor de cópia é excluído.

12.8 Copiar e mover objetos de classe

...

7 Se a definição da classe não declara explicitamente um construtor de cópia, um é declarado implicitamente. Se a definição da classe declara um construtor de movimentação ou operador de atribuição de movimentação, o construtor de cópia declarado implicitamente é definido como excluído;

Você pode passar o unique_ptrpara a função usando:

void MyFunc(std::unique_ptr<A>& arg)
{
    cout << arg->GetVal() << endl;
}

e use-o como você fez:

ou

void MyFunc(std::unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

e usá-lo como:

std::unique_ptr<A> ptr = std::unique_ptr<A>(new A(1234));
MyFunc(std::move(ptr));

Nota importante

Observe que se você usar o segundo método, ptrnão tem propriedade do ponteiro após a chamada para std::move(ptr)retorna.

void MyFunc(std::unique_ptr<A>&& arg)teria o mesmo efeito, void MyFunc(std::unique_ptr<A>& arg)já que ambos são referências.

No primeiro caso, ptrainda tem propriedade do ponteiro após a chamada para MyFunc.

Como MyFuncnão se apropria, seria melhor ter:

void MyFunc(const A* arg)
{
    assert(arg != nullptr); // or throw ?
    cout << arg->GetVal() << endl;
}

ou melhor

void MyFunc(const A& arg)
{
    cout << arg.GetVal() << endl;
}

Se você realmente deseja assumir a propriedade, deverá mover seu recurso:

std::unique_ptr<A> ptr = std::make_unique<A>(1234);
MyFunc(std::move(ptr));

ou passe diretamente uma referência de valor r:

MyFunc(std::make_unique<A>(1234));

std::unique_ptr não possui cópia proposital para garantia de ter apenas um proprietário.

Por que não posso passar um unique_ptrpara uma função?

Você pode, mas não por cópia - porque std::unique_ptr<>não é construtível por cópia.

Certamente este é o objetivo principal do construto?

Entre outras coisas, std::unique_ptr<>é projetado para marcar inequivocamente a propriedade única (em oposição a std::shared_ptr<>).

E o mais estranho de tudo, por que essa é uma maneira OK de passar isso?

Porque, nesse caso, não há construção de cópia.

Uma vez que unique_ptré de propriedade única, se você quiser passar como argumento tente

MyFunc(move(ptr));

Mas depois disso, o estado de ptrem mainserá nullptr.

Passar std::unique_ptr<T>como valor para uma função não está funcionando porque, como vocês mencionaram, unique_ptrnão é copiável.

Que tal isso?

std::unique_ptr<T> getSomething()
{
   auto ptr = std::make_unique<T>();
   return ptr;
}

este código está funcionando