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 指向同一资源，但管理引用计数资源的方式却不一样。
下面例子有什么问题？
#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时，又一次生成一个计数器，两个计数器不共享。
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;
}
授之以鱼不如授之以渔！！
如果大家喜欢，请三连！！！！！！！！！！！