Std :: unique_ptr'yi bir işleve nasıl geçirebilirim

A'yı std::unique_ptrbir işleve nasıl geçirebilirim ? Diyelim ki şu sınıfa sahibim:

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

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

Aşağıdakiler derlenmez:

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

Neden a'yı std::unique_ptrbir işleve geçiremiyorum? Elbette yapının birincil amacı bu mu? Veya C ++ komitesi ham C tarzı işaretlere geri dönmemi ve bunu şu şekilde aktarmamı mı istedi:

MyFunc(&(*ptr)); 

Ve en tuhafı, bu neden onu geçmenin iyi bir yolu? Korkunç derecede tutarsız görünüyor:

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

Burada temel olarak iki seçenek var:

Akıllı işaretçiyi referansla iletin

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

Akıllı işaretçiyi işlev bağımsız değişkenine taşı

Bu durumda iddianın geçerli olacağını unutmayın!

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

Onu değere göre geçiriyorsunuz, bu da bir kopya yapmak anlamına geliyor. Bu çok benzersiz olmaz, değil mi?

Değeri taşıyabilirsiniz, ancak bu, nesnenin sahipliğinin ve yaşam süresinin kontrolünün işleve aktarılması anlamına gelir.

MyFunc'a yapılan çağrının ömrü boyunca nesnenin yaşam süresinin var olacağı garanti edilirse, sadece ham bir gösterici üzerinden geçirin ptr.get().

Neden a'yı unique_ptrbir işleve geçiremiyorum?

Bunu yapamazsınız çünkü unique_ptrbir taşıma yapıcısı vardır, ancak kopya yapıcısı yoktur. Standarda göre, bir taşıma yapıcısı tanımlandığında ancak bir kopya oluşturucu tanımlanmadığında, kopya oluşturucu silinir.

12.8 Sınıf nesnelerini kopyalama ve taşıma

...

7 Sınıf tanımı bir kopya yapıcısını açık bir şekilde bildirmezse, biri örtük olarak bildirilir. Sınıf tanımı bir taşıma yapıcısı veya taşıma atama operatörü bildirirse, örtük olarak bildirilen kopya yapıcısı silinmiş olarak tanımlanır;

Şunu unique_ptrkullanarak işleve geçebilirsiniz :

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

ve sahip olduğunuz gibi kullanın:

veya

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

ve şu şekilde kullanın:

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

Önemli Not

İkinci yöntemi kullanırsanız, return ptrçağrısından sonra işaretçinin sahipliğinin olmadığını lütfen unutmayın std::move(ptr).

void MyFunc(std::unique_ptr<A>&& arg)void MyFunc(std::unique_ptr<A>& arg)her ikisi de referans olduğu için aynı etkiye sahip olacaktır .

İlk durumda, ptrçağrıldıktan sonra hala işaretçinin sahibi olur MyFunc.

As MyFuncsahipliğini almaz, bu olması daha iyi olacaktır:

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

ya da daha iyisi

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

Eğer gerçekten sahip olmak istiyorsanız, kaynağınızı taşımanız gerekir:

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

veya doğrudan bir r değeri referansı iletin:

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

std::unique_ptr tek bir sahibin olmasını garantilemek için bilerek kopyası yoktur.

Neden a'yı unique_ptrbir işleve geçiremiyorum?

Yapabilirsiniz, ancak kopyalayarak yapamazsınız - çünkü std::unique_ptr<>kopyalanabilir değildir.

Elbette yapının birincil amacı bu mu?

Diğer şeylerin yanı sıra, benzersiz sahipliği std::unique_ptr<>kesin olarak işaretlemek için tasarlanmıştır (aksine ).std::shared_ptr<>

Ve en tuhafı, bu neden onu geçmenin iyi bir yolu?

Çünkü bu durumda kopya-inşa yoktur.

Çünkü unique_ptrbenzersiz sahiplik için, bunu argüman olarak iletmek istiyorsanız deneyin

MyFunc(move(ptr));

Ama devlet bundan sonra ptrin mainolacaktır nullptr.

Geçme std::unique_ptr<T>bir işleve değer çünkü çalışmıyor gibi adamlar söz olarak, unique_ptrcopyable değildir.

Peki buna ne dersin?

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

bu kod çalışıyor