enable_shared_from_this模板类使用完全解析
作者：hahaya
日期：
以前都没有用过enable_shared_from_this模板类，虽然经常遇到但是也没怎么去关注，今天抽时间好好学习了下enable_shared_from_this模板类，发现在使用shared_ptr模板类和enable_shared_from_this模板类时有许多陷阱的，故记录于此。
什么时候该使用enable_shared_from_this模板类
在看下面的例子之前，简单说下使用背景，单有一个类，某个函数需要返回当前对象的指针，我们返回的是shared_ptr
#include <iostream>
#include <boost/shared_ptr.hpp>
class Test
{
public:
//析构函数
~Test() { std::cout << "Test Destructor." << std::endl; }
//获取指向当前对象的指针
boost::shared_ptr<Test> GetObject()
{
boost::shared_ptr<Test> pTest(this);
return pTest;
}
};
int main(int argc, char *argv[])
{
{
boost::shared_ptr<Test> p( new Test( ));
boost::shared_ptr<Test> q = p->GetObject();
}
return 0;
}程序输出：
Test Destructor.
Test Destructor.
从上面的输出你发现了什么，很明显的发现只创建new了一个Test对象，但是却调用了两次析构函数，这对程序来说肯定是一个灾难。为什么会出现这种情况呢？main函数中的boost::shared_ptr<Test> p( new Test( ));将shared_ptr
#include <iostream>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
class Test : public boost::enable_shared_from_this<Test> //改进1
{
public:
//析构函数
~Test() { std::cout << "Test Destructor." << std::endl; }
//获取指向当前对象的指针
boost::shared_ptr<Test> GetObject()
{
return shared_from_this(); //改进2
}
};
int main(int argc, char *argv[])
{
{
boost::shared_ptr<Test> p( new Test( ));
boost::shared_ptr<Test> q = p->GetObject();
}
return 0;
}程序输出：
Test Destructor.
从输出对象只被析构了一次，这是我们想要的结果，因此enable_shared_from_this
enable_shared_from_this模板类实现
打开enable_shared_from_this.hpp文件，会发现enable_shared_from_this
template<class T> class enable_shared_from_this
{
protected:
enable_shared_from_this() BOOST_NOEXCEPT
{
}
enable_shared_from_this(enable_shared_from_this const &) BOOST_NOEXCEPT
{
}
enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_NOEXCEPT
{
return *this;
}
~enable_shared_from_this() BOOST_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
{
}
public:
shared_ptr<T> shared_from_this()
{
shared_ptr<T> p( weak_this_ );
BOOST_ASSERT( p.get() == this );
return p;
}
shared_ptr<T const> shared_from_this() const
{
shared_ptr<T const> p( weak_this_ );
BOOST_ASSERT( p.get() == this );
return p;
}
public: // actually private, but avoids compiler template friendship issues
// Note: invoked automatically by shared_ptr; do not call
template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
{
if( weak_this_.expired() )
{
weak_this_ = shared_ptr<T>( *ppx, py );
}
}
private:
mutable weak_ptr<T> weak_this_;
};从enable_shared_from_this
使用enable_shared_from_this常见错误
先来看情形1：
class Test : public boost::enable_shared_from_this<Test>
{
Test() { boost::shared_ptr<Test> pTest = shared_from_this(); }
};这种用法明显是错的，虽然对象的基类enable_shared_from_this
接着我们来看情形2：
class Test : public boost::enable_shared_from_this<Test>
{
void func() { boost::shared_ptr<Test> pTest = shared_from_this(); }
};
int main()
{
Test test;
test.func(); //错误
Test pTest = new Test;
pTest->func(); //错误
}同样这种做法也是错误的，和情形1同样的原因shared_ptr
正确的做法应该是：
class Test : public boost::enable_shared_from_this<Test>
{
void func() { boost::shared_ptr<Test> pTest = shared_from_this(); }
};
int main()
{
shared_ptr<Test> pTest( new Test() );
pTest->func();
}shared_ptr<Test> pTest( new Test() );这句话依次执行的顺序是：1 调用enable_shared_from_this
从上面的错误中我们知道在使用enable_shared_from_this
- 不能在对象的构造函数中使用shared_from_this()函数。
- 先需要调用enable_shared_from_this
类的构造函数，接着调用对象的构造函数，最后需要调用shared_ptr 类的构造函数初始化enable_shared_from_this 的成员变量weak_this_。然后才能使用shared_from_this()函数。 - 如何程序中使用了智能指针shared_ptr
,则程序中统一使用智能指针，不能使用原始指针，以免出现错误。
出处：http://hahaya.github.com/use-enable-shared-from-this
本文版权归作者所有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接。