C ++ 17'de neden std :: make_unique kullanılıyor?

Anladığım kadarıyla, C ++ 14 tanıtıldı std::make_uniqueçünkü parametre değerlendirme sırasının belirtilmemesi nedeniyle bu güvenli değildi:

f(std::unique_ptr<MyClass>(new MyClass(param)), g()); // Syntax A

(Açıklama: Eğer değerlendirme önce hafızayı ham işaretçi için ayırırsa, sonra çağırır g()ve yapımdan önce bir istisna atılırsa std::unique_ptr, hafıza sızdırılır.)

Arama std::make_unique, arama sırasını kısıtlamanın bir yoluydu ve böylece işleri güvenli hale getiriyordu:

f(std::make_unique<MyClass>(param), g());             // Syntax B

O zamandan beri, C ++ 17 değerlendirme sırasını netleştirdi ve Sözdizimi A'yı da güvenli hale getirdi, işte sorum şu: C ++ 17'de over yapıcısını kullanmak için hala bir neden var mı? Bazı örnekler verebilir misiniz?std::make_uniquestd::unique_ptr

Şu an için, hayal edebildiğim tek neden, MyClassyalnızca bir kez yazmaya izin vermesidir (polimorfizme güvenmeniz gerekmediğini varsayarak std::unique_ptr<Base>(new Derived(param))). Bununla birlikte, bu oldukça zayıf bir neden gibi görünüyor, özellikle std::make_uniquekurucunun yaptığı sırada bir silici belirtmeye izin std::unique_ptrvermediğinde.

Ve daha açık olmak std::make_uniquegerekirse, Standart Kitaplık'tan çıkarılmayı savunmuyorum (en azından geriye dönük uyumluluk için mantıklıdır), daha ziyade hala şiddetle tercih edilenstd::unique_ptr

Ana nedenin kaldırıldığı konusunda haklısın. Hala yeni yönergeler kullanmama ve daha az yazma nedenleri var (türü tekrarlamak veya sözcüğü kullanmak zorunda değilsiniz new). Kuşkusuz bunlar güçlü argümanlar değil ama kodumda görmemeyi gerçekten seviyorum new.

Ayrıca tutarlılığı da unutmayın. Kesinlikle make_sharedkullanmalısınız make_unique, bu yüzden kullanmak doğaldır ve kalıba uyar. Bu değişime, sonra Önemsiz std::make_unique<MyClass>(param)için std::make_shared<MyClass>(param)(ya da tersine) sözdizimi bir çok daha fazla yeniden yazma gerektirir.

make_uniqueayıran Tgelen T[]ve T[N], unique_ptr(new ...)yapmaz.

Kolayca bir işaretçi geçirerek tanımlanmamış davranışı elde edebilirsiniz new[]bir etmek ed unique_ptr<T>veya bir işaretçi geçirerek newbir karşı ed unique_ptr<T[]>.

Bunun nedeni, kopyalar olmadan daha kısa koda sahip olmaktır. Karşılaştırmak

f(std::unique_ptr<MyClass>(new MyClass(param)), g());
f(std::make_unique<MyClass>(param), g());

Kaydetmek MyClass, newve takviyeler. Sadece bir karakter daha fazlasında maliyeti marka ile karşılaştırıldığında ptr .

Her kullanım, newömür boyu doğruluk için ekstra dikkatle denetlenmelidir; silinir mi? Sadece bir kere?

Her kullanımda make_uniquebu ekstra özellikler için değil; sahip olan nesne "doğru" yaşam süresine sahip olduğu sürece, benzersiz işaretçinin "doğru" olmasını özyinelemeli olarak yapar.

Şimdi, bunun unique_ptr<Foo>(new Foo())her yönden ¹ ile aynı olduğu doğrudur make_unique<Foo>(); sadece daha basit bir " newonları denetlemek için tüm kullanımları için kaynak kodunuzu grep" gerektirir .

¹ aslında genel durumda bir yalan. Mükemmel yönlendirme mükemmel değildir {}, varsayılan init, dizilerin hepsi istisnadır.

O zamandan beri, C ++ 17 değerlendirme sırasını netleştirerek Söz Dizimi A'yı da güvenli hale getirdi

Bu gerçekten yeterince iyi değil. Güvenlik garantisi olarak yeni tanıtılan bir teknik maddeye güvenmek çok sağlam bir uygulama değildir:

• Birisi bu kodu C ++ 14'te derleyebilir.
• Çiğ kullanımını teşvik edeceksiniz newÖrneğin, örneğinizi kopyalayıp yapıştırarak, çiğlerin başka yerlerde edebilirsiniz.
• SM'nin önerdiği gibi, kod kopyası olduğu için bir tür, diğeri değiştirilmeden değiştirilebilir.
• Bir tür otomatik IDE yeniden düzenleme bunu newbaşka bir yere taşıyabilir (tamam, verilmiş, pek şansı yok).

Genellikle, bu kod açıkça geçerli / sağlam / uygun olması için iyi bir fikir olmadan standardında teknik maddeleri, dil-laywering başvurmadan minör ararken veya gizleyebilir.

(Bu, esasen burada demet yıkımının sırası hakkında yaptığım argümanla aynı .)

Void işlevini düşünün (std :: unique_ptr (new A ()), std :: unique_ptr (new B ())) {...}

Yeni A () 'nın başarılı olduğunu, ancak yeni B ()' nin bir istisna attığını varsayalım: onu programınızın normal çalışmasını sürdürmek için yakalarsınız. Ne yazık ki, C ++ standardı, A nesnesinin yok edilmesini ve belleğinin serbest bırakılmasını gerektirmez: bellek sessizce sızar ve onu temizlemenin bir yolu yoktur. A ve B'yi std :: make_uniques içine sararak sızıntının gerçekleşmeyeceğinden emin olursunuz:

void işlevi (std :: make_unique (), std :: make_unique ()) {...} Buradaki nokta şu ki std :: make_unique ve std :: make_unique artık geçici nesnelerdir ve geçici nesnelerin temizlenmesi C ++ standardı: yıkıcıları tetiklenecek ve bellek serbest bırakılacaktır. Dolayısıyla, eğer yapabiliyorsanız, nesneleri her zaman std :: make_unique ve std :: make_shared kullanarak tahsis etmeyi tercih edin.