Sự khác biệt giữa std :: make_unique và std :: unique_ptr với mới

Có std::make_uniquebất kỳ lợi ích hiệu quả như thế std::make_sharednào?

So với xây dựng thủ công std::unique_ptr:

std::make_unique<int>(1);         // vs
std::unique_ptr<int>(new int(1));

Động lực đằng sau make_uniquechủ yếu là hai lần:

• make_uniquelà an toàn để tạo tạm thời, trong khi với việc sử dụng rõ ràng newbạn phải nhớ quy tắc về việc không sử dụng tạm thời không tên.

  foo(make_unique<T>(), make_unique<U>()); // exception safe
  
  foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*

• Việc bổ sung make_uniquecuối cùng có nghĩa là chúng ta có thể bảo mọi người 'không bao giờ' sử dụng newthay vì quy tắc trước đó để "không bao giờ" sử dụng newtrừ khi bạn thực hiện unique_ptr".

Ngoài ra còn có một lý do thứ ba:

• make_uniquekhông yêu cầu sử dụng loại dự phòng. unique_ptr<T>(new T())->make_unique<T>()

Không có lý do nào liên quan đến việc cải thiện hiệu quả thời gian chạy theo cách sử dụng make_shared(do tránh phân bổ thứ hai, với chi phí sử dụng bộ nhớ cao nhất có khả năng cao hơn).

* Dự kiến ​​C ++ 17 sẽ bao gồm thay đổi quy tắc có nghĩa là điều này không còn không an toàn. Xem các giấy tờ của ủy ban C ++ P0400R0 và P0145R3 .

std::make_uniquevà std::make_sharedcó vì hai lý do:

1. Vì vậy, bạn không phải liệt kê rõ ràng các đối số kiểu mẫu.
2. An toàn ngoại lệ bổ sung đối với việc sử dụng std::unique_ptrhoặc std::shared_ptrxây dựng. (Xem phần Ghi chú tại đây .)

Nó không thực sự về hiệu quả thời gian chạy. Có một chút về khối điều khiển và Tđược phân bổ cùng một lúc, nhưng tôi nghĩ đó là phần thưởng nhiều hơn và ít động lực hơn cho các chức năng này tồn tại.

Một lý do tại sao bạn sẽ phải sử dụng std::unique_ptr(new A())hoặc std::shared_ptr(new A())trực tiếp thay vì std::make_*()không thể truy cập vào hàm tạo của lớp Angoài phạm vi hiện tại.

Xem xét chức năng gọi

void function(std::unique_ptr<A>(new A()), std::unique_ptr<B>(new B())) { ... }

Giả sử rằng mới A()thành công, nhưng mới B()ném một ngoại lệ: bạn bắt nó để tiếp tục thực hiện chương trình bình thường của bạn. Thật không may, tiêu chuẩn C ++ không yêu cầu đối tượng A bị phá hủy và bộ nhớ của nó bị giải phóng: bộ nhớ âm thầm bị rò rỉ và không có cách nào để dọn sạch nó. Bằng cách gói A và B vào std::make_uniquesbạn, chắc chắn rò rỉ sẽ không xảy ra:

void function(std::make_unique<A>(), std::make_unique<B>()) { ... }

Vấn đề ở đây là std::make_unique<A>và std::make_unique<B>bây giờ là các đối tượng tạm thời và việc dọn dẹp các đối tượng tạm thời được chỉ định chính xác trong tiêu chuẩn C ++: các hàm hủy của chúng sẽ được kích hoạt và giải phóng bộ nhớ. Vì vậy, nếu bạn có thể, luôn luôn thích phân bổ các đối tượng bằng cách sử dụng std::make_uniquevà std::make_shared.