Là một deleter của shared_ptr được lưu trữ trong bộ nhớ được cấp phát bởi bộ cấp phát tùy chỉnh?

Nói rằng tôi có một shared_ptrvới một cấp phát tùy chỉnh và một deleter tùy chỉnh.

Tôi không thể tìm thấy bất cứ điều gì trong tiêu chuẩn nói về nơi lưu trữ của deleter: nó không nói rằng bộ cấp phát tùy chỉnh sẽ được sử dụng cho bộ nhớ của deleter và nó không nói rằng nó sẽ không tồn tại.

Đây có phải là không xác định hoặc tôi chỉ thiếu một cái gì đó?

hồn.smartptr. Shared.const / 9 trong C ++ 11:

Hiệu ứng: Xây dựng một đối tượng shared_ptr sở hữu đối tượng p và deleter d. Các constructor thứ hai và thứ tư sẽ sử dụng một bản sao của một bộ nhớ để phân bổ bộ nhớ cho sử dụng nội bộ.

Các constructor thứ hai và thứ tư có các nguyên mẫu này:

template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
template<class D, class A> shared_ptr(nullptr_t p, D d, A a);

Trong dự thảo mới nhất, produc.smartptr. Shared.const / 10 tương đương với mục đích của chúng tôi:

Hiệu ứng: Xây dựng một đối tượng shared_ptr sở hữu đối tượng p và deleter d. Khi T không phải là kiểu mảng, các hàm tạo thứ nhất và thứ hai cho phép shared_from_this với p. Các constructor thứ hai và thứ tư sẽ sử dụng một bản sao của một bộ nhớ để phân bổ bộ nhớ cho sử dụng nội bộ. Nếu một ngoại lệ được ném, d (p) được gọi.

Vì vậy, bộ cấp phát được sử dụng nếu có nhu cầu phân bổ nó trong bộ nhớ được phân bổ. Dựa trên tiêu chuẩn hiện tại và tại các báo cáo khiếm khuyết có liên quan, việc phân bổ không bắt buộc mà do ủy ban đảm nhận.

• Mặc dù giao diện shared_ptrcho phép thực hiện trong đó không bao giờ có khối điều khiển và tất cả shared_ptrvà weak_ptrđược đưa vào danh sách được liên kết, nhưng thực tế không có triển khai như vậy. Ngoài ra, ví dụ, từ ngữ đã được sửa đổi, giả sử rằng từ use_countđược chia sẻ.

• Deleter được yêu cầu chỉ di chuyển có thể xây dựng. Vì vậy, không thể có một vài bản sao trong shared_ptr.

Người ta có thể tưởng tượng một triển khai đưa deleter vào một thiết kế đặc biệt shared_ptrvà di chuyển nó khi nó đặc biệt shared_ptrbị xóa. Mặc dù việc triển khai có vẻ phù hợp, nhưng điều này cũng lạ, đặc biệt là vì khối điều khiển có thể cần thiết cho số lượng sử dụng (có lẽ có thể nhưng thậm chí còn lạ hơn khi làm điều tương tự với số lượng sử dụng).

Các DR có liên quan tôi đã tìm thấy: 545 , 575 , 2434 (thừa nhận rằng tất cả các triển khai đang sử dụng một khối điều khiển và dường như ngụ ý rằng các ràng buộc đa luồng phần nào bắt buộc nó), 2802 (yêu cầu rằng deleter chỉ di chuyển có thể xây dựng được và do đó ngăn cản việc thực hiện deleter được sao chép giữa một số shared_ptr).

Từ std :: shared_ptr chúng ta có:

Khối điều khiển là một đối tượng được phân bổ động giữ:

• hoặc là một con trỏ tới đối tượng được quản lý hoặc chính đối tượng được quản lý;
• deleter (loại bị xóa);
• bộ cấp phát (loại bị xóa);
• số lượng shared_ptrs sở hữu đối tượng được quản lý;
• số lượng yếu_ptrs đề cập đến đối tượng được quản lý.

Và từ std :: allocate_ Shared chúng tôi nhận được:

template< class T, class Alloc, class... Args >
shared_ptr<T> allocate_shared( const Alloc& alloc, Args&&... args );

Xây dựng một đối tượng loại T và bọc nó trong std :: shared_ptr [...] để sử dụng một cấp phát cho cả khối điều khiển của con trỏ dùng chung và đối tượng T.

Vì vậy, có vẻ như std :: allocate_ Shared sẽ phân bổ deletervới của bạn Alloc.

EDIT: Và từ n4810§20.11.3.6 Tạo [produc.smartptr. Shared.create]

1 Các yêu cầu chung áp dụng cho tất cả make_shared, allocate_shared, make_shared_default_init, và allocate_shared_default_initquá tải, trừ khi có quy định khác, được mô tả dưới đây.

[...]

7 Lưu ý: (7.1) - Việc triển khai sẽ thực hiện không quá một cấp phát bộ nhớ. [Lưu ý: Điều này cung cấp hiệu quả tương đương với một con trỏ thông minh xâm nhập. Lưu ý

[Nhấn mạnh tất cả của tôi]

Vì vậy, tiêu chuẩn đang nói rằng std::allocate_shared nên sử dụng Alloccho khối điều khiển.

Tôi tin rằng điều này là không xác định.

Đây là đặc điểm kỹ thuật của các nhà xây dựng có liên quan: [produc.smartptr. Shared.const] / 10

template<class Y, class D> shared_ptr(Y* p, D d);
template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
template <class D> shared_ptr(nullptr_t p, D d);
template <class D, class A> shared_ptr(nullptr_t p, D d, A a);

Tác dụng: Xây dựng một shared_­ptrđối tượng sở hữu đối tượng pvà deleter d. Khi Tkhông phải là một kiểu mảng, các hàm tạo thứ nhất và thứ hai cho phép shared_­from_­thisvới p. Các nhà xây dựng thứ hai và thứ tư sẽ sử dụng một bản sao ađể phân bổ bộ nhớ cho sử dụng nội bộ . Nếu một ngoại lệ được ném, d(p)được gọi.

Bây giờ, giải thích của tôi là khi thực hiện cần bộ nhớ để sử dụng nội bộ, nó sẽ làm như vậy bằng cách sử dụng a. Điều đó không có nghĩa là việc triển khai phải sử dụng bộ nhớ này để đặt mọi thứ. Ví dụ: giả sử có triển khai kỳ lạ này:

template <typename T>
class shared_ptr : /* ... */ {
    // ...
    std::aligned_storage<16> _Small_deleter;
    // ...
public:
    // ...
    template <class _D, class _A>
    shared_ptr(nullptr_t, _D __d, _A __a) // for example
        : _Allocator_base{__a}
    {
        if constexpr (sizeof(_D) <= 16)
            _Construct_at(&_Small_deleter, std::move(__d));
        else
            // use 'a' to allocate storage for the deleter
    }
// ...
};

Việc triển khai này có "sử dụng một bản sao ađể phân bổ bộ nhớ cho sử dụng nội bộ" không? Vâng, nó làm. Nó không bao giờ phân bổ bộ nhớ ngoại trừ bằng cách sử dụng a. Có nhiều vấn đề với việc triển khai ngây thơ này, nhưng chúng ta hãy nói rằng nó chuyển sang sử dụng bộ cấp phát trừ trường hợp đơn giản nhất shared_ptrđược xây dựng trực tiếp từ một con trỏ và không bao giờ được sao chép hoặc di chuyển hoặc được tham chiếu theo cách khác và không có biến chứng nào khác. Vấn đề là, chỉ vì chúng ta không tưởng tượng ra một triển khai hợp lệ không tự nó chứng minh rằng nó không thể tồn tại trên lý thuyết. Tôi không nói rằng việc thực hiện như vậy thực sự có thể được tìm thấy trong thế giới thực, chỉ là tiêu chuẩn dường như không chủ động cấm nó.