make_unique dan penerusan sempurna

Mengapa tidak ada std::make_uniquetemplat fungsi di pustaka C ++ 11 standar? saya menemukan

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

sedikit bertele-tele. Bukankah yang berikut ini akan jauh lebih baik?

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

Ini menyembunyikan yang newbaik dan hanya menyebutkan tipe sekali.

Bagaimanapun, ini adalah upaya saya untuk implementasi dari 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)...));
}

Butuh waktu cukup lama untuk menyelesaikannya std::forward, tapi saya tidak yakin apakah itu benar. Apakah itu? Apa sebenarnya std::forward<Args>(args)...artinya? Apa yang dilakukan oleh kompiler?

Herb Sutter, ketua komite standardisasi C ++, menulis di blognya :

Bahwa C ++ 11 tidak termasuk make_uniqueadalah sebagian dari pengawasan, dan hampir pasti akan ditambahkan di masa depan.

Dia juga memberikan implementasi yang identik dengan yang diberikan oleh OP.

Sunting: std::make_unique sekarang adalah bagian dari C ++ 14 .

Bagus, tetapi Stephan T. Lavavej (lebih dikenal sebagai STL) memiliki solusi yang lebih baik make_unique, yang berfungsi dengan benar untuk versi array.

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

Ini dapat dilihat pada video Core C ++ 6-nya .

Versi terbaru dari versi make_unique STL sekarang tersedia sebagai N3656 . Versi ini diadopsi menjadi konsep C ++ 14.

std::make_sharedbukan hanya singkatan untuk std::shared_ptr<Type> ptr(new Type(...));. Itu melakukan sesuatu yang tidak bisa Anda lakukan tanpanya.

Untuk melakukan tugasnya, std::shared_ptrharus mengalokasikan blok pelacak selain menahan penyimpanan untuk penunjuk yang sebenarnya. Namun, karena std::make_sharedmengalokasikan objek yang sebenarnya, ada kemungkinan bahwa std::make_sharedmengalokasikan objek dan blok pelacakan di blok memori yang sama.

Jadi sementara std::shared_ptr<Type> ptr = new Type(...);akan ada dua alokasi memori (satu untuk new, satu di std::shared_ptrblok pelacakan), std::make_shared<Type>(...)akan mengalokasikan satu blok memori.

Itu penting bagi banyak pengguna potensial std::shared_ptr. Satu-satunya hal yang std::make_uniqueakan dilakukan adalah sedikit lebih nyaman. Tidak lebih dari itu.

Sementara tidak ada yang menghentikan Anda dari menulis pembantu Anda sendiri, saya percaya bahwa alasan utama menyediakan make_shared<T>di perpustakaan adalah bahwa itu sebenarnya menciptakan jenis internal yang berbeda dari pointer bersama shared_ptr<T>(new T), yang dialokasikan secara berbeda, dan tidak ada cara untuk mencapai ini tanpa dedikasi pembantu.

make_uniquePembungkus Anda di sisi lain hanyalah gula sintaksis di sekitar newekspresi, jadi meskipun mungkin terlihat menyenangkan bagi mata, itu tidak membawa apa pun newke meja. Koreksi: ini sebenarnya tidak benar: Memiliki panggilan fungsi untuk membungkus newekspresi memberikan keamanan pengecualian, misalnya dalam kasus di mana Anda memanggil suatu fungsi void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Memiliki dua mentah newyang tidak dilanjutkan sehubungan dengan satu sama lain berarti bahwa jika satu ekspresi baru gagal dengan pengecualian, yang lain dapat membocorkan sumber daya. Adapun mengapa tidak ada make_uniquedalam standar: Itu baru saja dilupakan. (Ini kadang-kadang terjadi. Tidak ada global std::cbegindalam standar meskipun harus ada satu.)

Perhatikan juga bahwa unique_ptrmengambil parameter templat kedua yang entah bagaimana harus Anda izinkan; ini berbeda dengan shared_ptr, yang menggunakan penghapusan tipe untuk menyimpan delet khusus tanpa menjadikannya bagian dari tipe itu.

Dalam C ++ 11 ...digunakan (dalam kode templat) untuk "paket ekspansi" juga.

Syaratnya adalah Anda menggunakannya sebagai akhiran dari ekspresi yang berisi paket parameter yang tidak dikembangkan, dan itu hanya akan menerapkan ekspresi untuk masing-masing elemen paket.

Misalnya, membangun contoh Anda:

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)

Yang terakhir salah saya pikir.

Juga, paket argumen tidak dapat diteruskan ke fungsi yang tidak dikembangkan. Saya tidak yakin tentang paket parameter template.

Terinspirasi oleh implementasi oleh Stephan T. Lavavej, saya pikir mungkin lebih baik memiliki make_unique yang mendukung perluasan array, ada di github dan saya ingin mendapatkan komentar tentangnya. Ini memungkinkan Anda untuk melakukan ini:

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