C++ 智能指针深入解析

 更新时间:2013年07月16日 10:34:36   作者:  
以下是对C++中智能指针的使用进行了详细的分析介绍,需要的朋友可以参考下

1. 为什么需要智能指针?
简单的说,智能指针是为了实现类似于Java中的垃圾回收机制。Java的垃圾回收机制使程序员从繁杂的内存管理任务中彻底的解脱出来,在申请使用一块内存区域之后,无需去关注应该何时何地释放内存,Java将会自动帮助回收。但是出于效率和其他原因(可能C++设计者不屑于这种傻瓜氏的编程方式),C++本身并没有这样的功能,其繁杂且易出错的内存管理也一直为广大程序员所诟病。

更进一步地说,智能指针的出现是为了满足管理类中指针成员的需要。包含指针成员的类需要特别注意复制控制和赋值操作,原因是复制指针时只复制指针中的地址,而不会复制指针指向的对象。当类的实例在析构的时候,可能会导致垂悬指针问题。

管理类中指针成员的方法一般有两种方式:一种是采用值型类,这种类是给指针成员提供值语义(value semantics),当复制该值型对象时,会得到一个不同的新副本。这种方式典型的应用是string类。另外一种方式就是智能指针,实现这种方式的指针所指向的对象是共享的。

2. 智能指针的实现概述
智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联,引用计数跟踪该类有多少个对象共享同一指针。
每次创建类的新对象时,初始化指针并将引用计数置为1;当对象作为另一对象的副本而创建时,拷贝构造函数拷贝指针并增加与之相应的引用计数;对一个对象进行赋值时,赋值操作符减少左操作数所指对象的引用计数(如果引用计数为减至0,则删除对象),并增加右操作数所指对象的引用计数;调用析构函数时,构造函数减少引用计数(如果引用计数减至0,则删除基础对象)。
实现智能指针有两种经典策略:一是引入辅助类,二是使用句柄类。

3. 实现方式1:引入辅助类
这种方式定义一个单独的具体类(RefPtr)来封装指针和相应的引用计数。

复制代码 代码如下:

class 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);
     SmartPtr sp2(sp1);
     Point *p2 = new Point(5, 5);
     SmartPtr sp3(p2);
     sp3 = sp1;
     return 0;
}

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

4. 实现方式2:使用句柄类
为了避免上面方案中每个使用指针的类自己去控制引用计数,可以用一个类把指针封装起来。封装好后,这个类对象可以出现在用户类使用指针的任何地方,表现为一个指针的行为。我们可以像指针一样使用它,而不用担心普通成员指针所带来的问题,我们把这样的类叫句柄类。在封装句柄类时,需要申请一个动态分配的引用计数空间,指针与引用计数分开存储。实现示例如下:
复制代码 代码如下:

class 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; }
public:
     virtual Point* clone() const {               //虚函数,为了实现让句柄类在不知道对象的确切类型的情况下分配已知对象的新副本
     return new Point(*this);
 }

private:
     int x,y;
};
class D3Point : public Point                           //派生类
{
public:
     D3Point(int xVal, int yVal, int zVal):Point(xVal, yVal), z(zVal) { }
     int getZ() const { return z; }
     void setZ(int zVal) { z = zVal; }
public:
     D3Point* clone() const {                 //虚函数,为了实现让句柄类在不知道对象的确切类型的情况下分配已知对象的新副本
  return new D3Point(*this);
 }
private:
     int z;
};
class SmartPtr
{
public:
     SmartPtr(Point *ptr = 0):p(ptr), count(new int(1)) { }                                         //构造函数
     SmartPtr(Point &point):p(point.clone()), count(new int(1)) { }                          //构造函数
     SmartPtr(const SmartPtr &sp):p(sp.p), count(sp.count) { ++*count; }             //复制构造函数
     SmartPtr& operator=(const SmartPtr &sp) {                                                   //重载赋值操作符
         ++*sp.count;                                           //首先将右操作数引用计数加1,
         decr_use();                                             //然后将引用计数减1,可以应对自赋值
         p = sp.p;
         count = sp.count;
         return *this;
     }
    ~SmartPtr() {                                          //析构函数
          decr_use();
     }
public:                                   //一般情况下不会实现这两个操作符,因为我们不希望用户直接操纵基础对象指针
     const Point* operator->() const {
          if(p) return p;
          else throw logic_error("Unbound Point");
     }
 const Point& operator*() const {
      if(p) return *p;
      else throw logic_error("Unbound Point");
     }
private:
    void decr_use() {
        if(--*count == 0)
        {
             delete p;
             delete count;
       }
    }
private:
     Point *p;                                      //基础对象指针
     int *count;                                   //指向引用计数的指针
};
int main()
{
      Point *p1 = new Point(10, 8);
      SmartPtr sp1(p1);
      SmartPtr sp2(sp1);
      D3Point *p2 = new D3Point(5, 5, 0);
      SmartPtr sp3(p2);
      return 0;
}

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

相关文章

  • C语言合并排序及实例代码

    C语言合并排序及实例代码

    本篇文章主要介绍C语言合并排序算法,这里对合并排序通过实例代码进行了详细讲解,希望能帮助到大家学习
    2016-07-07
  • c++截取汉字和英文混合字符串代码实例

    c++截取汉字和英文混合字符串代码实例

    这篇文章主要介绍了c++截取汉字英文混合字符串,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2019-04-04
  • C语言递归实现线索二叉树

    C语言递归实现线索二叉树

    这篇文章主要介绍了C语言递归实现线索二叉树,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-10-10
  • C语言中无符号数和有符号数之间的运算

    C语言中无符号数和有符号数之间的运算

    C语言中有符号数和无符号数进行运算默认会将有符号数看成无符号数进行运算,其中算术运算默认返回无符号数,逻辑运算当然是返回0或1了。下面通过一个例子给大家分享C语言中无符号数和有符号数之间的运算,一起看看吧
    2017-09-09
  • C++学习小结之二进制转换

    C++学习小结之二进制转换

    这篇文章主要介绍了C++学习小结之二进制转换的相关资料,需要的朋友可以参考下
    2015-07-07
  • c++基础语法:普通继承

    c++基础语法:普通继承

    基类成员的private成员不但对于对象是不可见的,对于派生类也是不可见的,只能被基类成员或者友元访问
    2013-09-09
  • 简单掌握Linux系统中fork()函数创建子进程的用法

    简单掌握Linux系统中fork()函数创建子进程的用法

    fork()函数只能在类Unix系统下使用,因为需要引入unistd头文件,这里我们就来简单掌握Linux系统中fork()函数创建子进程的用法,需要的朋友可以参考下
    2016-06-06
  • C/C++中关于std::string的compare陷阱示例详解

    C/C++中关于std::string的compare陷阱示例详解

    这篇文章主要给大家介绍了关于C/C++中关于std::string的compare陷阱的相关资料,文中先对C/C++中的std::string进行了简单的介绍,通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧。
    2017-11-11
  • C++快速幂与大数取模算法示例

    C++快速幂与大数取模算法示例

    这篇文章主要介绍了C++快速幂算法和大数取模算法的示例,对C++程序员来说有一定的帮助,有需要的朋友可以参考借鉴,下面来一起看看。
    2016-08-08
  • C++标准之(ravalue reference) 右值引用介绍

    C++标准之(ravalue reference) 右值引用介绍

    临时对象的产生和拷贝所带来的效率折损,一直是C++所为人诟病的问题,下面简单地介绍一下Copy Elision、RVO,对此不感兴趣的可以直接跳过
    2012-11-11

最新评论