Unique_ptr işlevlerinden döndürülüyor

unique_ptr<T>kopya oluşturmaya izin vermez, bunun yerine taşıma semantiğini destekler. Yine de, unique_ptr<T>bir işlevden bir geri dönebilir ve döndürülen değeri bir değişkene atayabilirim.

#include <iostream>
#include <memory>

using namespace std;

unique_ptr<int> foo()
{
  unique_ptr<int> p( new int(10) );

  return p;                   // 1
  //return move( p );         // 2
}

int main()
{
  unique_ptr<int> p = foo();

  cout << *p << endl;
  return 0;
}

Yukarıdaki kod istendiği gibi derlenir ve çalışır. Peki bu satır 1kopya oluşturucuyu çağırmıyor ve derleyici hatalarına neden olmuyor? Eğer hat 2kullanmak zorunda olsaydım, bu mantıklı olurdu (hat 2çalışmalarını da kullanmak , ama bunu yapmak zorunda değiliz).

C ++ 0x, bu değer istisna unique_ptr, işlev çıkar çıkmaz yok edilecek geçici bir nesne olduğundan izin verir , böylece döndürülen işaretçinin benzersizliğini garanti eder. Bunun nasıl uygulandığını merak ediyorum, derleyicide özel olarak kaplanmış mı yoksa dil spesifikasyonunda bu istismarın başka bir maddesi var mı?

dil belirtiminde bunun istismar ettiği başka bir madde var mı?

Evet, bkz. 12.8 §34 ve §35:

Belirli ölçütler karşılandığında, bir uygulamanın bir nesne nesnesinin kopyala / taşı yapısını atlamasına izin verilir [...] Kopya elizyonu olarak adlandırılan bu kopyala / taşı işlemi seçimine [...] bir dönüş ifadesinde izin verilir. İfade, işlev dönüş türüyle aynı cv-niteliksiz türe sahip geçici olmayan otomatik bir nesnenin adı olduğunda, sınıf dönüş türüne sahip bir işlev [...]

Bir kopyalama işleminin seçilmesi için kriterler karşılandığında ve kopyalanacak nesne bir değer ile belirlenirse, kopya için yapıcıyı seçmek için aşırı yük çözünürlüğü ilk olarak nesne bir değer tarafından belirlenmiş gibi gerçekleştirilir .

En kötü durumda dönüş deyiminde adlandırılmış bir değer, yani C ++ 11, C ++ 14 ve C ++ 17'de elemeler olmadan, değere göre döndürmenin burada varsayılan seçim olması gerektiğine bir nokta daha eklemek istedim bir rvalue olarak. Örneğin, aşağıdaki işlev -fno-elide-constructorsbayrakla derlenir

std::unique_ptr<int> get_unique() {
  auto ptr = std::unique_ptr<int>{new int{2}}; // <- 1
  return ptr; // <- 2, moved into the to be returned unique_ptr
}

...

auto int_uptr = get_unique(); // <- 3

Derlemeye ayarlanan bayrakla bu işlevde iki hamle (1 ve 2) ve daha sonra da (3) bir hamle gerçekleşir.

Bu hiçbir şekilde spesifik değildir std::unique_ptr, ancak taşınabilir olan herhangi bir sınıfa uygulanır. Değerle döndüğünüz için dil kuralları tarafından garanti edilir. Derleyici kopyaları kaldırmaya çalışır, kopyaları kaldıramıyorsa bir taşıma yapıcısını çağırır, hareket edemiyorsa bir kopya yapıcısını çağırır ve kopyalayamazsa derleyemez.

Eğer std::unique_ptrargüman olarak kabul eden bir fonksiyonunuz olsaydı, ona p'yi geçemezdiniz. Move yapıcısını açıkça çağırmanız gerekir, ancak bu durumda çağrıdan sonra p değişkenini kullanmamalısınız bar().

void bar(std::unique_ptr<int> p)
{
    // ...
}

int main()
{
    unique_ptr<int> p = foo();
    bar(p); // error, can't implicitly invoke move constructor on lvalue
    bar(std::move(p)); // OK but don't use p afterwards
    return 0;
}

unique_ptr geleneksel kopya oluşturucuya sahip değil. Bunun yerine, değer referanslarını kullanan bir "hareket yapıcısı" vardır:

unique_ptr::unique_ptr(unique_ptr && src);

Bir rvalue referansı (çift ve işareti) yalnızca bir rvalue'ya bağlanır. Bu nedenle bir işleve lvalue unique_ptr iletmeye çalıştığınızda hata alıyorsunuz. Öte yandan, bir işlevden döndürülen bir değer bir değer olarak kabul edilir, bu nedenle taşıma yapıcısı otomatik olarak çağrılır.

Bu arada, bu doğru bir şekilde çalışacaktır:

bar(unique_ptr<int>(new int(44));

Buradaki geçici unique_ptr bir değerdir.

Bence Scott Meyers'in Etkili Modern C ++ 'ın 25. maddesinde mükemmel bir şekilde açıklandı . İşte bir alıntı:

Standardın RVO'yu kutsama kısmı, RVO'nun koşulları yerine getirilirse, ancak derleyiciler kopya elizyonu yapmayı seçmezse, döndürülen nesneye bir rvalue olarak davranılması gerektiğini söyler. Gerçekte, Standart, RVO'ya izin verildiğinde, ya kopya seçiminin yapılmasını ya std::moveda döndürülen yerel nesnelere dolaylı olarak uygulanmasını gerektirir.

Burada, RVO atıfta değer optimizasyonu dönmek ve RVT için şartlar yerine getirildiği takdirde yerel nesne dönen araçlar yapmanız beklenir o fonksiyonun içinde tanımlanması RVO güzel atıfta bulunarak kitabının öğesi 25'de açıklandığı da, standart (burada yerel nesne , return ifadesi tarafından oluşturulan geçici nesneleri içerir). Alıntıdanstd::move en büyük çekim ya kopya eleme ya da iade edilen yerel nesnelere dolaylı olarak uygulanmasıdır . Scott std::move, derleyici kopyayı elememeyi seçtiğinde ve programcının açıkça yapmaması gerektiğinde örtük olarak uygulanan madde 25'ten bahseder .

Senin durumunda, kod açıkça aday olduğunu RVT yerel nesnesi döndüren olarak pve tipi pdönüş türü, kopya elision sonuçları aynıdır. Ve eğer derleyici kopyayı elememeyi seçerse, ne sebeple olursa olsun, std::movesıraya girerdi 1.

Diğer cevaplarda görmediğim bir şeyBaşka bir cevabı açıklığa kavuşturmak için , bir işlev içinde yaratılan std :: unique_ptr ile bu işleve verilen yanıt arasında bir fark olduğunu açıklığa kavuşturmak .

Örnek şöyle olabilir:

class Test
{int i;};
std::unique_ptr<Test> foo1()
{
    std::unique_ptr<Test> res(new Test);
    return res;
}
std::unique_ptr<Test> foo2(std::unique_ptr<Test>&& t)
{
    // return t;  // this will produce an error!
    return std::move(t);
}

//...
auto test1=foo1();
auto test2=foo2(std::unique_ptr<Test>(new Test));