Tính hữu dụng của `enable_ Shared_from_this` là gì?

Tôi đã chạy qua enable_shared_from_thistrong khi đọc các ví dụ Boost.Asio và sau khi đọc tài liệu tôi vẫn không biết làm thế nào để sử dụng chính xác điều này. Ai đó có thể xin vui lòng cho tôi một ví dụ và giải thích khi sử dụng lớp này có ý nghĩa.

Nó cho phép bạn có được một shared_ptrví dụ hợp lệ this, khi tất cả những gì bạn có là this. Nếu không có nó, bạn sẽ không có cách nào nhận được một shared_ptrđến this, trừ khi bạn đã có một là một thành viên. Ví dụ này từ tài liệu tăng cường cho enable_ Shared_from_this :

class Y: public enable_shared_from_this<Y>
{
public:

    shared_ptr<Y> f()
    {
        return shared_from_this();
    }
}

int main()
{
    shared_ptr<Y> p(new Y);
    shared_ptr<Y> q = p->f();
    assert(p == q);
    assert(!(p < q || q < p)); // p and q must share ownership
}

Phương thức f()trả về một giá trị hợp lệ shared_ptr, mặc dù nó không có cá thể thành viên. Lưu ý rằng bạn không thể đơn giản làm điều này:

class Y: public enable_shared_from_this<Y>
{
public:

    shared_ptr<Y> f()
    {
        return shared_ptr<Y>(this);
    }
}

Con trỏ được chia sẻ mà con số này trả về sẽ có số tham chiếu khác với con trỏ "thích hợp" và một trong số chúng sẽ bị mất và giữ tham chiếu lơ lửng khi đối tượng bị xóa.

enable_shared_from_thisđã trở thành một phần của tiêu chuẩn C ++ 11. Bạn cũng có thể lấy nó từ đó cũng như từ boost.

từ bài viết của Tiến sĩ Dobbs về con trỏ yếu, tôi nghĩ ví dụ này dễ hiểu hơn (nguồn: http://drdobbs.com/cpp/184402026 ):

... mã như thế này sẽ không hoạt động chính xác:

int *ip = new int;
shared_ptr<int> sp1(ip);
shared_ptr<int> sp2(ip);

Cả hai shared_ptrđối tượng đều không biết về đối tượng kia, vì vậy cả hai sẽ cố gắng giải phóng tài nguyên khi chúng bị phá hủy. Điều đó thường dẫn đến các vấn đề.

Tương tự, nếu một hàm thành viên cần một shared_ptrđối tượng sở hữu đối tượng mà nó được gọi, nó không thể tạo một đối tượng một cách nhanh chóng:

struct S
{
  shared_ptr<S> dangerous()
  {
     return shared_ptr<S>(this);   // don't do this!
  }
};

int main()
{
   shared_ptr<S> sp1(new S);
   shared_ptr<S> sp2 = sp1->dangerous();
   return 0;
}

Mã này có cùng một vấn đề như ví dụ trước, mặc dù ở dạng tinh tế hơn. Khi nó được xây dựng, shared_ptđối tượng r sp1sở hữu tài nguyên mới được phân bổ. Mã bên trong hàm thành viên S::dangerouskhông biết về shared_ptrđối tượng đó , vì vậy shared_ptrđối tượng mà nó trả về khác với sp1. Sao chép shared_ptrđối tượng mới để sp2không giúp đỡ; khi sp2đi ra khỏi phạm vi, nó sẽ giải phóng tài nguyên và khi sp1đi ra khỏi phạm vi, nó sẽ giải phóng tài nguyên một lần nữa.

Cách để tránh vấn đề này là sử dụng mẫu lớp enable_shared_from_this. Mẫu lấy một đối số kiểu mẫu, là tên của lớp xác định tài nguyên được quản lý. Đến lượt, lớp đó phải được xuất phát công khai từ mẫu; như thế này:

struct S : enable_shared_from_this<S>
{
  shared_ptr<S> not_dangerous()
  {
    return shared_from_this();
  }
};

int main()
{
   shared_ptr<S> sp1(new S);
   shared_ptr<S> sp2 = sp1->not_dangerous();
   return 0;
}

Khi bạn làm điều này, hãy nhớ rằng đối tượng mà bạn gọi shared_from_thisphải được sở hữu bởi một shared_ptrđối tượng. Điều này sẽ không hoạt động:

int main()
{
   S *p = new S;
   shared_ptr<S> sp2 = p->not_dangerous();     // don't do this
}

Đây là lời giải thích của tôi, từ góc độ các loại hạt và bu lông (câu trả lời hàng đầu không 'nhấp chuột' với tôi). * Lưu ý rằng đây là kết quả của việc điều tra nguồn cho shared_ptr và enable_ Shared_from_this đi kèm với Visual Studio 2012. Có lẽ các trình biên dịch khác triển khai enable_spl_from_this khác nhau ... *

enable_shared_from_this<T>thêm một weak_ptr<T>ví dụ riêng Tchứa ' một số tham chiếu thực ' cho ví dụ của T.

Vì vậy, khi bạn lần đầu tiên tạo một shared_ptr<T>T * mới, điểm yếu bên trong của T * sẽ được khởi tạo với số lần truy cập là 1. Cơ shared_ptrbản mới dựa vào điều nàyweak_ptr .

Tsau đó, trong các phương thức của nó, có thể gọi shared_from_thisđể lấy một thể hiện của các sao lưushared_ptr<T> đó vào cùng một số tham chiếu được lưu trữ bên trong . Theo cách này, bạn luôn có một nơi T*lưu trữ số lần giới thiệu thay vì có nhiều shared_ptrtrường hợp không biết về nhau và mỗi người nghĩ rằng họ là người shared_ptrchịu trách nhiệm đếm Tvà xóa nó khi họ tham gia -count đạt đến không.

Lưu ý rằng việc sử dụng boost :: intrusive_ptr không gặp phải vấn đề này. Đây thường là một cách thuận tiện hơn để khắc phục vấn đề này.

Nó giống hệt nhau trong c ++ 11 trở lên: Đó là cho phép khả năng quay trở lại thisnhư một con trỏ dùng chung vì thiscung cấp cho bạn một con trỏ thô.

nói cách khác, nó cho phép bạn biến mã như thế này

class Node {
public:
    Node* getParent const() {
        if (m_parent) {
            return m_parent;
        } else {
            return this;
        }
    }

private:

    Node * m_parent = nullptr;
};           

vào đây:

class Node : std::enable_shared_from_this<Node> {
public:
    std::shared_ptr<Node> getParent const() {
        std::shared_ptr<Node> parent = m_parent.lock();
        if (parent) {
            return parent;
        } else {
            return shared_from_this();
        }
    }

private:

    std::weak_ptr<Node> m_parent;
};           

Một cách khác là thêm một weak_ptr<Y> m_stubthành viên vào class Y. Sau đó viết:

shared_ptr<Y> Y::f()
{
    return m_stub.lock();
}

Hữu ích khi bạn không thể thay đổi lớp bạn đang bắt nguồn (ví dụ: mở rộng thư viện của người khác). Đừng quên khởi tạo thành viên, ví dụ: m_stub = shared_ptr<Y>(this)nó có hiệu lực ngay cả trong khi xây dựng.

Sẽ ổn nếu có nhiều sơ khai như thế này trong hệ thống phân cấp thừa kế, nó sẽ không ngăn chặn sự phá hủy của đối tượng.

Chỉnh sửa: Như được chỉ định chính xác bởi nobar người dùng, mã sẽ phá hủy đối tượng Y khi quá trình gán kết thúc và các biến tạm thời bị hủy. Do đó, câu trả lời của tôi là không chính xác.