如何安全的抛出指向自己的指针

需求描述：有一个类，需要提供一个接口，这个接口需要将自己以指针的方式传出去。

方法1

class Bad
{
private:
	int *pa;
public:
	
	Bad(int n)
	{
		pa = new int(n);
	}
	~Bad()
	{
		std::cout << "Bad::~Bad() called" << std::endl;
		delete pa;
		pa = NULL;
		
	}
	Bad* getptr2()
	{
		return this;
	}
	void Test()
	{
		cout << "hello world! ";
		cout << *pa << endl;
	}

};

int main()
{
	Bad* bp3 = new Bad(100);
	Bad* bp4 = bp3->getptr2();
	delete bp4;
	bp3->Test();
	getchar();
	return 0;
}  

一个裸指针传递给调用者，谁也不知道调用者会干什么？假如调用者delete了该对象，如上述代码delete bp4;但是bp3仍然还要使用，则就会造成问题，结果如下：

方法2

你可能会想到使用智能指针，代码如下：

std::shared_ptr<Bad> getptr1() 
{
	return std::shared_ptr<Bad>(this);	
}

调用：

int main()
{
	{
	// 错误的示例，每个shared_ptr都认为自己是对象仅有的所有者
	std::shared_ptr<Bad> bp1(new Bad(10));
	std::shared_ptr<Bad> bp2 = bp1->getptr1();
	// 打印bp1和bp2的引用计数
	std::cout << "bp1.use_count() = " << bp1.use_count() << std::endl;
	std::cout << "bp2.use_count() = " << bp2.use_count() << std::endl;	
	}
	getchar();
	return 0;
}  // Bad 对象将会被删除两次

结果：

可以看到，对象只构造了一次，但却析构了两次。并且在增加一个指向的时候，shared_ptr的计数并没有增加。也就是说，这个时候，bp1和bp2都认为自己是Bad指针的唯一拥有者，这两个shared_ptr在计数为0的时候，都会调用一次Test对象的析构函数，所以会出问题。

那么为什么会这样呢？给一个shared_ptr传递一个this指针难道不能引起shared_ptr的计数吗？
答案是：对的，shared_ptr根本认不得你传进来的指针变量是不是之前已经传过。
下面给出经典解释：

void main()
{
	int* p = new int(10);
	shared_ptr<int> sp1(p);
	shared_ptr<int> sp2(p);
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	system("pause");
}

结果：

想必无需我再多说了吧。
那该如何做呢？

正确做法

enable_shared_from_this 是一个以其派生类为模板类型参数的基类模板，继承它，派生类的this指针就能变成一个 shared_ptr。
完整代码：

class Bad: public enable_shared_from_this<Bad>       //改进1
{
private:
	int *pa;
public:
	std::shared_ptr<Bad> getptr()
	{
		return shared_from_this();      //改进2
	}
	Bad(int n)
	{
		pa = new int(n);
	}
	~Bad()
	{
		std::cout << "Bad::~Bad() called" << std::endl;
		delete pa;
		pa = NULL;
		
	}
	
	void Test()
	{
		cout << "hello world! ";
		cout << *pa << endl;
	}

};

int main()
{
	{
	
	std::shared_ptr<Bad> bp1(new Bad(10));
	std::shared_ptr<Bad> bp2 = bp1->getptr();
	// 打印bp1和bp2的引用计数
	std::cout << "bp1.use_count() = " << bp1.use_count() << std::endl;
	std::cout << "bp2.use_count() = " << bp2.use_count() << std::endl;
	
	}
	system("pause");
	return 0;
}  // Bad 对象将会被删除两次

结果：

实现原理

enable_shared_from_this的一种实现方法是，其内部有一个weak_ptr类型的成员变量_Wptr，当shared_ptr构造的时候，如果其模板类型继承了enable_shared_from_this，则对_Wptr进行初始化操作，这样将来调用shared_from_this函数的时候，就能够通过weak_ptr构造出对应的shared_ptr。有兴趣的可以去看看源码，本人大概看了下代码，总结出了一些使用的注意的地方。shared_from_this()仅在shared_ptr的构造函数被调用之后才能使用，原因是enable_shared_from_this::_Wptr并不在构造函数中设置，而是在shared_ptr的构造函数中设置。
示例：

class Test :public enable_shared_from_this<Test>
{
public:
	void func()
	{
		shared_ptr<Test> pT = shared_from_this();
	}
};
void main()
{
	Test t;
	t.func();
}

结果：

注意：不要试图对一个没有被shared_ptr接管的类对象调用shared_from_this()，不然会产生未定义行为的错误，结果则是奔溃。
另外对于智能指针不熟悉的同学，可以看看我的另一篇文章C++11中SmartPointer详解，这一篇就够了