boost.enable_shared_from_this和boost.shared_ptr的使用

Jack

boost.enable_shared_from_this结合boost.shared_ptr似乎非常完美, 其实不然,
使用它还是需要注意很多地方, 如果不注意, 那也将会导致致命性的错误.

1. 首先enable_shared_from_this不能在构造函数中使用.

show code:

2. class tester
3.     : public boost::enable_shared_from_this<tester>
4. {
5. public:
6.     tester()
7.     {
8.         boost::shared_ptr<tester> sp = shared_from_this(); // 错误的使用!!!
9.     }
10. };

复制代码

2. 析构函数执行时, 析构函数内部不能调用shared_from_this(); 并且其它线程也不能再使用shared_from_this();

show code

2. class tester
3.     : public boost::enable_shared_from_this<tester>
4. {
5. public:
6.     tester()
7.     {
8.         // boost::shared_ptr<tester> sp = shared_from_this(); // 错误的使用!!!
9.     }
11.     ~tester()
12.     {
13.         Sleep(0xFFFFFFFF); // 析构一直不退出.
14.     }
16.     void start()
17.     {
18.         boost::shared_ptr<tester> ts;
19.         boost::thread t1(boost::bind(&tester::operation, this, boost::ref(ts)));
20.     }
22.     void operation(boost::shared_ptr<tester>& sp)
23.     {
24.         for (;;)
25.         {
26.             // 线程中使用shared_from_this()!!!
27.             // 当这个对象的生命期到了结束时(还未结束),
28.             // 执行析构函数时, 这里将导致错误!!!
29.             // 也就是说, 只要对象执行到析构函数, 无论如何
30.             // 都不能再调用这个对象的shared_from_this!
31.             sp = shared_from_this();
32.             Sleep(100);
33.         }
34.     }
35. };
37. int main(int argc, char* argv[])
38. {
39.     boost::shared_ptr<tester> sp(new tester);
40.     sp->start();
41.     return 0;
42. }

复制代码

还有好几种情况, 有空全部总结下, 并把原因也列出来.

总之如果实在难以把握的话, 又要把在中间this一样的智能指针的时候, 还是使用boost.intrusive_ptr吧, 还有就是COM指针也可以boost.intrusive_ptr来包装，或者也可以使用shared_ptr直接如下：

show code:

2. template <class _RawComPtr>
3. boost::shared_ptr<_RawComPtr> make_shared_from_COM(_RawComPtr * p)
4. {
5.     p->AddRef();
6.     boost::shared_ptr<_RawComPtr> pw(p, boost::mem_fn(&_RawComPtr::Release));
7.     return pw;
8. }

复制代码

这样写成一个模板，似乎也是很不错的做法。类似的包装像FILE*这样的也非常方便，如：

show code:

2. boost::shared_ptr<FILE> spfile(fopen("c:\\test.dat", "w+b"), fclose);
3. // 写时可以：
4. fwrite(buf, n, n, >(*spfile));
5. // 或:
6. fwrite(buf, n, n, spfile.get());
7. // 这样就会当智能指针撤消时，自动fclose掉这个文件。当然也可以写删除器来完成。不过最简单就简单些吧。

复制代码

另外，更值得推荐的就是使用它来做"Pimpl",这种做法在许多的质量比较高的开源库里广泛使用，如libtorrent等...类似的代码像：
show code:

2. // file.hpp:
3. class file
4. {
5. private:
7.     class impl;
8.     shared_ptr<impl> pimpl_;
10. public:
12.     file(char const * name, char const * mode);
14.     // compiler generated members are fine and useful
16.     void read(void * data, size_t size);
17. };
18. // file.cpp:
20. #include "file.hpp"
22. class file::impl
23. {
24. private:
26.     impl(impl const >);
27.     impl > operator=(impl const >);
29.     // private data
31. public:
33.     impl(char const * name, char const * mode) { ... }
34.     ~impl() { ... }
35.     void read(void * data, size_t size) { ... }
36. };
38. file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
39. {
40. }
42. void file::read(void * data, size_t size)
43. {
44.     pimpl_->read(data, size);
45. }

复制代码

当然c++技巧太多，所以导致很多东西必须深入了解才能正确使用，也正因为如此，很多事实都应验了Linus Torvalds的话，不过又有谁会因为这些原因放弃c++呢? 至少我不会，不过我更喜欢C。