¿Cómo puedo pasar std :: unique_ptr a una función?

¿Cómo puedo pasar una std::unique_ptra una función? Digamos que tengo la siguiente clase:

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

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

Lo siguiente no se 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 qué no puedo pasar una std::unique_ptra una función? ¿Seguramente este es el propósito principal del constructo? ¿O el comité de C ++ tenía la intención de que recurriera a punteros de estilo C sin formato y lo pasara así:

MyFunc(&(*ptr)); 

Y lo más extraño de todo, ¿por qué es una buena forma de pasarlo? Parece horriblemente inconsistente:

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

Básicamente, hay dos opciones aquí:

Pase el puntero inteligente por referencia

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

Mueva el puntero inteligente al argumento de la función

Tenga en cuenta que en este caso, la aserción se mantendrá.

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

Lo estás pasando por valor, lo que implica hacer una copia. Eso no sería muy especial, ¿verdad?

Puede mover el valor, pero eso implica pasar la propiedad del objeto y el control de su vida útil a la función.

Si se garantiza que la vida útil del objeto existe durante la vida útil de la llamada a MyFunc, simplemente pase un puntero sin procesar a través de ptr.get().

¿Por qué no puedo pasar una unique_ptra una función?

No puede hacer eso porque unique_ptrtiene un constructor de movimiento pero no un constructor de copia. De acuerdo con el estándar, cuando se define un constructor de movimiento pero no se define un constructor de copia, se elimina el constructor de copia.

12.8 Copiar y mover objetos de clase

...

7 Si la definición de clase no declara explícitamente un constructor de copia, uno se declara implícitamente. Si la definición de clase declara un constructor de movimiento o un operador de asignación de movimiento, el constructor de copia declarado implícitamente se define como eliminado;

Puede pasar el unique_ptra la función usando:

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

y úsalo como lo has hecho:

o

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

y utilícelo como:

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

Nota IMPORTANTE

Tenga en cuenta que si utiliza el segundo método, ptrno tiene la propiedad del puntero después de la llamada a std::move(ptr)devoluciones.

void MyFunc(std::unique_ptr<A>&& arg)tendría el mismo efecto que void MyFunc(std::unique_ptr<A>& arg)ya que ambos son referencias.

En el primer caso, ptrtodavía tiene la propiedad del puntero después de la llamada a MyFunc.

Como MyFuncno se apropia, sería mejor tener:

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

o mejor

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

Si realmente desea tomar posesión, debe mover su recurso:

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

o pasar directamente una referencia de valor r:

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

std::unique_ptr no tiene copia a propósito para garantizar tener un solo dueño.

¿Por qué no puedo pasar una unique_ptra una función?

Puede hacerlo, pero no por copia, porque std::unique_ptr<>no se puede copiar.

¿Seguramente este es el propósito principal del constructo?

Entre otras cosas, std::unique_ptr<>está diseñado para marcar inequívocamente la propiedad única (a diferencia de std::shared_ptr<>).

Y lo más extraño de todo, ¿por qué es una buena forma de pasarlo?

Porque en ese caso, no hay construcción de copias.

Dado que unique_ptres para propiedad única, si desea pasarlo como argumento, intente

MyFunc(move(ptr));

Pero después de eso, el estado de ptrin mainserá nullptr.

Pasar std::unique_ptr<T>como valor a una función no funciona porque, como ustedes mencionan, unique_ptrno se puede copiar.

¿Qué pasa con esto?

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

este código está funcionando