make_unique ve mükemmel yönlendirme

std::make_uniqueStandart C ++ 11 kitaplığında neden işlev şablonu yok ? buldum

std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3));

biraz ayrıntılı. Aşağıdakiler çok daha hoş olmaz mıydı?

auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3);

Bu newgüzel gizler ve sadece bir kez türü bahseder.

Her neyse, işte benim uygulama girişimim make_unique:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Bu std::forwardşeylerin derlenmesini sağlamak biraz zaman aldı , ama doğru olup olmadığından emin değilim. Bu mu? Tam olarak ne anlama std::forward<Args>(args)...geliyor? Derleyici bundan ne çıkarıyor?

C ++ standardizasyon komitesi başkanı Herb Sutter blogunda şöyle yazıyor :

C ++ 11'in içermediği make_uniquekısmen bir gözetimdir ve gelecekte kesinlikle kesinlikle eklenecektir.

Ayrıca OP tarafından verilenle aynı olan bir uygulama da verir.

Düzenleme: std::make_unique şimdi C ++ 14'ün bir parçasıdır .

Güzel, ama Stephan T. Lavavej (daha iyi STL olarak bilinir), make_uniquedizi sürümü için doğru çalışan daha iyi bir çözüme sahiptir .

#include <memory>
#include <type_traits>
#include <utility>

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::false_type, Args&&... args) {
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::true_type, Args&&... args) {
   static_assert(std::extent<T>::value == 0,
       "make_unique<T[N]>() is forbidden, please use make_unique<T[]>().");

   typedef typename std::remove_extent<T>::type U;
   return std::unique_ptr<T>(new U[sizeof...(Args)]{std::forward<Args>(args)...});
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
   return make_unique_helper<T>(std::is_array<T>(), std::forward<Args>(args)...);
}

Bu onun Core C ++ 6 videosunda görülebilir .

Make_unique ait STL? Sürümüne güncellenmiş sürümü olarak kullanıma sunulmuştur N3656 . Bu sürüm taslak C ++ 14'e uyarlanmıştır .

std::make_sharedsadece kısayol değildir std::shared_ptr<Type> ptr(new Type(...));. Onsuz yapamayacağınız bir şey yapar .

İşini yapmak std::shared_ptriçin, gerçek işaretçi için depolama alanını tutmanın yanı sıra bir izleme bloğu ayırmalıdır. Bununla birlikte, std::make_sharedtahsis gerçek nesne, bu mümkün olduğu std::make_sharedayırır konusu, her ikisi ve de izleme bloğunu aynı bellek bloğuna .

Yani ederken std::shared_ptr<Type> ptr = new Type(...);iki bellek ayırmalarını (için biri olacağını new, bir std::shared_ptrizleme bloğu), std::make_shared<Type>(...)tahsis edecek birini bellek bloğu.

Bu, birçok potansiyel kullanıcı için önemlidir std::shared_ptr. std::make_uniqueA'nın yapacağı tek şey biraz daha uygun olmaktır. Bundan daha fazlası yok.

Hiçbir şey kendi yardımcısını yazmanızı engellemese make_shared<T>de, kütüphanede sağlamanın ana nedeninin aslında shared_ptr<T>(new T)farklı bir şekilde tahsis edilmiş olandan farklı bir iç paylaşılan işaretçi oluşturması ve buna adanmış olmadan bunu başarmanın bir yolu olmadığına inanıyorum. yardımcı.

Sizin make_uniquediğer taraftan sarıcı bir çevrede sadece sözdizimsel şeker newo, hiçbir şey getirmiyor göze hoş görünebilir bu yüzden ederken, ifade newmasaya. Düzeltme: bu aslında doğru değildir: newİfadeyi sarmak için bir işlev çağrısına sahip olmak , örneğin bir işlevi çağırmanız durumunda istisna güvenliği sağlar void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). newBirbirine göre birbirinden farklı iki ham madde olması, yeni bir ifade bir istisna dışında başarısız olursa, diğerinin kaynakları sızdırabileceği anlamına gelir. make_uniqueStandartta neden yok diye gelince : Sadece unutuldu. (Bu arada sırada olur. Küresel de yokturstd::cbegin sırada gerçekleşir. Standart olmasına rağmen .)

Ayrıca unique_ptr, bir şekilde izin vermeniz gereken ikinci bir şablon parametresi aldığını unutmayın ; bu, özel silgileri türün bir parçası haline getirmeden saklamakshared_ptr için tür silme özelliğini kullananlardan farklıdır .

C ++ 11'de ... (şablon kodunda) "paket genişletme" için de kullanılır.

Gereksinim, genişlememiş bir parametre paketi içeren bir ifadenin soneki olarak kullanmanız ve ifadeyi paketin öğelerinin her birine uygulayabilmesidir.

Örneğin, örneğinizi temel alarak:

std::forward<Args>(args)... -> std::forward<int>(1), std::forward<int>(2),
                                                     std::forward<int>(3)

std::forward<Args...>(args...) -> std::forward<int, int, int>(1,2,3)

İkincisinin yanlış olduğunu düşünüyorum.

Ayrıca, argüman paketi genişletilmemiş bir işleve geçirilemez. Bir şablon parametreleri paketi hakkında emin değilim.

Stephan T. Lavavej tarafından uygulanması esinlenerek, Bence dizi kapsamlarını desteklenen bir make_unique olması güzel olabileceğini düşündüm o github üzerinde olduğunu ve bunu ilgili yorum almak isteriz. Bunu yapmanıza izin verir:

// create unique_ptr to an array of 100 integers
auto a = make_unique<int[100]>();

// create a unique_ptr to an array of 100 integers and
// set the first three elements to 1,2,3
auto b = make_unique<int[100]>(1,2,3);