基于C++实现一个简单的智能指针类-蒲公英云

基于C++实现一个简单的智能指针类

Dear 丶 2022-06-16 01:28 363阅读 0赞

在C、C++类的语言当中对指针的使用是十分常见和重要的，但是使用指针也很容易导致内存泄漏、不安全的情况发生，本文就针对这种情况来实现一个简单的智能指针类，通过这个类实现对指针操作的封装，降低使用指针带来的负面影响。

一、实现智能指针的两个类

1、RefBase类

这个类的具体实现如下：

/* 定义一个引用计数的基类 */
class RefBase{
private:
    int cnt;    // 引用计数的数值
public:
    RefBase() : cnt(0){}         // 通过构造函数将引用计数的初值设为0
    void incStrongCnt(void){this->cnt++;}        // 引用计数加一
    void decStrongCnt(void){this->cnt--;}        // 引用计数减一 
    int getStrongCnt(void){return this->cnt;}    // 获得引用计数
};

这是一个使用智能指针的所有类都要继承的基类，通过这个类中的引用计数的相关操作来判定当前类的引用计数是否为0，以此来判断当前指针对象是否可以是否，确保内存释放的安全性。
2、SP类

这是指针指针实现的核心类，它的实现具体如下：

/* 定义智能指针的模板类 */
template<typename T> class SP{
private:
    T *p;
public:
    SP() : p(0){}    // 空的构造函数
    SP(T *other)    // 定义赋值构造函数，把对象指针作为参数赋值给智能指针对象的私有属性
    {
        this->p = other;
        p->incStrongCnt();
    }
    SP(const SP&  other)    // 定义拷贝构造函数
    {
        this->p = other.p;
        p->incStrongCnt();
    }
    ~SP()    // 定义析构函数，当引用计数为0时，释放对象
    {
        if(p)
        {
            p->decStrongCnt();    
            if(p->getStrongCnt() == 0)    // 判断引用计数是否为0
                delete p;
        }
    }
    /* 定义指向操作的运算符重载 */
    T* operator->()
    {
        return this->p;
    }
    /* 定义应用操作的运算符重载 */
    T& operator*()
    {
        return *(this->p);
    }
};

在这个类中实现了基本的赋值构造函数和拷贝构造函数，有因为是对指针的操作所以实现了基本的引用、指向操作符的重载。

二、测试
实现一个简单的小例子来对智能指针进行测试，为此定义了一个Demo类，这个类的具体实现如下（注意这个类的必须继承至RefBase类）：

/* 定义一个测试类来测试智能指针 */
class Demo : public RefBase{
public :
    /* 定义构造函数和析构函数用来进行测试 */
    Demo(){cout << "Demo()" << endl;}        
    ~Demo(){cout << "~Demo()" << endl;}
    void printInfo(){cout << "Hello,world!" << endl;}    // 定义一个测试函数
};

在main函数中实现如下代码：

/* 定义一个demo的智能指针对象 */
SP<Demo> demo = new Demo();
demo->printInfo();
SP<Demo> demo2 = demo;    // 将demo直接赋值给demo2，调用拷贝构造函数
demo2->printInfo();

编译并运行试验结构如下：

Center

附录：本文实现的完整例程如下所示。

#include <iostream>
using namespace std;
/* 定义一个引用计数的基类 */
class RefBase{
private:
    int cnt;    // 引用计数的数值
public:
    RefBase() : cnt(0){}         // 通过构造函数将引用计数的初值设为0
    void incStrongCnt(void){this->cnt++;}        // 引用计数加一
    void decStrongCnt(void){this->cnt--;}        // 引用计数减一 
    int getStrongCnt(void){return this->cnt;}    // 获得引用计数
};
/* 定义智能指针的模板类 */
template<typename T> class SP{
private:
    T *p;
public:
    SP() : p(0){}    // 空的构造函数
    SP(T *other)    // 定义赋值构造函数，把对象指针作为参数赋值给智能指针对象的私有属性
    {
        this->p = other;
        p->incStrongCnt();
    }
    SP(const SP&  other)    // 定义拷贝构造函数
    {
        this->p = other.p;
        p->incStrongCnt();
    }
    ~SP()    // 定义析构函数，当引用计数为0时，释放对象
    {
        if(p)
        {
            p->decStrongCnt();    
            if(p->getStrongCnt() == 0)    // 判断引用计数是否为0
                delete p;
        }
    }
    /* 定义指向操作的运算符重载 */
    T* operator->()
    {
        return this->p;
    }
    /* 定义应用操作的运算符重载 */
    T& operator*()
    {
        return *(this->p);
    }
};
/* 定义一个测试类来测试智能指针 */
class Demo : public RefBase{
public :
    /* 定义构造函数和析构函数用来进行测试 */
    Demo(){cout << "Demo()" << endl;}        
    ~Demo(){cout << "~Demo()" << endl;}
    void printInfo(){cout << "Hello,world!" << endl;}    // 定义一个测试函数
};
/* 程序的入口函数 */
int main(int argc, char *argv[])
{
    /* 定义一个demo的智能指针对象 */
    SP<Demo> demo = new Demo();
    demo->printInfo();
    SP<Demo> demo2 = demo;    // 将demo直接赋值给demo2，调用拷贝构造函数
    demo2->printInfo();
    return 0;
}