Wie kann ich std :: unique_ptr an eine Funktion übergeben?

Wie kann ich ein std::unique_ptrin eine Funktion übergeben? Nehmen wir an, ich habe folgende Klasse:

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

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

Folgendes wird nicht kompiliert:

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

Warum kann ich a nicht an std::unique_ptreine Funktion übergeben? Dies ist sicherlich der Hauptzweck des Konstrukts? Oder wollte das C ++ - Komitee, dass ich auf rohe C-Zeiger zurückgreife und es so weitergebe:

MyFunc(&(*ptr)); 

Und am seltsamsten ist, warum ist dies eine gute Möglichkeit, es weiterzugeben? Es scheint schrecklich inkonsistent:

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

Grundsätzlich gibt es hier zwei Möglichkeiten:

Übergeben Sie den Smart Pointer als Referenz

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

Bewegen Sie den Smart Pointer in das Funktionsargument

Beachten Sie, dass in diesem Fall die Behauptung gilt!

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

Sie übergeben es als Wert, was bedeutet, dass Sie eine Kopie erstellen. Das wäre doch nicht sehr einzigartig, oder?

Sie können den Wert verschieben, dies bedeutet jedoch, dass das Eigentum an dem Objekt und die Kontrolle über seine Lebensdauer an die Funktion übergeben werden.

Wenn die Lebensdauer des Objekts während der gesamten Lebensdauer des Aufrufs von MyFunc garantiert ist, übergeben Sie einfach einen Rohzeiger über ptr.get().

Warum kann ich a nicht an unique_ptreine Funktion übergeben?

Sie können dies nicht tun, da unique_ptres einen Verschiebungskonstruktor, aber keinen Kopierkonstruktor gibt. Gemäß dem Standard wird der Kopierkonstruktor gelöscht, wenn ein Verschiebungskonstruktor definiert ist, ein Kopierkonstruktor jedoch nicht definiert ist.

12.8 Kopieren und Verschieben von Klassenobjekten

...

7 Wenn die Klassendefinition einen Kopierkonstruktor nicht explizit deklariert, wird einer implizit deklariert. Wenn die Klassendefinition einen Verschiebungskonstruktor oder einen Verschiebungszuweisungsoperator deklariert, wird der implizit deklarierte Kopierkonstruktor als gelöscht definiert.

Sie können das unique_ptran die Funktion übergeben, indem Sie Folgendes verwenden:

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

und benutze es wie du:

oder

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

und benutze es wie:

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

Wichtige Notiz

Beachten Sie, dass bei Verwendung der zweiten Methode ptrder Zeiger nach dem Aufruf von std::move(ptr)return nicht im Besitz des Zeigers ist .

void MyFunc(std::unique_ptr<A>&& arg)hätte den gleichen Effekt wie void MyFunc(std::unique_ptr<A>& arg)da beide Referenzen sind.

Im ersten Fall ptrhat der Zeiger nach dem Aufruf von noch Besitz MyFunc.

Da MyFunces kein Eigentum übernimmt, wäre es besser, Folgendes zu haben:

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

oder besser

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

Wenn Sie wirklich Eigentümer werden möchten, müssen Sie Ihre Ressource verschieben:

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

oder übergeben Sie direkt eine r-Wert-Referenz:

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

std::unique_ptr hat nicht absichtlich eine Kopie, um zu garantieren, nur einen Besitzer zu haben.

Warum kann ich a nicht an unique_ptreine Funktion übergeben?

Sie können, aber nicht durch Kopieren - weil std::unique_ptr<>nicht kopierkonstruierbar ist.

Dies ist sicherlich der Hauptzweck des Konstrukts?

Unter anderem std::unique_ptr<>wird entwickelt , um eindeutig markieren einzigartiges Eigentum (im Gegensatz zu std::shared_ptr<>).

Und am seltsamsten ist, warum ist dies eine gute Möglichkeit, es weiterzugeben?

Denn in diesem Fall gibt es keine Kopierkonstruktion.

Da unique_ptres sich um ein eindeutiges Eigentum handelt, versuchen Sie es, wenn Sie es als Argument übergeben möchten

MyFunc(move(ptr));

Aber danach wird der Zustand von ptrin mainsein nullptr.

Die Übergabe std::unique_ptr<T>als Wert an eine Funktion funktioniert nicht, da sie, wie Sie bereits erwähnt haben, unique_ptrnicht kopierbar ist.

Was ist damit?

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

Dieser Code funktioniert