C++的enable_shared_from_this

一、问题

裸指针与智能指针混用，请看这个例子——代码1

 class A
 {
 public:
	 A() :mptr(new int)
	 {
		 cout << "A()" << endl;
	 }
	 ~A()
	 {
		 cout << "~A()" << endl;
		 delete mptr;
		 mptr = nullptr;
	 }
 private:
	 int *mptr{nullptr};
 };

 int main()
 {
	 A *p = new A(); // 裸指针,指向堆上的对象

	 shared_ptr<A> ptr1(p);// 用shared_ptr智能指针管理指针p指向的对象
	 shared_ptr<A> ptr2(p);// 用shared_ptr智能指针管理指针p指向的对象
	 // 下面两次打印都是1，因此同一个new A()被析构两次，逻辑错误
	 cout << ptr1.use_count() << endl;
	 cout << ptr2.use_count() << endl;
     return 0；
}

输出

同时会报错

main函数中，虽然用了两个智能指针shared_ptr，但是它们管理的都是同一个资源，导致出main函数把A对象析构了两次。

另一个例子——代码2，如果我们给A类提供了一个成员方法，返回指向自身对象的shared_ptr智能指针，能否正确执行？

 class A
 {
 public:
	 A() :mptr(new int)
	 {
		 cout << "A()" << endl;
	 }
	 ~A()
	 {
		 cout << "~A()" << endl;
		 delete mptr;
		 mptr = nullptr;
	 }

	 // A类提供了一个成员方法，返回指向自身对象的shared_ptr智能指针。
	 shared_ptr<A> getSharedPtr()
	 {
		 /*注意：不能直接返回this，在多线程环境下，根本无法获知this指针指向
		 的对象的生存状态，通过shared_ptr和weak_ptr可以解决多线程访问共享
		 对象的线程安全问题*/
		 return shared_ptr<A>(this);
	 }
 private:
	 int *mptr{nullptr};
 };

 int main()
 {
	 A *p = new A(); // 裸指针,指向堆上的对象

	 shared_ptr<A> ptr1(p);
	 shared_ptr<A> ptr2 = ptr1->getSharedPtr();

	 // 下面两次打印都是1，然而同一个new A()被析构两次，逻辑错误
	 cout << ptr1.use_count() << endl;
	 cout << ptr2.use_count() << endl;
     return 0
}

同样，也是

二、原因

从我的博客中可以看到，智能指针只有在拷贝构造函数与Operator=时，引用计数才加1。如果直接使用因为shared_ptr ptr1( p )和shared_ptr ptr2( p )，则是调用了shared_ptr的构造函数。在它的构造函数中，都重新定义了引用计数这个成员变量，所以每个智能指针对象的引用计数都是1，导致原对象被析构两次。

三、解决方案

对于代码1，使用拷贝构造函数就好了

int main()
{
	A *p = new A(); // 裸指针指向堆上的对象

	shared_ptr<A> ptr1(p);// 用shared_ptr智能指针管理指针p指向的对象

	shared_ptr<A> ptr2(ptr1);// 用ptr1拷贝构造ptr2

	// 下面两次打印都是2，最终随着ptr1和ptr2析构，资源只释放一次，正确！
	cout << ptr1.use_count() << endl; 
	cout << ptr2.use_count() << endl;

	return 0;
}

对于代码2，使用 enable_shared_from_this和shared_from_this

首先肯定不能像上面代码清单2那样写return shared_ptr< A > ( this ) ，这会调用shared_ptr智能指针的构造函数，对this指针指向的对象，又建立了一份引用计数对象，加上main函数中的shared_ptr< A > ptr1(new A());已经对这个A对象建立的引用计数对象，又成了两个引用计数对象，对同一个资源都记录了引用计数，为1，最终两次析构对象释放内存，错误！

那如果一个类要提供一个函数接口，返回一个指向当前对象的shared_ptr智能指针怎么办？方法就是继承enable_shared_from_this类，然后通过调用从基类继承来的shared_from_this()方法返回指向同一个资源对象的智能指针shared_ptr。

 // 智能指针测试类，继承enable_shared_from_this类
 class A : public enable_shared_from_this<A>
 {
 public:
	 A() :mptr(new int)
	 {
		 cout << "A()" << endl;
	 }
	 ~A()
	 {
		 cout << "~A()" << endl;
		 delete mptr;
		 mptr = nullptr;
	 }

	 // A类提供了一个成员方法，返回指向自身对象的shared_ptr智能指针
	 shared_ptr<A> getSharedPtr()
	 {
		 /*通过调用基类的shared_from_this方法得到一个指向当前对象的
		 智能指针*/
		 return shared_from_this();
	 }
 private:
	 int *mptr;
 };

 输出正常

四、enable_shared_from_this的原理

一个类继承enable_shared_from_this会怎么样？看看enable_shared_from_this基类的成员变量有什么，如下：

template<class _Ty>
	class enable_shared_from_this
	{	// provide member functions that create shared_ptr to this
public:
	using _Esft_type = enable_shared_from_this;

	_NODISCARD shared_ptr<_Ty> shared_from_this()
		{	// return shared_ptr
		return (shared_ptr<_Ty>(_Wptr));
		}
	// 成员变量是一个指向资源的弱智能指针
	mutable weak_ptr<_Ty> _Wptr;
};

原来是使用了weak_ptr，对于weak_ptr，请见weak_ptr的使用。

也就是说，如果一个类继承了enable_shared_from_this，那么它产生的对象就会从基类enable_shared_from_this继承一个成员变量_Wptr，当定义第一个智能指针对象的时候shared_ptr< A > ptr1(new A())，调用shared_ptr的普通构造函数，就会初始化A对象的成员变量_Wptr，作为观察A对象资源的一个弱智能指针观察者。

参考：

C++智能指针的enable_shared_from_this和shared_from_this机制_大秦坑王的博客-CSDN博客

C++11新特性之十：enable_shared_from_this_草上爬的博客-CSDN博客