C++之shared_from_this用法以及类自引用this指针陷阱

C++系列文章目录

---

---

前言

shared_ptr实现原理
shared_ptr 从 _Ptr_base 继承了 element_type 和 _Ref_count_base 类型的两个成员变量。

template<class _Ty>class _Ptr_base
{ 
private: 
        element_type * _Ptr{
            ptr
        }; // 指向资源的指针 
        _Ref_count_base * _Rep{
            ptr
        }; // 指向资源引用计数的指针
};

_Ref_count_base 中定义了原子类型的变量 _Uses 和 _Weaks，它们分别记录资源的引用个数和资源观察者的个数。

class __declspec(novtable) _Ref_count_base
{ 
    private:
         _Atomic_counter_t _Uses;//记录资源引用个数 
         _Atomic_counter_t _Weaks;//记录观察者个数
}

当要使用 shared_ptr 管理同一资源，调用 shared_ptr 的构造函数和拷贝构造函数是不一样的，它们虽然使得不同 shared_ptr 指向同一资源，但管理引用计数资源的方式却不一样。

---

一、为什么需要enable_shared_from_this

下面例子有什么问题？

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <memory>
using namespace std;
 
int main(){
	shared_ptr<int> ptr1(new int(101)); 
	shared_ptr<int> ptr2(ptr1.get());//ptr1.get()返回ptr1保存对象的裸指针,ptr2会有新的计数器，不跟ptr1共享计数器
	cout << ptr1.use_count() << " " << ptr2.use_count() << " " << endl;
	//所以一定不要既用shared_ptr又用对象裸指针（p.get()相当于裸指针）即输出1 1
	cin.get();
	return 0;
}

通过上面的例子发现引用计数各自维护的是1，当两个对象ptr1、ptr2释放的时候会调用两次释放资源。

下面的例子是智能指针的正确用法：

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <memory>
using namespace std;
 
int main(){
	shared_ptr<int> ptr1(new int(101)); 
	shared_ptr<int> ptr2(ptr1);              //ptr1与ptr2共享引用技术2
	cout << ptr1.use_count() << " " << ptr2.use_count() << " " << endl;
	cin.get();
	return 0;
}

有时候自定义的类对象，需要自己引用计数，std::shared_ptr< T > (this),此时对象的引用计数也是各自维护一个计数1，因此是错误的用法，为了解决这个问题，引出来了 enable_shared_from_this。即当如果出现两个shared_ptr指针都指向同一对象，但是计数器不共享时，会导致对象被释放两次，程序出错了，就如同上面的例子。

为什么需要enable_shared_from_this
问题：为什么要这么麻烦，要继承一个继承enable_shared_from_this< T >模板对象，使用其中的成员函数shared_from_this(),直接使用：std::shared_ptr< TestA > getSharedFromThis() { return std::shared_ptr< TestA > (this); }

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <memory>
 
using namespace std;
 
class TestB
{
public:
	TestB(){
		cout << "TestB create" << endl;
	}
	~TestB(){
		cout << "TestB destory" << endl;
	}
	shared_ptr<TestB> getSharedFromThis() { 
		return  shared_ptr<TestB> (this); 
	}
};
int main(){
	{
		shared_ptr<TestB> ptr3(new TestB());
		shared_ptr<TestB> ptr4 = ptr3->getSharedFromThis();
		cout << "ptr2 count: " << ptr3.use_count() << " ptr4 count: " << ptr4.use_count() << endl;
		//输出：ptr2 count: 1 ptr4 count: 1 然后会崩溃因为重复释放
	}
	cin.get();
	return 0;
}

两个shared_ptr的引用计数都是1，然后释放时，导致对象被释放两遍，导致程序崩溃。
为什么会这样，要从shared_ptr的原理说起；shared_ptr为什么能够在没有shared_ptr指针指向对象时释放对象？
因为所有指向同一个对象的shared_ptr指针共享同一个计数器，当有新的shared_ptr指向对象时，计数器+1，有shared_ptr销毁或者不再指向该对象时,计数器-1，当计数器为0时，对象被销毁。

如何会导致shared_ptr指向同一个对象，但是不共享引用计数器。是因为裸指针与shared_ptr混用，如果我们用一个裸指针初始化或者赋值给shared_ptr指针时，在shared_ptr内部生成一个计数器，当另外一个shared_ptr不用share_ptr赋值或者初始化的话，再次将一个裸指针赋值给另外一个shared_ptr时，又一次生成一个计数器，两个计数器不共享。

二、enable_shared_from_this用法

c++11中的智能指针源于boost，所以也将enable_shared_from_this和其成员函数shared_from_this()也给收编了。通过模板方式继承enable_shared_from_this ，然后调用shared_from_this()函数返回对象T的shared_ptr指针，非常方便。
使用时需要引用头文件 ：#include < memory >

enable_shared_from_this例子

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <memory>
using namespace std;
class TestA : public enable_shared_from_this<TestA>
{
public:
	TestA(){
		cout << "TestA create" << endl;
	}
	~TestA(){
		cout << "TesA destory" << endl;
	}
	shared_ptr<TestA> getSharedFromThis() { 
		return shared_from_this(); 
	}
};
 
int main(){
	{//出了此作用域 ptr1 ptr2 销毁， TestA对象销毁
		shared_ptr<TestA> ptr1(new TestA());
		shared_ptr<TestA> ptr2 = ptr1->getSharedFromThis();
		cout << "ptr1 count: " << ptr1.use_count() << " ptr2 count: " << ptr2.use_count() << endl;
		//输出：ptr1 count: 2 ptr2 count: 2  可以正常释放对象
	}
	return 0;
}

总结

授之以鱼不如授之以渔！！
如果大家喜欢，请三连！！！！！！！！！！！