Boost智能指针小记

╰+攻爆jí腚メ 2022-05-15 11:28 150阅读 0赞

参考资料：[http://www.boost.org/doc/libs/1\_47\_0/libs/smart\_ptr/smart\_ptr.htm][http_www.boost.org_doc_libs_1_47_0_libs_smart_ptr_smart_ptr.htm]

\[scoped\_ptr\]

模板类[scoped\_ptr][scoped_ptr]储存着一个指向动态分配的对象的指针，可以通过reset方法显式释放对象，或者在scoped\_ptr的析构函数中释放。

Scoped\_ptr提供了基本的[RAII][]机制，没有shared-ownership或transfer-of-ownership的语义问题。它的名字和语义表明了它的目的只是单纯地在当前作用域保持所有权，同时它继承于noncopyable。

由于scoped\_ptr只是用于简单需求的简单解决方案，它本身设计就很简单，这使得它的操作跟内置指针一样快，并且不需要耗费额外的存储空间。

此外，scoped\_ptr不能用于STL容器类和指向动态分配的数组的指针，如果需要，可以使用shared\_ptr和scoped\_array。一个比较经常的用法就是使用scoped\_ptr来实现[pimpl][]，避免在头文件中引入类的完整实现，可以减少编译时间等。

以下是scoped\_ptr的概览：

namespace boost \{ template<class T> class scoped\_ptr : noncopyable \{ public: typedef T element\_type; explicit scoped\_ptr(T \* p = 0); //never throws ~scoped\_ptr(); //never throws void reset(T \* p = 0); //never throws T & operator\*() const; //never throws T \* operator->() const; //never throws T \* get() const; //never throws operator unspecified-bool-type() const; //never throws void swap(scoped\_ptr & b); //never throws \}; template<class T> void swap(scoped\_ptr<T> & a, scoped\_ptr<T> & b); //never throws \}  
以下是scoped\_ptr的使用示例：

\#include <boost/scoped\_ptr.hpp> \#include <iostream> class MyClass \{ public: MyClass()\{ std::cout << "MyClass" << std::endl; \} ~MyClass()\{ std::cout << "~MyClass" << std::endl; \} void MyFunc()\{ std::cout << "MyFunc" << std::endl; \} \}; int main(int argc, char \*argv\[\]) \{ boost::scoped\_ptr<MyClass> spMyClass(new MyClass); spMyClass->MyFunc(); spMyClass.reset(); system("Pause"); return 0; \}

\[shared\_ptr\]

顾名思义，[shared\_ptr][shared_ptr]智能指针能够共享所有权，并且它符合C++标准库中CopyConstructible和Assignable的要求，所以它可以用于STL的容器类上。通常，shared\_ptr不能正确地管理数组指针，如果需要，可以使用shared\_array。

智能指针shared\_ptr通过引用计数来管理资源，所以存在循环引用的问题，可以通过[weak\_ptr][weak_ptr]来打破循环。在没有看源码前，可以思考下如何实现shared\_ptr的引用计数，这对实践是有帮助的（显然是废话）。

下面两种初始化方式中，第一种是得到提倡的：

boost::shared\_ptr<MyClass> spMyClass1(new MyClass); MyClass \*pMyClass = new MyClass(); boost::shared\_ptr<MyClass> spMyClass2(pMyClass);  
如果使用第二种，要避免出现如下代码，存在由于重复释放导致访问非法内存的错误：

MyClass \*pMyClass = new MyClass(); boost::shared\_ptr<MyClass> spMyClass1(pMyClass); boost::shared\_ptr<MyClass> spMyClass2(pMyClass);  
正确的做法应该是：

MyClass \*pMyClass = new MyClass(); boost::shared\_ptr<MyClass> spMyClass1(pMyClass); boost::shared\_ptr<MyClass> spMyClass2(spMyClass1);  
这个可能在实践中出现的问题就与理解引用计数怎么实现的相关联。

此外，使用一个临时shared\_ptr作为函参也可能出现问题，导致内存泄漏。因为C++参数的求值顺序是未定的（未求证，是没有相关标准还是编译器厂商自定义了？），比如下述代码的构造顺序可能为new int(2)，g()，shared\_ptr，但是g()如果抛出异常呢？那么shared\_ptr就构造不了，new了一个int，就没有释放了。

f(shared\_ptr<int>(new int(2)), g());  
\[weak\_ptr\]

前面说过shared\_ptr存在循环引用的问题，使用weak\_ptr可以解决。智能指针weak\_ptr只能通过shared\_ptr来构造，它可以管理shared\_ptr指向的对象，同时不增加引用计数。

智能指针weak\_ptr所能进行的操作是有限的，因为在多线程编程中使用它来获取存储的指针通常都是危险的，即便在单线程中，也可能引发问题，比如boost官网上展示的一段代码：

shared\_ptr<int> p(new int(5)); weak\_ptr<int> q(p); if(int \* r = q.get()) \{ //use \*r \}  
存在执行q.get()后，另一个线程中指向相同对象的shared\_ptr执行了reset的可能，对于这个问题，可以如下解决（同样来自官方）：

shared\_ptr<int> p(new int(5)); weak\_ptr<int> q(p); if(shared\_ptr<int> r = q.lock()) \{ //use \*r \}  
成员函数lock()返回如下：

expired()? shared\_ptr<T>(): shared\_ptr<T>(\*this)  
而expired()函数返回如下：

use\_count() == 0

\[intrusive\_ptr\]

之前说过shared\_ptr存在一个问题，就是多次使用未经过包装的原生指针（raw pointer）进行构造，会导致多次析构，造成非法访问内存的错误。这是由于shared\_ptr把引用计数放在shared\_ptr结构中，所以使用原生指针构造会造成多份引用计数。

而intrusive\_ptr则不存在这个问题，因为它把引用计数放在管理的对象中。同时，它要求对象必须有intrusive\_ptr\_add\_ref和intrusive\_ptr\_release两个成员函数以供intrusive\_ptr调用来管理引用计数。这也是intrusive\_ptr的名称由来。

通常来说，如果使用intrusive\_ptr的好处不是很明显，那么就优先考虑shared\_ptr。

[http_www.boost.org_doc_libs_1_47_0_libs_smart_ptr_smart_ptr.htm]: http://www.boost.org/doc/libs/1_47_0/libs/smart_ptr/smart_ptr.htm
[scoped_ptr]: http://www.boost.org/doc/libs/1_47_0/libs/smart_ptr/scoped_ptr.htm
[RAII]: http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization
[pimpl]: http://www.richelbilderbeek.nl/CppPimpl.htm
[shared_ptr]: http://www.boost.org/doc/libs/1_47_0/libs/smart_ptr/shared_ptr.htm
[weak_ptr]: http://www.boost.org/doc/libs/1_47_0/libs/smart_ptr/weak_ptr.htm