C ++ 'da bir nesne döndürmek nasıl?

Birçok benzer soru var gibi başlık tanıdık geliyor biliyorum, ama sorunun farklı bir yönünü soruyorum (yığın üzerinde şeyler var ve yığın üzerine koymak arasındaki farkı biliyorum).

Java'da her zaman "yerel" nesnelere başvuruları döndürebilirim

public Thing calculateThing() {
    Thing thing = new Thing();
    // do calculations and modify thing
    return thing;
}

C ++, benzer bir şey yapmak için 2 seçenek var

(1) Bir nesneyi "döndürmem" gerektiğinde referansları kullanabilirim

void calculateThing(Thing& thing) {
    // do calculations and modify thing
}

O zaman böyle kullan

Thing thing;
calculateThing(thing);

(2) Veya dinamik olarak ayrılmış bir nesneye bir işaretçi döndürebilirim

Thing* calculateThing() {
    Thing* thing(new Thing());
    // do calculations and modify thing
    return thing;
}

O zaman böyle kullan

Thing* thing = calculateThing();
delete thing;

İlk yaklaşımı kullanarak hafızayı elle boşaltmak zorunda kalmayacağım, ama bana göre kodun okunmasını zorlaştırıyor. İkinci yaklaşımla ilgili sorun, hatırlamak zorunda kalacağım delete thing;, ki bu hoş görünmüyor. Kopyalanan bir değeri döndürmek istemiyorum çünkü verimsiz (sanırım), işte sorular geliyor

• Üçüncü bir çözüm var mı (değerin kopyalanmasını gerektirmez)?
• İlk çözüme bağlı kalırsam herhangi bir sorun var mı?
• İkinci çözümü ne zaman ve neden kullanmalıyım?

Kopyalanan bir değeri döndürmek istemiyorum çünkü verimsiz

Kanıtla.

RVO ve NRVO ve C ++ 0x hareket semantiğine bakın. Çoğu durumda, C ++ 03'te bir out parametresi kodunuzu çirkin hale getirmenin iyi bir yoludur ve C ++ 0x'de bir out parametresi kullanarak kendinizi incitirsiniz.

Sadece temiz kod yazın, değere göre döndürün. Performans bir sorunsa profil oluşturun (tahmin etmeyi durdurun) ve düzeltmek için neler yapabileceğinizi bulun. Muhtemelen bir şeyleri işlevlerden döndürmeyecektir.

Bununla birlikte, eğer böyle yazmaya hazırsanız, muhtemelen out parametresini yapmak istersiniz. Daha güvenli ve genellikle daha hızlı olan dinamik bellek ayırmayı önler. İşlevi çağırmadan önce nesneyi oluşturmak için bir yolunuz olmasını gerektirir, bu da tüm nesneler için her zaman anlamlı değildir.

Dinamik ayırmayı kullanmak istiyorsanız, yapılabilecek en az şey bunu akıllı bir işaretçiye koymaktır. (Bu her zaman her zaman yapılmalıdır) O zaman bir şey silme konusunda endişelenmeyin, işler istisna güvenlidir, vb. Tek sorun zaten değerle döndürmekten daha yavaş olması!

Sadece nesneyi oluşturun ve geri gönderin

Thing calculateThing() {
    Thing thing;
    // do calculations and modify thing
     return thing;
}

Optimizasyonu unutursanız ve sadece okunabilir kod yazarsanız kendinize bir iyilik yapacağınızı düşünüyorum (daha sonra bir profiler çalıştırmanız gerekir - ancak önceden optimize etmeyin).

Bunun gibi bir nesneyi döndürmeniz yeterlidir:

Thing calculateThing() 
{
   Thing thing();
   // do calculations and modify thing
   return thing;
}

Bu, Things üzerinde kopya oluşturucuyu çağırır, böylece bunu kendi uygulamanızı yapmak isteyebilirsiniz. Bunun gibi:

Thing(const Thing& aThing) {}

Bu biraz daha yavaş gerçekleşebilir, ancak hiç sorun olmayabilir.

Güncelleme

Derleyici muhtemelen kopya oluşturucuya yapılan çağrıyı optimize eder, böylece fazladan ek yük olmaz. (Yorumda işaret edilen dreamlax gibi).

Auto_ptr gibi akıllı işaretçiler (Thing gerçekten büyük ve ağır bir nesne ise) kullanmaya çalıştınız mı:

std::auto_ptr<Thing> calculateThing()
{
  std::auto_ptr<Thing> thing(new Thing);
  // .. some calculations
  return thing;
}


// ...
{
  std::auto_ptr<Thing> thing = calculateThing();
  // working with thing

  // auto_ptr frees thing 
}

Bir kopya oluşturucunun çağrılıp çağrılmadığını belirlemenin hızlı bir yolu, sınıfınızın kopya yapıcısına günlük eklemektir:

MyClass::MyClass(const MyClass &other)
{
    std::cout << "Copy constructor was called" << std::endl;
}

MyClass someFunction()
{
    MyClass dummy;
    return dummy;
}

Ara someFunction; alacağınız "Kopya yapıcısı çağrıldı" satırlarının sayısı 0, 1 ve 2 arasında değişecektir. Hiçbirini almazsanız, derleyiciniz dönüş değerini optimize etmiştir (yapmasına izin verilir). Eğer 0 alamadım olsun ve kopyalama yapıcı gülünç pahalı ise, o zaman da işlevlerden örnekleri dönmek için alternatif yollar aramak.

Öncelikle kodda bir hata var Thing *thing(new Thing());, sadece ve sadece return thing;.

• Kullanın shared_ptr<Thing>. Bir işaretçi olarak tho deref. İçerdiği son referans Thingkapsam dışına çıktığında sizin için silinecektir .
• İlk çözüm naif kütüphanelerde çok yaygındır. Biraz performansa ve sözdizimsel yüke sahiptir, mümkünse kaçının
• İkinci çözümü yalnızca istisnaların atılmayacağını garanti edemiyorsanız veya performans kesinlikle kritik olduğunda kullanın (bu konuyla ilgili olmadan önce C veya montajla arayüz oluşturacaksınız).

Bir C ++ uzmanının daha iyi bir cevapla geleceğinden eminim, ama şahsen ikinci yaklaşımı seviyorum. Akıllı işaretçiler kullanmak, unutmak problemine yardımcı olur deleteve dediğiniz gibi, elden önce bir nesne oluşturmak zorunda kalmadan daha temiz görünür (ve yığın üzerinde ayırmak istiyorsanız yine de silmek zorunda kalırsınız).