智能指针原理与实现-优快云博客

本文介绍了智能指针的概念及其实现方式，包括辅助类和句柄类两种策略。通过引用计数机制，智能指针能够自动管理内存，避免悬垂指针的问题，确保程序的健壮性和内存的有效利用。

智能指针实现

简介

智能指针是一个类，它对普通指针进行封装，使智能指针对象具有普通指针类型一样的操作。它能够在复制对象时，使副本和原对象都指向同一存储区域，通过副本或原对象改变所指值时，通过另一个对象访问的值也发生改变。

智能指针能够对内存进行自动管理，避免出现悬垂指针情况。C/C++语言中，在创建对象是进行内存分配，使用完毕后需要释放内存，如果出现不正确操作内存，则可能导致内存泄露。而智能指针能够解决这一问题，管理内存。
引用计数

引用计数让指针让要删除的内存知道是否还有其他指针存在，如果有，则不对内存进行删除，如有没有，则删除，这样能够避免悬垂指针的存在。

引用计数的目的：

1）简化跟踪堆中的对象的过程。它能够跟踪对象的所有权，并自动销毁对象。它充当简单垃圾回收体系。

2）节省内存，提高程序运行效率。当很多对象有相同值时，共享这一值，避免复制存储多个副本，从而节省内存。

实现

智能指针的实现可以使用辅助类和句柄类两种策略实现。

辅助类实现方法：定义一个基础对象类，然后在定义一个辅助类来实现。辅助类的所有成员均为私有，使其不被普通用户使用。为让智能指针使用，需把智能指针类声明为辅助类的友元。辅助类主要含有两个数据成员：计数count和基础对象指针。

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

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

2）当对象作为另一个对象的副本时，复制构造函数复制副本指针，并增加与指针相应的引用计数（加1）；

3）使用赋值操作符对一个对象进行赋值时，先使左操作数的指针的引用计数减1（减1是因为指针指向别的地方），如果减1后引用计数为0，则释放指针所指对象内存。然后增加右操作数所指对象的引用计数（增加是因为做操作数指向对象即右操作指向对象）；

4）调用析构函数时，析构函数先使引用计数减1，如果减至0，则delete对象。

具体实现如下：

#include <iostream>
using namespace std;
// 基础对象点类 
class Point
{
    private:
        int x, y;
    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;
        }
}; 

// 辅助类
class U_Ptr
{
    private:
        int count;
        Point *p;

        friend class SmartPtr;
        U_Ptr(Point *ptr): p(ptr), count(1) { }
        ~U_Ptr() { delete p; }
}; 

class SmartPtr
{
    private:
        U_Ptr *rp;
    public:
        SmartPtr(Point *ptr): rp(new U_Ptr(ptr)){ }
        SmartPtr(const SmartPtr &sp): rp(sp.rp)
        {
            ++rp->count;
        }
        SmartPtr& operator= (const SmartPtr& rhs)
        {
            ++rhs.rp->count;
            if (--rp->count == 0)
                delete rp;
            rp = rhs.rp;
            return *this;
        }
        ~SmartPtr()
        {
            if (--rp->count == 0)
                delete rp;
            else
                cout << "还存在" << rp->count << "个指针指向基础对象" << endl; 
        }
        Point& operator *()   // 重载*操作符
        {
            return *(rp->p);
        } 
        Point* operator ->()  // 重载->操作符
        {
            return rp->p;
        } 
};

int main()
{
    // 定义一个基础对象类指针
    Point *pa = new Point(10, 20);
    // 定义三个智能指针类对象，对象都指向基础类对象pa
    // 使用花括号控制三个指针的生命期，观察技术的变化
    {
        SmartPtr sptr1(pa);               // 此时计数count = 1 
        cout << sptr1->getX() << endl;
        {
            SmartPtr sptr2(sptr1);        // 次时计数count = 2 
            {
                SmartPtr sptr3 = sptr1;   // 此时技术count = 3 
            }
            // 此时count = 2； 
        }
        // 此时count = 1； 
    } 
    // 此时count = 0；pa对象被delete掉 
    cout << pa->getX() << endl;
    return 0;
}

利用模板实现

#include <iostream>
using namespace std;
// 模板类作为友元时要先有声明
template <typename T> class SmartPtr;

// 辅助类
template <typename T> class U_Ptr
{
    // 类内成员访问权限为private，使其不让普通用户使用该类。 
    private:
        T *p;           // 基础对象指针
        int count;      // 引用计数 
        friend class SmartPtr<T>;           // 定义智能指针类为友元，因为智能指针类需要直接操作辅助类 
        U_Ptr(T *ptr):p(ptr),count(1) { }   // 构造函数的参数为基础对象的指针 
        ~U_Ptr() { delete p; }              // 析构函数 
};
// 智能指针类
template <typename T> class SmartPtr
{
    private:
        U_Ptr<T> *rp;   // 辅助类对象指针  
    public:
        SmartPtr(T *ptr):rp(new U_Ptr<T>(ptr)) { }   // 构造函数 
        SmartPtr(const SmartPtr<T> &sp):rp(sp.rp)    // 复制构造函数 
        { 
            ++rp->count;
        } 
        SmartPtr& operator = (const SmartPtr<T> &rhs)// 重载赋值操作符 
        {
            ++rhs.rp->count;       // 将右操作数引用计数加1 
            if (--rp.count == 0)   // 将左操作数引用计数减1，可以对应自赋值 
                delete rp;
            rp = rhs.rp;
            return *this; 
        }
        T& operator *()            // 重载*操作符 
        {
            return *(rp->p);
        }
        T* operator ->()           // 重载->操作符
        {
            return rp->p;
        } 
        ~SmartPtr()                // 析构函数 
        {
            if (--rp->count == 0)  // 当引用计数减为0时，删除辅助类对象指针，从而删除基础对象 
                delete rp;
            else
                cout << "还存在" << rp->count << "个指针指向基础对象" << endl; 
        }
}; 
int main()
{
    int *i = new int(2);
    {
        SmartPtr<int> ptr1(i);
        {
            SmartPtr<int> ptr2(ptr1);
            {
                SmartPtr<int> ptr3 = ptr2;
                cout << *ptr1 << endl;
                *ptr1 = 20;
                cout << *ptr2 << endl;
            } 
        }
    }
    return 0;
}

参看文献

http://mp.weixin.qq.com/s?__biz=MzAxNDI5NzEzNg==&mid=2651156666&idx=1&sn=4109903d526468f5913922d2f06e5a1a&scene=23&srcid=0528aIzOIN05Z0MQKuw7HrwJ#rd