make_unique และการส่งต่อที่สมบูรณ์แบบ

เหตุใดจึงไม่มีstd::make_uniqueเทมเพลตฟังก์ชันในไลบรารี C ++ 11 มาตรฐาน ฉันหา

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

verbose เล็กน้อย ต่อไปนี้จะดีกว่านี้ไหม

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

สิ่งนี้ซ่อนสิ่งที่newดีและกล่าวถึงเพียงครั้งเดียวเท่านั้น

อย่างไรก็ตามนี่คือความพยายามของฉันในการดำเนินการ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)...));
}

ฉันใช้เวลาพอสมควรในการstd::forwardรวบรวมสิ่งต่าง ๆ แต่ฉันไม่แน่ใจว่ามันถูกต้องหรือไม่ ใช่ไหม? std::forward<Args>(args)...หมายความว่าอะไรกันแน่? คอมไพเลอร์ทำอะไรได้บ้าง

Herb Sutter เก้าอี้ของคณะกรรมการมาตรฐาน C ++ เขียนไว้ในบล็อกของเขา:

C ++ 11 ที่ไม่รวมmake_uniqueนั้นเป็นส่วนหนึ่งของการกำกับดูแลและจะเพิ่มเข้ามาในอนาคต

นอกจากนี้เขายังให้การใช้งานที่เหมือนกันกับที่ได้รับจาก OP

แก้ไข: std::make_uniqueตอนนี้เป็นส่วนหนึ่งของภาษา C ++ 14

นิสัยดี แต่ Stephan T. Lavavej (รู้จักกันในชื่อ STL) มีวิธีแก้ปัญหาที่ดีกว่าสำหรับmake_uniqueซึ่งทำงานได้อย่างถูกต้องสำหรับรุ่นอาร์เรย์

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

สามารถดูได้ในวิดีโอ Core C ++ 6 ของเขา

รุ่นปรับปรุงของรุ่น STL ของ make_unique ขณะนี้ใช้ได้เป็นN3656 รุ่นนี้มีการนำไปใช้กับแบบร่าง C ++ 14

std::make_sharedstd::shared_ptr<Type> ptr(new Type(...));ไม่ได้เป็นเพียงชวเลข มันทำสิ่งที่คุณไม่สามารถทำถ้าขาดมัน

เพื่อที่จะทำงานได้std::shared_ptrต้องจัดสรรบล็อกการติดตามเพิ่มเติมเพื่อเก็บที่เก็บสำหรับตัวชี้จริง อย่างไรก็ตามเนื่องจากstd::make_sharedจัดสรรวัตถุจริงจึงเป็นไปได้ที่จะstd::make_sharedจัดสรรทั้งวัตถุและบล็อกติดตามในบล็อกหน่วยความจำเดียวกัน

ดังนั้นในขณะที่std::shared_ptr<Type> ptr = new Type(...);จะจัดสรรสองหน่วยความจำ (หนึ่งสำหรับnew, หนึ่งในstd::shared_ptrบล็อกการติดตาม) std::make_shared<Type>(...)จะจัดสรรหนึ่งหน่วยความจำบล็อก

std::shared_ptrนั่นเป็นสิ่งสำคัญสำหรับผู้ที่มีศักยภาพหลายแห่ง สิ่งเดียวที่std::make_uniqueจะทำคือสะดวกขึ้นเล็กน้อย ไม่มีอะไรมากไปกว่านั้น

ในขณะที่ไม่มีอะไรหยุดคุณจากการเขียนผู้ช่วยของคุณเองฉันเชื่อว่าเหตุผลหลักmake_shared<T>ในการให้บริการในห้องสมุดก็คือว่ามันสร้างตัวชี้ที่ใช้ร่วมกันภายในชนิดที่แตกต่างกว่าshared_ptr<T>(new T)ที่จัดสรรไว้แตกต่างกันและไม่มีวิธีใดที่จะบรรลุเป้าหมายนี้ ผู้ช่วย

make_uniqueเสื้อคลุมของคุณในอีกทางหนึ่งเป็นเพียงประโยคน้ำตาลรอบ ๆnewสำนวนดังนั้นในขณะที่มันอาจดูเป็นที่ชื่นชอบ แต่มันไม่ได้นำอะไรnewมาวางบนโต๊ะ การแก้ไข:นี้ไม่ได้ในความเป็นจริงจริง: มีการเรียกใช้ฟังก์ชันการตัดการแสดงออกให้ความปลอดภัยยกเว้นเช่นในกรณีที่คุณเรียกฟังก์ชั่นnew void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&)การมี raw สองตัวnewที่ไม่ได้เกิดตามมาด้วยความเคารพซึ่งกันและกันหมายความว่าหากการแสดงออกใหม่ล้มเหลวโดยมีข้อยกเว้น สำหรับสาเหตุที่ไม่มีmake_uniqueมาตรฐาน: มันถูกลืมไปแล้ว (สิ่งนี้เกิดขึ้นเป็นครั้งคราวและยังไม่มีstd::cbeginมาตรฐานระดับโลกแม้ว่าจะควรมีอยู่ก็ตาม)

นอกจากนี้โปรดทราบว่าunique_ptrใช้พารามิเตอร์เทมเพลตที่สองซึ่งคุณควรอนุญาต สิ่งนี้แตกต่างจากshared_ptrซึ่งใช้การลบประเภทเพื่อจัดเก็บ deleters ที่กำหนดเองโดยไม่ทำให้พวกเขาเป็นส่วนหนึ่งของประเภท

ใน C ++ 11 ...ใช้ (ในรหัสเทมเพลต) สำหรับ "แพ็คขยาย" เช่นกัน

ความต้องการคือคุณใช้มันเป็นคำต่อท้ายของการแสดงออกที่มีแพ็คของพารามิเตอร์ที่ไม่ขยายและมันก็จะใช้การแสดงออกกับแต่ละองค์ประกอบของแพ็ค

ตัวอย่างเช่นการสร้างตัวอย่างของคุณ:

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)

ฉันคิดว่าไม่ถูกต้อง

นอกจากนี้ชุดของอาร์กิวเมนต์อาจไม่ถูกส่งไปยังฟังก์ชันที่ไม่ขยาย ฉันไม่แน่ใจเกี่ยวกับชุดพารามิเตอร์เทมเพลต

แรงบันดาลใจจากการใช้งานโดย Stephan T. Lavavej ฉันคิดว่ามันอาจจะดีถ้ามี make_unique ที่รองรับส่วนขยายของอาร์เรย์มันใช้ gitub และฉันชอบที่จะรับความคิดเห็น อนุญาตให้คุณทำสิ่งนี้:

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