C++智能指针简析

   智能指针(auto_ptr)：

       auto_ptr只是C++标准库提供的一个类模板，它与传统的new/delete控制内存相比有一定优势，但也有其局限。

   

1. auto_ptr是什么？

auto_ptr 是C++标准库提供的类模板，auto_ptr对象通过初始化指向由new创建的动态内存，它是这块内存的拥有者，一块内存不能同时被分给两个拥有者。当auto_ptr对象生命周期结束时，其析构函数会将auto_ptr对象拥有的动态内存自动释放。即使发生异常，通过异常的栈展开过程也能将动态内存释放。auto_ptr不支持new数组。

 

2. auto_ptr需要包含的头文件？

#include <memory>

 

3. 初始化auto_ptr对象的方法？

1) 构造函数

1] 将已存在的指向动态内存的普通指针作为参数来构造

int* p = new int(33);

auto_ptr<int> api(p);

2] 直接构造智能指针

auto_ptr< int > api( new int( 33 ) );

2) 拷贝构造

利用已经存在的智能指针来构造新的智能指针

auto_ptr< string > pstr_auto(newstring("Brontosaurus" ) );

auto_ptr< string >pstr_auto2(pstr_auto);  //利用pstr_auto来构造pstr_auto2

因为一块动态内存智能由一个智能指针独享，所以在拷贝构造或赋值时都会发生拥有权转移的过程。在此拷贝构造过程中，pstr_auto将失去对字符串内存的所有权，而pstr_auto2将其获得。对象销毁时，pstr_auto2负责内存的自动销毁。

3) 赋值

利用已经存在的智能指针来构造新的智能指针

auto_ptr< int > p1( new int( 1024 ));

auto_ptr< int > p2( new int( 2048 ));

p1 = p2;

在赋值之前，由p1指向的对象被删除。赋值之后，p1拥有int型对象的所有权。该对象值为2048。p2不再被用来指向该对象。

 

4. 空的auto_ptr需要初始化吗？

通常的指针在定义的时候若不指向任何对象，我们用Null给其赋值。对于智能指针，因为构造函数有默认值0，我们可以直接定义空的auto_ptr如下：

auto_ptr< int > p_auto_int;  //不指向任何对象

 

5. 防止两个auto_ptr对象拥有同一个对象（一块内存）

因为auto_ptr的所有权独有，所以下面的代码会造成混乱。

int* p = new int(0);
auto_ptr<int> ap1(p);
auto_ptr<int> ap2(p);

因为ap1与ap2都认为指针p是归它管的，在析构时都试图删除p,　两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto_ptr。

 

6. 警惕智能指针作为参数！

1) 按值传递时，函数调用过程中在函数的作用域中会产生一个局部对象来接收传入的auto_ptr(拷贝构造)，这样，传入的实参auto_ptr就失去了其对原对象的所有权，而该对象会在函数退出时被局部auto_ptr删除。如下例：

void f(auto_ptr<int> ap)

{cout<<*ap;}
auto_ptr<int> ap1(new int(0));
f(ap1);
cout<<*ap1; //错误，经过f(ap1)函数调用，ap1已经不再拥有任何对象了。

2) 引用或指针时，不会存在上面的拷贝过程。但我们并不知道在函数中对传入的auto_ptr做了什么，如果当中某些操作使其失去了对对象的所有权，那么这还是可能会导致致命的执行期错误。

结论：const reference是智能指针作为参数传递的底线。

 

7. auto_ptr不能初始化为指向非动态内存

原因很简单，delete表达式会被应用在不是动态分配的指针上这将导致未定义的程序行为。

 

8. auto_ptr常用的成员函数

1) get()

返回auto_ptr指向的那个对象的内存地址。如下例：

int* p = new int(33);

cout << "the adress of p:"<<p<< endl;

auto_ptr<int> ap1(p);

cout << "the adress ofap1:"<< &ap1 << endl;

cout << "the adress of theobjectwhichap1 point to: " << ap1.get() << endl;

输出如下：

the adress of p: 00481E00

the adress of ap1: 0012FF68

the adress of the object which ap1 pointto:00481E00

第一行与第三行相同，都是int所在的那块内存的地址。第二行是ap1这个类对象本身所在内存的地址。

2) reset()

重新设置auto_ptr指向的对象。类似于赋值操作，但赋值操作不允许将一个普通指针指直接赋给auto_ptr，而reset()允许。如下例：

auto_ptr< string > pstr_auto(newstring("Brontosaurus" ) );

pstr_auto.reset( new string( "Long-neck"));

在例子中，重置前pstr_auto拥有"Brontosaurus"字符内存的所有权，这块内存首先会被释放。之后pstr_auto再拥有"Long -neck"字符内存的所有权。

注：reset(0)可以释放对象，销毁内存。

3) release()

返回auto_ptr指向的那个对象的内存地址,并释放对这个对象的所有权。

用此函数初始化auto_ptr时可以避免两个auto_ptr对象拥有同一个对象的情况（与get函数相比）。

例子如下：

auto_ptr< string > pstr_auto(newstring("Brontosaurus" ) );

auto_ptr< string >pstr_auto2(pstr_auto.get()); //这是两个auto_ptr拥有同一个对象

auto_ptr< string>pstr_auto2(pstr_auto.release() ); //release可以首先释放所有权

     具体操作中的智能指针：它的一种通用实现方法是采用引用计数的方法。智能指针将一个计数器与类指向的对象相关联，引用计数跟踪共有多少个类对象共享同一指针。

    每次创建类的新对象时，初始化指针并将引用计数置为1；

    当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；

    对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；这是因此左侧的指针指向了右侧指针所指向的对象，因此右指针所指向的对象的引用计数+1；

    调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

    实现智能指针有两种经典策略：一是引入辅助类，二是使用句柄类。这里主要讲一下引入辅助类的方法，看下面的例子：

class Point                                       //基础对象类，要做一个对Point类的智能指针

{

public:

    Point(int xVal = 0, int yVal = 0):x(xVal),y(yVal) { }

    int getX() const { return x; }

    int getY() const { return y; }

    void setX(int xVal) { x = xVal; }

    void setY(int yVal) { y = yVal; }

private:

    int x,y;

};

class RefPtr                                  //辅助类

{//该类成员访问权限全部为private，因为不想让用户直接使用该类

 friend class SmartPtr;      //定义智能指针类为友元，因为智能指针类需要直接操纵辅助类

 RefPtr(Point *ptr):p(ptr), count(1) {}

 ~RefPtr() { delete p; }

  

 int count;                                                     //引用计数

 Point*p;                                                      //基础对象指针

};

  

class SmartPtr                                             //智能指针类

{

public:

 SmartPtr(Point *ptr):rp(new RefPtr(ptr)) {}                                 //构造函数

 SmartPtr(const SmartPtr &sp):rp(sp.rp) {++rp->count;}            //复制构造函数

 SmartPtr& operator=(const SmartPtr& rhs){                              //重载赋值操作符

  ++rhs.rp->count;                                                         //首先将右操作数引用计数加1，

  if(--rp->count ==0)                                                                     //然后将引用计数减1，可以应对自赋值

   delete rp;

  rp = rhs.rp;

  return *this;

 }

 ~SmartPtr(){                                            //析构函数

  if(--rp->count ==0)                                  //当引用计数减为0时，删除辅助类对象指针，从而删除基础对象

   delete rp;

 }

  

private:

 RefPtr*rp;                                                //辅助类对象指针

};

  

int main()

{

 Point *p1 = new Point(10, 8);

 SmartPtr sp1(p1);    //此时sp1.rp->count = 1

 SmartPtr sp2(sp1);    //首先将sp1.rp->count赋给sp2.rp->count,之后sp2.rp->count++,这时sp1,sp2的rp是同一个对象

 

使用该方式的内存结构图如下：