Tại sao unique_ptr không thể suy ra loại deleter?

Question

Hãy nói rằng tôi muốn sử dụng một deleter tuỳ chỉnh với một unique_ptr:

void custom_deleter(int* obj) 
{ 
    delete obj; 
} 

Tại sao tôi phải viết này:

std::unique_ptr<int, void(*)(int*)> x(new int, custom_deleter); 

thay vì điều này:

std::unique_ptr<int> x(new int, custom_deleter); //does not compile 

?

Không thể suy ra loại suy luận?

Answer 1

Đối unique_ptr, các deleter là một phần của các loại:

template < 
    class T, 
    class Deleter = std::default_delete<T> 
> class unique_ptr; 

Như vậy, khi bạn đang xây dựng một đối tượng, bạn cần phải xác định loại của nó. Điểm mấu bạn đang viết:

std::unique_ptr<int> x(new int, custom_deleter); 

tương đương với:

std::unique_ptr<int, std::default_delete<int> > x(new int, custom_deleter); 

Và bạn không thể xây dựng một std::default_delete<int> từ custom_deleter.

Cách duy nhất để suy luận loại deleter là sử dụng mẫu khấu trừ vào phần đó quá:

template <typename T, typename Deleter> 
std::unique_ptr<T, Deleter> make_unique_ptr(T* ptr, Deleter deleter) { 
    return std::unique_ptr<T, Deleter>(ptr, deleter); 
} 

Answer 2

Nó không thể suy ra các loại của deleter, vì unique_ptr theo mặc định không có nhà nước dành cho một deleter: deleter mặc định là không trạng thái.

Trong trường hợp của bạn, dấu phân cách cần giá trị của con trỏ, vì vậy nó không thể 'vừa' trong trạng thái của std::unique_ptr (chỉ là con trỏ đến số T).

Điều này làm cho unique_ptr thay thế nhẹ, gần như miễn phí cho một con trỏ sở hữu.

Deductin có thể được thực hiện, nhưng nó sẽ phải thay đổi loại kết quả unique_ptr.

Khi so sánh, shared_ptr luôn có khả năng trạng thái cho một dấu phân cách, hai bộ đếm nguyên tử khác nhau và một con trỏ tới giá trị. Đó là trọng lượng nặng hơn, và không phải là một thay thế miễn phí cho một con trỏ.