shared_from_this用法，以及shared_ptr陷阱

        c++11中的智能指针源于boost，所以也将 类enable_shared_from_this 和 及其成员函数shared_from_this()也给收编了。

        通过模板方式继承enable_shared_from_this<T> 然后调用shared_from_this()函数返回对象T的shared_ptr指针，非常方便。使用时需要引用头文件 ：#include <memory>

用例：

#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;
}

问题：为什么要这么麻烦，要继承一个继承enable_shared_from_this<T>模板对象，使用其中的成员函数shared_from_this(),直接使用：

shared_ptr<TestA> getSharedFromThis() { return  shared_ptr<TestA> (this); }

这样不好吗？

这样使用就是陷入shared_ptr使用的陷阱里了。我们可以写一个程序试试看：

#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内部生成一个计数器，当另外一个shared_ptr不用share_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);
	shared_ptr<int> ptr3;
	ptr3 = ptr1;

	shared_ptr<int> ptr4(ptr1.get());//ptr1.get()返回ptr1保存对象的裸指针,ptr4会有新的计数器，不跟ptr1,ptr2,ptr3共享计数器
	cout << ptr1.use_count() << " " << ptr2.use_count() << " "
		<< ptr3.use_count() << " " << ptr4.use_count() << endl;
	//所以一定不要既用shared_ptr又用对象裸指针（p.get()相当于裸指针）
	cin.get();
	return 0;
}