make_unique và chuyển tiếp hoàn hảo

Tại sao không có std::make_uniquemẫu hàm trong thư viện C ++ 11 tiêu chuẩn? Tôi tìm thấy

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

dài dòng một chút. Không phải sau đây sẽ đẹp hơn nhiều?

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

Điều này ẩn giấu newđộc đáo và chỉ đề cập đến loại một lần.

Dù sao, đây là nỗ lực của tôi trong việc thực hiện 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)...));
}

Tôi mất khá nhiều thời gian để có được std::forwardcông cụ biên dịch, nhưng tôi không chắc liệu nó có đúng không. Là nó? Chính xác thì std::forward<Args>(args)...có nghĩa là gì? Trình biên dịch làm gì cho điều đó?

Herb Sutter, chủ tịch ủy ban C ++ chuẩn, viết về mình trên blog :

C ++ 11 không bao gồm make_uniquemột phần là một sự giám sát và gần như chắc chắn nó sẽ được thêm vào trong tương lai.

Ông cũng đưa ra một triển khai giống hệt với triển khai của OP.

Chỉnh sửa: std::make_unique bây giờ là một phần của C ++ 14 .

Đẹp, nhưng Stephan T. Lavavej (được biết đến với tên STL) có một giải pháp tốt hơn make_unique, hoạt động chính xác cho phiên bản mảng.

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

Điều này có thể được nhìn thấy trên video Core C ++ 6 của anh ấy .

Phiên bản cập nhật của phiên bản make_unique của STL hiện có sẵn dưới dạng N3656 . Phiên bản này đã được thông qua vào dự thảo C ++ 14.

std::make_sharedkhông chỉ là tốc ký cho std::shared_ptr<Type> ptr(new Type(...));. Nó làm một cái gì đó mà bạn không thể làm mà không có nó.

Để thực hiện công việc của mình, std::shared_ptrphải phân bổ một khối theo dõi ngoài việc giữ bộ lưu trữ cho con trỏ thực tế. Tuy nhiên, vì std::make_sharedphân bổ đối tượng thực tế, có thể std::make_sharedphân bổ cả đối tượng và khối theo dõi trong cùng một khối bộ nhớ.

Vì vậy, trong khi std::shared_ptr<Type> ptr = new Type(...);sẽ là hai cấp phát bộ nhớ (một cho new, một trong std::shared_ptrkhối theo dõi), std::make_shared<Type>(...)sẽ phân bổ một khối bộ nhớ.

Đó là điều quan trọng đối với nhiều người dùng tiềm năng std::shared_ptr. Điều duy nhất std::make_uniquesẽ làm là thuận tiện hơn một chút. Không có gì hơn thế.

Mặc dù không có gì ngăn bạn viết người trợ giúp của riêng bạn, tôi tin rằng lý do chính để cung cấp make_shared<T>trong thư viện là nó thực sự tạo ra một loại con trỏ chia sẻ nội bộ khác với shared_ptr<T>(new T), được phân bổ khác nhau và không có cách nào để đạt được điều này nếu không có sự tận tâm người giúp đỡ.

make_uniqueMặt khác, trình bao bọc của bạn chỉ là đường cú pháp xung quanh một newbiểu thức, vì vậy trong khi nó có thể trông vừa mắt, nó không mang bất cứ thứ gì newlên bàn. Sửa lỗi: thực tế điều này không đúng: Có một lệnh gọi hàm để bọc newbiểu thức cung cấp sự an toàn ngoại lệ, ví dụ trong trường hợp bạn gọi một hàm void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Có hai nguyên liệu newkhông có kết quả liên quan đến nhau có nghĩa là nếu một biểu thức mới không thành công với một ngoại lệ, thì biểu thức kia có thể rò rỉ tài nguyên. Về lý do tại sao không có make_uniquetrong tiêu chuẩn: Nó chỉ bị lãng quên. (Điều này thỉnh thoảng xảy ra. Cũng không có std::cbegintiêu chuẩn toàn cầu mặc dù phải có một cái.)

Cũng lưu ý rằng unique_ptrcó một tham số mẫu thứ hai mà bạn nên cho phép bằng cách nào đó; điều này khác với shared_ptr, trong đó sử dụng kiểu xóa để lưu trữ các thông số tùy chỉnh mà không biến chúng thành một phần của kiểu.

Trong C ++ 11 ... cũng được sử dụng (trong mã mẫu) cho "mở rộng gói".

Yêu cầu là bạn sử dụng nó như một hậu tố của một biểu thức có chứa một gói tham số chưa được mở rộng và nó sẽ chỉ áp dụng biểu thức cho từng thành phần của gói.

Ví dụ: xây dựng trên ví dụ của bạn:

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)

Cái sau là không chính xác tôi nghĩ.

Ngoài ra, gói đối số có thể không được chuyển đến một hàm chưa được mở rộng. Tôi không chắc chắn về một gói các tham số mẫu.

Lấy cảm hứng từ việc thực hiện bởi Stephan T. Lavavej, tôi nghĩ rằng thật tuyệt khi có một make_unique hỗ trợ các phạm vi mảng, nó trên github và tôi rất thích nhận được ý kiến ​​về nó. Nó cho phép bạn làm điều này:

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