C++ 11：std::auto_ptr介绍，以及boost::scoped_ptr

一时失言乱红尘 2022-01-06 06:15 228阅读 0赞

**本文根据众多互联网博客内容整理后形成，引用内容的版权归原始作者所有，仅限于学习研究使用。**

# 1 std::auto\_ptr #

## **1.1 auto\_ptr介绍** ##

智能指针能保证，无论在何种情况下，只要自己被摧毁，就一定连带释放其所指资源。auto\_ptr是这样的一种指针：它是“它所指向的对象”的拥有者。**auto\_ptr要求一个对象只能有一个拥有者，严禁一物二主。不再需要delete，也不再需要catch了**。不用担心忘掉delete动作，担心程序异常结束时内存遗失或者资源遗失，只要有智能指针auto\_ptr.

c++标准库提供的auto\_ptr一种帮助程序员防止“被抛出异常时发生资源泄漏”的智能指针。

auto\_ptr在头文件**\#include<memory>** 中

auto\_ptr没有所有的指针算术（包括++）运算。auto\_ptr不允许你使用一般指针惯用的赋值初始化方式。 例如：

**std::auto\_ptr<ClassA> ptr1(new ClassA); //对的**

std::auto\_ptr<ClassA> ptr2 =new ClassA;  //错的

## **2.auto\_ptr拥有权的转移** ##

std::auto\_ptr<ClassA> ptr1(new ClassA);//ptr1拥有了那个new出来的对象。

std::auto\_ptr<ClassA> ptr2(ptr1);　　//ptr2拥有了那个new出来的对象，ptr1=NULL不再拥有它，即拥有权的转移；

//这样对象就只会在ptr2被摧毁的时候被delete一次。

下面的赋值操作和上面的差不多：

std::auto\_ptr<ClassA> ptr1(new ClassA);

std::auto\_ptr<ClassA> ptr2;

ptr2=ptr1; //拥有权从ptr1转移到ptr2

如果ptr2被赋值之前正拥有另一个对象，赋值时将会delete掉那个对象。

std::auto\_ptr<ClassA> ptr1(new ClassA);

std::auto\_ptr<ClassA> ptr2(new ClassA);

ptr2=ptr1; //拥有权从ptr1转移到ptr2，ptr2的原来的对象被delete掉。

拥有权的转移，实质上并非只是被简单拷贝而已。只要发生了拥有权转移，先前的拥有者就失去了拥有权，结果拥有者一旦交出拥有权，就两手空空，只剩下一个null指针在手了。

只有auto\_ptr可以拿来当做另一个auto\_ptr的初值，普通指针是不行的。例如：

std::auto\_ptr<ClassA> ptr ；//可以定义空的auto\_ptr指针，对于智能指针，因为构造函数有默认值0

ptr =new ClassA;　　　　//错误，

ptr =std::auto\_ptr<ClassA> (new ClassA);//正确被auto\_ptr对象或者auto\_ptr指针赋值，

3）某函数是数据的终点，auto\_ptr以传值方式被当作一个参数传递给某函数时。被调用端的参数获得了这个auto\_ptr的拥有权，如果函数不再将它传递出去，它所指的对象就会在函数退出时被删除。如：void sink(std::auto\_ptr<ClassA> );

4) 某函数是数据的起点。

std::auto_ptr<ClassA> f()
 　　　　{
 　　　　　　std::auto_ptr<ClassA> ptr(new ClassA);
 　　　　　　//........
 　　　　　　return ptr;
 　　　　}
 
 　　　　void g()
 　　　　{
 　　　　　　std::auto_ptr<ClassA> p;
 　　　　　　for (int i =0; i <10; i++) {
 　　　　　　　　p=f();  //p获得f()返回对象的拥有权。每当f()被调用时，它都new一个对象，然后把该对象连同其拥有权一起返回给调用端。
 　　　　　　　　//一旦循环再次执行这个赋值动作，p原先拥有的对象被删除。当离开g()时，p也被摧毁。
 　　　　　　}
 }

auto\_ptr的语义本身就包含了拥有权，所以如果你无意转交你的拥有权，就不要在参数列表值中使用auto\_ptr，也不要以它作为返回值。

下面的例子本来是想将auto\_ptr所指对象的值打印出来，却可能引发了错误：

//a bad example 
\#include <iostream> 
\#include <memory> 
using namespace std; 
 
template<class T> 
void bad\_print(std::auto\_ptr<T> p) 
\{ 
  if (NULL ==p.get()) 
    cout <<"NULL"; 
  else 
    cout << \*p;  
\} 
 
int main() 
\{ 
  auto\_ptr<int> p(new int); 
  \*p =42; 
  bad\_print(p); //bad\_print调用结束后，p所指向的对象被删除了。 
  \*p =18;//执行期错误，用g++编译时出现Segmentation fault (core dumped)（段错误） 
  return 0; 
\}

//a bad example 
\#include <iostream> 
\#include <memory> 
using namespace std; 
 
template<class T> 
void bad\_print(std::auto\_ptr<T> p) 
\{ 
  if (NULL ==p.get()) 
    cout <<"NULL"; 
  else 
    cout << \*p;  
\} 
 
int main() 
\{ 
  **const** auto\_ptr<int> p(new int); 
  \*p =42; 
  bad\_print(p);　　//编译期错误，无法变更constant reference的拥有权 
  \*p =18;　　　　//ok 
  return 0; 
\}

**关键字const并非意味你不能更改auto\_ptr所拥有的对象，而是意味着你不能更改auto\_ptr的拥有权**。例如：

std::auto\_ptr<int> f()

const std::auto\_ptr<int> p(new int);

std::auto\_ptr<int>  q(new int);

\*p =42;//ok,改变值

bad\_print(p);//编译期错误，不能变更拥有权

\*p =\*q;  //ok;

p =q;　　//编译期错误

return p;  //编译期错误

如果使用const auto\_ptr作为参数，对新对象的任何赋值操作都将导致编译期错误。就其常数特性而言，const auto\_ptr比较类似常数指针(T\* const p),

而非指向常数的指针(const T\* p)，尽管语法上更像后者。

## **1.3 auto\_ptr的正确运用：** ##

1）**auto\_ptr之间不能共享拥有权，即不要让两个auto\_ptr指向同一个对象。**

一个auto\_ptr千万不能指向另一个auto\_ptr（或其它对象）所拥有的对象，尽管语法上没问题，很多情况下可能也不会发生错误。但是，当一个指针删除该对象后，另一个指针突然间指向一个已被摧毁的对象，那么，如果再使用那个指针进行读写操作，就会引发一场灾难。

2）并不存在针对array而设计的auto\_ptrs

**auto\_ptr不能指向array，因为auto\_ptr是透过delete而非delete\[ \]来释放其所拥有的对象**。注意，c++标准程序库并未针对array而设计的auto\_ptr。标准程序库另提供了数个容器类别，用来管理数据群。

3）auto\_ptrs绝非一个“四海通用”的智能型指针

并非任何适用智能指针的地方都适用auto\_ptr，特别请注意的是，它不是引用计数型指针——这种指针保证，如果有一组智能型指针指向同一个对象，那么当且仅当最后一个智能型指针被销毁时，该对象才会被销毁。

4）auto\_ptrs不满足STL容器对其他元素的要求

auto\_ptr并不满足STL标准容器对于元素的最基本要求，因为在拷贝和赋值动作之后，原本的auto\_ptr和新产生的auto\_ptr并不相等。是的，拷贝和赋值之后，原本的auto\_ptr会交出拥有权，而不是拷贝给新的auto\_ptr。因此绝对不要将auto\_ptr作为标准容器的元素。

5）**不要使用auto\_ptr对象保存指向静态分配对象的指针**，否则，当auto\_ptr对象本身被撤销的时候，它将试图删除指向非动态分配对象的指针，导致未定义的行为。

使用一个 std::auto\_ptr 的限制很多，还不能用来管理堆内存数组，如此多的限制就很容易导致问题。所以说它是一个带有缺陷的设计，是一个“弃儿”。由于 std::auto\_ptr 引发了诸多问题，一些设计并不是非常符合 C++ 编程思想，所以C++引入了下面 boost 库的智能指针，boost 智能指针可以解决如上问题。

## 1.4 总结： ##

std::auto\_ptr 可用来管理单个对象的内存，但是，请注意如下几点：

1）    首先auto\_ptr智能指针是个封装好的类；

2）    尽量不要使用“operator=”。如果使用了，请不要再使用先前对象；

3）    std::auto\_ptr 最好不要当成**参数传递**（读者可以自行写代码确定为什么不能）；

4）    采用栈上的指针去管理堆上的内容，所以auto\_ptr所管理的对象必须是**new出**来的，也不能是malloc出来的。（原因:在auto\_ptr的实现机制中，采用的是delete 掉一个指针，该delete一方面是调用了指针所指对象的析构函数（这也是为什么采用智能指针，new了一个对象，但是不用delete的原因），另一方面释放了堆空间的内存。）

# #

# 2 boost::scoped\_ptr #

## 2.1 介绍 ##

boost::scoped\_ptr和std::auto\_ptr非常类似，是一个简单的智能指针，它能够保证在离开作用域后对象被自动释放。下列代码演示了该指针的基本应用：

<table> 
 <tbody> 
 <tr> 
 <td> #include&nbsp;&lt;string&gt; #include&nbsp;&lt;iostream&gt; #include&nbsp;&lt;boost/scoped_ptr.hpp&gt; class&nbsp;implementation { public: &nbsp;&nbsp;&nbsp;&nbsp;~implementation() { std::cout &lt;&lt;"destroying implementation\n"; } &nbsp;&nbsp;&nbsp;&nbsp;void&nbsp;do_something() { std::cout &lt;&lt;&nbsp;"did something\n"; } }; void&nbsp;test() { &nbsp;&nbsp;&nbsp;&nbsp;boost::scoped_ptr&lt;implementation&gt; impl(new&nbsp;implementation()); &nbsp;&nbsp;&nbsp;&nbsp;impl-&gt;do_something(); } void&nbsp;main() { &nbsp;&nbsp;&nbsp;&nbsp;std::cout&lt;&lt;"Test Begin ... \n"; &nbsp;&nbsp;&nbsp;&nbsp;test(); &nbsp;&nbsp;&nbsp;&nbsp;std::cout&lt;&lt;"Test End.\n"; } </td> 
 </tr> 
 </tbody> 
</table>

该代码的输出结果是：

<table> 
 <tbody> 
 <tr> 
 <td> Test Begin ... did something destroying implementation Test End. </td> 
 </tr> 
 </tbody> 
</table>

可以看到：当implementation类离其开impl作用域的时候，会被自动删除，这样就会避免由于忘记手动调用delete而造成内存泄漏了。

## **2.2 boost::scoped\_ptr特点：** ##

boost::scoped\_ptr 属于 boost 库，定义在 namespace boost 中，包含头文件\#include<boost/smart\_ptr.hpp> 便可以使用。scoped\_ptr 跟 auto\_ptr 一样，可以方便的管理单个堆内存对象，特别的是，scoped\_ptr 独享所有权，避免了auto\_ptr恼人的几个问题。

scoped\_ptr是一种简单粗暴的设计，它本质就是**防拷贝**，避免出现管理权的转移。这是它的最大特点，所以他的拷贝构造函数和赋值运算符重载函数都只是声明而不定义，而且为了防止有的人在类外定义，所以将函数声明为protected。但这也是它最大的问题所在，就是不能赋值拷贝，也就是说功能不全。但是这种设计比较高效、简洁。没有 release() 函数，不会导致先前的内存泄露问题。

boost::scoped\_ptr的实现和std::auto\_ptr非常类似，都是利用了一个栈上的对象去管理一个堆上的对象，从而使得堆上的对象随着栈上的对象销毁时自动删除。**不同的是，boost::scoped\_ptr有着更严格的使用限制——不能拷贝。这就意味着：boost::scoped\_ptr指针是不能转换其所有权的。**

1.  不能转换所有权  
    boost::scoped\_ptr所管理的对象生命周期仅仅局限于一个区间（该指针所在的"\{\}"之间），无法传到区间之外，这就意味着boost::scoped\_ptr对象是不能作为函数的返回值的（std::auto\_ptr可以）。
2.  不能共享所有权  
    这点和std::auto\_ptr类似。这个特点一方面使得该指针简单易用。另一方面也造成了功能的薄弱——不能用于stl的容器中。
3.  不能用于管理数组对象  
    由于boost::scoped\_ptr是通过delete来删除所管理对象的，而数组对象必须通过deletep\[\]来删除，因此boost::scoped\_ptr是不能管理数组对象的，如果要管理数组对象需要使用boost::scoped\_array类。

## **2.3 boost::scoped\_ptr的常用操作：** ##

可以简化为如下形式：

<table> 
 <tbody> 
 <tr> 
 <td> namespace&nbsp;boost { &nbsp;&nbsp;&nbsp;&nbsp;template&lt;typename&nbsp;T&gt;&nbsp;class&nbsp;scoped_ptr : noncopyable { &nbsp;&nbsp;&nbsp;&nbsp;public: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;explicit&nbsp;scoped_ptr(T* p = 0);&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;~scoped_ptr();&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;void&nbsp;reset(T* p = 0);&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;T&amp;&nbsp;operator*()&nbsp;const;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;T*&nbsp;operator-&gt;()&nbsp;const;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;T* get()&nbsp;const;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;void&nbsp;swap(scoped_ptr&amp; b);&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;}; &nbsp;&nbsp;&nbsp;&nbsp;template&lt;typename&nbsp;T&gt;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;void&nbsp;swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b);&nbsp; } </td> 
 </tr> 
 </tbody> 
</table>

它的常用操作如下：

<table> 
 <tbody> 
 <tr> 
 <td> 成员函数 </td> 
 <td> 功能 </td> 
 </tr> 
 <tr> 
 <td> operator*() </td> 
 <td> 以引用的形式访问所管理的对象的成员 </td> 
 </tr> 
 <tr> 
 <td> operator-&gt;() </td> 
 <td> 以指针的形式访问所管理的对象的成员 </td> 
 </tr> 
 <tr> 
 <td> reset() </td> 
 <td> 释放所管理的对象，管理另外一个对象 </td> 
 </tr> 
 <tr> 
 <td> swap(scoped_ptr&amp; b) </td> 
 <td> 交换两个boost::scoped_ptr管理的对象 </td> 
 </tr> 
 </tbody> 
</table>

下列测试代码演示了这些功能函数的基本使用方法。

<table> 
 <tbody> 
 <tr> 
 <td> #include&nbsp;&lt;string&gt; #include&nbsp;&lt;iostream&gt; #include&nbsp;&lt;boost/scoped_ptr.hpp&gt; #include&nbsp;&lt;boost/scoped_array.hpp&gt; #include&nbsp;&lt;boost/config.hpp&gt; #include&nbsp;&lt;boost/detail/lightweight_test.hpp&gt; void&nbsp;test() { &nbsp;&nbsp;&nbsp;&nbsp;// test scoped_ptr with a built-in type &nbsp;&nbsp;&nbsp;&nbsp;long&nbsp;* lp =&nbsp;new&nbsp;long; &nbsp;&nbsp;&nbsp;&nbsp;boost::scoped_ptr&lt;long&gt; sp ( lp ); &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( sp.get() == lp ); &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( lp == sp.get() ); &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( &amp;*sp == lp ); &nbsp;&nbsp;&nbsp;&nbsp;*sp = 1234568901L; &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( *sp == 1234568901L ); &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( *lp == 1234568901L ); &nbsp;&nbsp;&nbsp;&nbsp;long&nbsp;* lp2 =&nbsp;new&nbsp;long; &nbsp;&nbsp;&nbsp;&nbsp;boost::scoped_ptr&lt;long&gt; sp2 ( lp2 ); &nbsp;&nbsp;&nbsp;&nbsp;sp.swap(sp2); &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( sp.get() == lp2 ); &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( sp2.get() == lp ); &nbsp;&nbsp;&nbsp;&nbsp;sp.reset(NULL); &nbsp;&nbsp;&nbsp;&nbsp;BOOST_TEST( sp.get() == NULL ); } void&nbsp;main() { &nbsp;&nbsp;&nbsp;&nbsp;test(); } </td> 
 </tr> 
 </tbody> 
</table>

## 2.4 scoped\_ptr使用特点总结： ##

1）与auto\_ptr类似，采用栈上的指针去管理堆上的内容，从而使得堆上的对象随着栈上对象销毁时自动删除；

2）scoped\_ptr有着更严格的使用限制——不能拷贝，这也意味着scoped\_ptr不能转换其所有权，所以它管理的对象不能作为**函数的返回值**，对象生命周期仅仅局限于一定区间（该指针所在的\{\}区间，而std::auto\_ptr可以）；

3）由于防拷贝的特性，使其管理的对象**不能共享所有权**，这与std::auto\_ptr类似，这一特点使该指针简单易用，但也造成了功能的薄弱。

# **3 boost::scoped\_ptr和std::auto\_ptr的选取：** #

boost::scoped\_ptr和std::auto\_ptr的功能和操作都非常类似，**如何在他们之间选取取决于是否需要转移所管理的对象的所有权（如是否需要作为函数的返回值）**。如果没有这个需要的话，大可以使用boost::scoped\_ptr，让编译器来进行更严格的检查，来发现一些不正确的赋值操作。

参考：

[https://www.cnblogs.com/TianFang/archive/2008/09/15/1291050.html][https_www.cnblogs.com_TianFang_archive_2008_09_15_1291050.html]

[https://www.cnblogs.com/ckings/p/3663028.html][https_www.cnblogs.com_ckings_p_3663028.html]

[https://www.cnblogs.com/33debug/p/6832726.html][https_www.cnblogs.com_33debug_p_6832726.html]

[https_www.cnblogs.com_TianFang_archive_2008_09_15_1291050.html]: https://www.cnblogs.com/TianFang/archive/2008/09/15/1291050.html
[https_www.cnblogs.com_ckings_p_3663028.html]: https://www.cnblogs.com/ckings/p/3663028.html
[https_www.cnblogs.com_33debug_p_6832726.html]: https://www.cnblogs.com/33debug/p/6832726.html