c++学习：智能指针的底层作用原理+用法

码农小白

已于 2024-01-10 01:38:40 修改

阅读量483

点赞数 7

分类专栏： c++ 文章标签： c++ 学习开发语言

于 2024-01-10 01:35:25 首次发布

本文链接：https://blog.csdn.net/weixin_59669309/article/details/135492852

版权

c++ 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

思考；如果多个智能指针同时指向同一个堆空间，怎么只执行一次析构函数进行释放空间（共享智能指针类）

智能指针作用原理

如果分配了一个内存空间，但后面又忘记释放空间，会造成内存泄漏，智能指针就可以自动释放空间，避免内存泄漏。

智能指针是一个RAII类模型，用于动态分配内存，其设计思想是将基本类型指针封装为(模板)类对象指针，并在离开作用域时调用析构函数，使用delete删除指针所指向的内存空间。

作用

能够处理内存泄漏问题和空悬指针问题

原理

像类一样，有构造函数和析构函数，当申请的时候就是构造函数，当不用了，就自动运行析构函数来释放空间

模仿int*类型的智能指针

class shared_ptr
{
public:
    //等价于int *p = new int(100)
    shared_ptr(int*p):ptr(p){}
    ~shared_ptr()
    {
        cout<<__FUNCTION__<<endl;
        if(this->ptr != NULL)
        {
            delete this->ptr;
        }
    }
    int*get()
    {
        return this->ptr;
    }
private:
    int*ptr;
};

void test()
{
    //正常申请内存空间
    int *p = new int(100);
    *p = 200;
    cout<<*p<<endl;
    delete p;

    //模仿智能指针申请内存空间
    shared_ptr p1(new int(100));
    *(p1.get()) = 200;
    cout<<*(p1.get())<<endl;
}

模仿所有类型的智能指针（模板）

template<class T>
class shared_ptr
{
public:
    //int *p = new int(100)
    shared_ptr(T*p):ptr(p){}
    ~shared_ptr()
    {
        cout<<__FUNCTION__<<endl;
        if(this->ptr != NULL)
        {
            delete this->ptr;
        }
    }
    T*get()
    {
        return this->ptr;
    }
private:
    T*ptr;
};

//例子 ：申请一个类的智能指针
class Demo
{
public:
    Demo()
    {
        cout<<"Demo()"<<endl;
    }
    ~Demo()
    {
        cout<<"~Demo()"<<endl;
    }
private:
    int data;
};

void test01()
{
    shared_ptr<Demo> p1(new Demo);
}

共享智能指针类

思考；如果多个智能指针同时指向同一个堆空间，怎么只执行一次析构函数进行释放空间（共享智能指针类）

解决办法：每当有一个智能指针指向一个堆空间，就记录一次，当有第二个智能指针指向该空间，就+1，每当一个智能指针执行析构函数的时候就-1，判断是否是最后一个指向该空间的智能指针再决定释放空间

template<class T>
class shared_ptr
{
public:
    //int *p = new int(100)
    shared_ptr(T*p):ptr(p){}
    shared_ptr(shared_ptr &ra)
    {
        ptr = ra.ptr;
        count++;
    }
    ~shared_ptr()
    {
        cout<<__FUNCTION__<<endl;
        if(this->ptr != NULL && --count == 0)
        {
            //最后一个对象被销毁的时候，才执行里面的代码
            delete this->ptr;
            this->ptr = NULL;
            cout<<"count == 0"<<endl;
        }
    }
    T*get()
    {
        return this->ptr;
    }
private:
    T*ptr;
    static int count;//要在类外定义初始化
};

template<class T>
int shared_ptr<T>::count=0;

class Demo
{
public:
    Demo()
    {
        cout<<"Demo()"<<endl;
    }
    ~Demo()
    {
        cout<<"~Demo()"<<endl;
    }
    void setData(int d)
    {
        data = d;
    }
private:
    int data;
};

void test01()
{
    //多个智能指针类的对象可以管理 同一个堆空间
    shared_ptr<Demo> p2(new Demo);
    shared_ptr<Demo> p3(p2);
    shared_ptr<Demo> p4(p3);
    shared_ptr<Demo> p5(p4);

    p2.get()->setData(100);
}

独占式智能指针

如果是独占式智能指针，shared_ptr<Demo> p3(p2);这种写法会报错，因为智能有一个智能指针指向该堆空间

template<class T>
class unique_ptr
{
    //方法1：将拷贝构造函数声明为私有，外面的无法调用
    //unique_ptr(unique_ptr &ra);
public:
    unique_ptr(T*p):ptr(p){}
    //方法2：在拷贝构造函数的声明后面加上delete关键字 ，表示这个函数不能被调用
    unique_ptr(unique_ptr &ra) = delete;
    ~unique_ptr()
    {
        cout<<__FUNCTION__<<endl;
        if(this->ptr != NULL)
        {
            delete this->ptr;
            this->ptr = NULL;
        }
    }
    T*get()
    {
        return this->ptr;
    }
private:
    T*ptr;
    static int count;//要在类外定义初始化
};

c++提供的标准智能指针

头文件

#include <memory>

标准智能指针模板类的成员类型和成员函数

std::shared_ptr - cppreference.comhttps://zh.cppreference.com/w/cpp/memory/shared_ptr

用法

#include <iostream>
#include <memory> //C++智能指针类的头文件

using namespace std;

int main()
{
    shared_ptr<int> ptr1(new int(120));

    *(ptr1.get()) = 1000;

    unique_ptr<char> ptr2(new char);

    return 0;
}