Jak mogę przekazać std :: unique_ptr do funkcji

Jak mogę przekazać a std::unique_ptrdo funkcji? Powiedzmy, że mam następującą klasę:

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

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

Następujące elementy nie są kompilowane:

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

Dlaczego nie mogę przekazać a std::unique_ptrdo funkcji? Z pewnością to jest główny cel konstrukcji? Czy też komisja C ++ miała zamiar wrócić do surowych wskaźników w stylu C i przekazać to w ten sposób:

MyFunc(&(*ptr)); 

A co najdziwniejsze, dlaczego jest to dobry sposób na to, by go ominąć? Wydaje się okropnie niekonsekwentne:

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

Zasadniczo są tutaj dwie opcje:

Przekaż inteligentny wskaźnik przez odniesienie

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

Przenieś inteligentny wskaźnik do argumentu funkcji

Zauważ, że w tym przypadku asercja zostanie zachowana!

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

Przekazujesz to według wartości, co oznacza wykonanie kopii. To nie byłoby wyjątkowe, prawda?

Możesz przenieść wartość, ale oznacza to przekazanie własności obiektu i kontrolę jego życia do funkcji.

Jeśli czas życia obiektu jest gwarantowany przez cały czas trwania wywołania MyFunc, po prostu przekaż nieprzetworzony wskaźnik via ptr.get().

Dlaczego nie mogę przekazać a unique_ptrdo funkcji?

Nie możesz tego zrobić, ponieważ unique_ptrma konstruktor przenoszenia, ale nie ma konstruktora kopiującego. Zgodnie ze standardem, jeśli zdefiniowano konstruktor przenoszenia, ale nie zdefiniowano konstruktora kopiującego, konstruktor kopiujący jest usuwany.

12.8 Kopiowanie i przenoszenie obiektów klas

...

7 Jeśli definicja klasy nie deklaruje jawnie konstruktora kopiującego, jest on deklarowany niejawnie. Jeśli definicja klasy deklaruje konstruktor przenoszenia lub operator przypisania przenoszenia, niejawnie zadeklarowany konstruktor kopiujący jest zdefiniowany jako usunięty;

Możesz przekazać unique_ptrdo funkcji przy pomocy:

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

i używaj go tak, jak masz:

lub

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

i używaj go jak:

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

Ważna uwaga

Zauważ, że jeśli używasz drugiej metody, ptrnie ma prawa własności do wskaźnika po wywołaniu std::move(ptr)return.

void MyFunc(std::unique_ptr<A>&& arg) miałby taki sam efekt jak void MyFunc(std::unique_ptr<A>& arg) ponieważ oba są odniesieniami.

W pierwszym przypadku ptrnadal ma własność wskaźnika po wywołaniu MyFunc.

Ponieważ MyFuncnie przejmuje na własność, lepiej byłoby mieć:

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

albo lepiej

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

Jeśli naprawdę chcesz przejąć na własność, musisz przenieść swój zasób:

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

lub przekaż bezpośrednio odniesienie do wartości r:

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

std::unique_ptr nie ma celowo kopii gwarantującej posiadanie tylko jednego właściciela.

Dlaczego nie mogę przekazać a unique_ptrdo funkcji?

Możesz, ale nie przez kopiowanie - ponieważ std::unique_ptr<>nie można go kopiować.

Z pewnością to jest główny cel konstrukcji?

Między innymi std::unique_ptr<>ma na celu jednoznaczne oznaczenie unikalnej własności (w przeciwieństwie do std::shared_ptr<>).

A co najdziwniejsze, dlaczego jest to dobry sposób na to, by go ominąć?

Ponieważ w tym przypadku nie ma konstrukcji kopiowania.

Ponieważ unique_ptrsłuży do unikalnej własności, jeśli chcesz przekazać to jako argument, spróbuj

MyFunc(move(ptr));

Ale po tym, że stan ptrIN mainbędzie nullptr.

Przekazywanie funkcji std::unique_ptr<T>jako wartość nie działa, ponieważ, jak wspomnieliście, unique_ptrnie można jej skopiować.

A co z tym?

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

ten kod działa