C++学习之路： share_from_this<T>类的使用

引言： 当我们在类的内部需要定义一个指向 this 自身对象的 智能指针时， 会出现 两个同指向智能指针 分属两个系统的问题， 导致析构的时候 出现二次析构， 程序就会挂掉。

因为两个指针指向同一个对象，但是却不共享引用计数

那么在类内部如何获取 指向自身对象的 智能指针呢， 显式手动的获取很明显是错误的；

这时就需要在类 A 定义时继承一个 enable_share_from_this<A>  类即可

这样在类的内部就可以获取指向 自身的智能指针， 且影响其他智能指针的引用计数；

在类内部用 share_from_this() 获取智能指针可以 让类外部的 智能指针知道， 使其所有共对象的智能指针 共享计数，  文字描述十分绕， 我们看了代码就十分明了了；

1.举个例子，下面的代码在函数f内部通过this构造了shared_ptr对象，然后打印x_的值。

class B { 
public: 
    B(): x_(4) { 
        cout << "B::B()" << endl; 
    } 
     
    ~B() { 
        cout << "B::~B()" << endl; 
    } 
     
    void f() { 
        shared_ptr<B> p(this); //显式的 用this 初始化一个指向自身的智能指针， 外部的其他智能指针并不知情， 他们不共享引用计数。
        cout << p->x_ << endl; //
        //shared_from_this(); 
    } 
     
private: 
    int x_; 
}; 

以下是测试代码：

int main(int argc, char** argv) { 
    shared_ptr<B> x(new B);  //类外部的智能指针 不知情类内部有相同的指针
    x->f(); 
    return 0; 
} 

打印结果：

B::B() 
4 
B::~B() 
B::~B() 
//两次析构B对象，这是个灾难。

显然两个同指向的 智能指针如果不共享计数的话， 会引起两次析构的巨大灾难；  

 

2. enable_shared_from_this<T> 这个类就是专门为解决这个问题而产生的

注意继承时要 定义为 public，否则外部无法使用。

class A : public enable_shared_from_this<A> { 
public: 
    A() { 
        cout << "A::A()" << endl; 
    } 
     
    ~A() { 
        cout << "A::~A()" << endl; 
    } 
     
    void f() { 
        //cout << shared_from_this()->x_ << endl; // this way is okay too 
        shared_ptr<A> p = shared_from_this(); 
        cout << p->x_ << endl; 
    } 
     
private: 
    int x_; 
}; 

测试代码

int main(int argc, char** argv) { 
    shared_ptr<A> x(new A); 
    x->f(); 
    return 0; 
} 

打印结果

A::A() 
0 
A::~A() 
//只出现了一次析构

显然， 类内部的智能指针和 类外部的智能指针共享了 引用计数，  从析构角度来看， main函数结束  需要析构A智能指针，  则A调用自己的析构函数 去析构对象 ， 那么首先析构的是 对象中智能指针B，

B析构了后 引用计数-1， 然后main中的A指针析构完所持有的对象后，再自己