【C++】————智能指针

2024-08-22 15:42:08 浏览数 (1)

一，什么是智能指针

在C 中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加1，每析构一次内部的引用计数减1，减为0时，删除所指向的堆内存。

  • c 中用的最多的是下面三种智能指针

C 11中提供了三种智能指针，使用这些智能指针时需要引用头文件<memory>

  • std::shared_ptr：共享的智能指针
  • std::unique_ptr：独占的智能指针
  • std::weak_ptr：弱引用的智能指针，它不共享指针，不能操作资源，是用来监视shared_ptr的。

二，共享的智能指针shared_ptr

  • 首先了解一下基本概念，再看代码，会学的很快
1. shared_ptr的初始化

共享智能指针是指多个智能指针可以同时管理同一块有效的内存，共享智能指针shared_ptr 是一个模板类，如果要进行初始化有三种方式：通过构造函数、std::make_shared辅助函数以及reset方法。共享智能指针对象初始化完毕之后就指向了要管理的那块堆内存，如果想要查看当前有多少个智能指针同时管理着这块内存可以使用共享智能指针提供的一个成员函数use_count

2.获取原始指针

对应基础数据类型来说，通过操作智能指针和操作智能指针管理的内存效果是一样的，可以直接完成数据的读写。但是如果共享智能指针管理的是一个对象，那么就需要取出原始内存的地址再操作，可以调用共享智能指针类提供的get()方法得到原始地址

3. 指定删除器

当智能指针管理的内存对应的引用计数变为0的时候，这块内存就会被智能指针析构掉了。另外，我们在初始化智能指针的时候也可以自己指定删除动作，这个删除操作对应的函数被称之为删除器，这个删除器函数本质是一个回调函数，我们只需要进行实现，其调用是由智能指针完成的。

下面我们来看一下代码如何实现：

代码语言：javascript复制
#pragma once
#include <iostream>
#include <functional>


namespace zy
{
    template<class T>
    class shared_ptr
    {
    public:
        shared_ptr(T* ptr = nullptr) 
            : _ptr(ptr)
            , _pcount(ptr ? new int(1) : nullptr)
        {
            std::cout << "shared_ptr(T* ptr)" << std::endl;
        }

        template<class D>
        shared_ptr(T* ptr = nullptr,D del)
            : _ptr(ptr)
            , _pcount(ptr ? new int(1) : nullptr)
            , _del(del)
        {}

        shared_ptr(const shared_ptr& sp) 
            : _ptr(sp._ptr)
            , _pcount(sp._pcount)
        {
              (*_pcount);
            std::cout << "Copy constructor" << std::endl;
        }

        shared_ptr& operator=(const shared_ptr& sp)
        {
            if (this != &sp)
            {
                // 释放当前对象管理的资源（如果有）
                this->Realease();

                _ptr = sp._ptr;
                _pcount = sp._pcount;
                  (*_pcount);
            }
            return *this;
        }

        ~shared_ptr()
        {
            Realease();
        }

        void Realease()
        {
            if (_pcount && --(*_pcount) == 0)
            {
                //delete _ptr;
                _del(_ptr);

                delete _pcount;
                _ptr = nullptr;
                _pcount = nullptr;
            }
        }

        T* get()
        {
            return _ptr;
        }

        int use_count()
        {
            return _pcount ? *_pcount : 0;
        }

        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }

    private:
        T* _ptr;
        int* _pcount;

        fuction<void(T* ptr)>_del = [](T* ptr) {delete ptr};
    };
}

三，独占的智能指针unique_ptr

1. 初始化

std::unique_ptr是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针，可以通过它的构造函数初始化一个独占智能指针对象，但是不允许通过赋值将一个unique_ptr赋值给另一个unique_ptr。

2. 删除器

unique_ptr指定删除器和shared_ptr指定删除器是有区别的，unique_ptr指定删除器的时候需要确定删除器的类型，所以不能像shared_ptr那样直接指定删除器

代码语言：javascript复制
#pragma once
#include <iostream>

template <typename T>
class unique_ptr {
public:
    // 构造函数，接受一个原始指针并接管其所有权
    unique_ptr(T* ptr = nullptr) 
     : ptr_(ptr) 
    {}

    // 移动构造函数，转移所有权
    unique_ptr(unique_ptr&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }

    // 移动赋值运算符，转移所有权
    unique_ptr& operator=(unique_ptr&& other) noexcept {
        if (this!= &other) {
            reset();
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }

    // 析构函数，释放所管理的资源
    ~unique_ptr() {
        reset();
    }

    // 解引用操作符
    T& operator*() const {
        return *ptr_;
    }

    // 箭头操作符
    T* operator->() const {
        return ptr_;
    }

    // 获取原始指针
    T* get() const {
        return ptr_;
    }

    // 释放所管理的资源并将指针置为 nullptr
    void reset(T* ptr = nullptr) {
        if (ptr_) {
            delete ptr_;
        }
        ptr_ = ptr;
    }

private:
    T* ptr_;
};

四， 弱引用的智能指针weak_ptr

弱引用智能指针std::weak_ptr可以看做是shared_ptr的助手，它不管理shared_ptr内部的指针。std::weak_ptr没有重载操作符*和->，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视shared_ptr中管理的资源是否存在。

1 初始化

弱引用智能指针std::weak_ptr可以看做是shared_ptr的助手，它不管理shared_ptr内部的指针。std::weak_ptr没有重载操作符*和->，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视shared_ptr中管理的资源是否存在。

代码语言：javascript复制
#include <iostream>
#include <memory>
using namespace std;
 
int main() 
{
    shared_ptr<int> sp(new int);
 
    weak_ptr<int> wp1;
    weak_ptr<int> wp2(wp1);
    weak_ptr<int> wp3(sp);
    weak_ptr<int> wp4;
    wp4 = sp;
    weak_ptr<int> wp5;
    wp5 = wp3;
    
    return 0;
}
  1. weak_ptr<int> wp1;构造了一个空weak_ptr对象
  2. weak_ptr<int> wp2(wp1);通过一个空weak_ptr对象构造了另一个空weak_ptr对象
  3. weak_ptr<int> wp3(sp);通过一个shared_ptr对象构造了一个可用的weak_ptr实例对象
  4. wp4 = sp;通过一个shared_ptr对象构造了一个可用的weak_ptr实例对象（这是一个隐式类型转换）
  5. wp5 = wp3;通过一个weak_ptr对象构造了一个可用的weak_ptr实例对象
  • 通过调用std::weak_ptr类提供的use_count()方法可以获得当前所观测资源的引用计数
2.常用函数

通过调用std::weak_ptr类提供的expired()方法来判断观测的资源是否已经被释放 通过调用std::weak_ptr类提供的lock()方法来获取管理所监测资源的shared_ptr对象 通过调用std::weak_ptr类提供的reset()方法来清空对象，使其不监测任何资源

  • 利用weak_ptr可以解决shared_ptr的一些问题

  1. 返回管理this的shared_ptr
  2. 解决循环引用问题

最后：

十分感谢你可以耐着性子把它读完和我可以坚持写到这里，送几句话，对你，也对我：

1.一个冷知识： 屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。

2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。 正所谓：君子可内敛不可懦弱，面不公可起而论之。

3.成年人的世界，只筛选，不教育。

4.自律不是6点起床，7点准时学习，而是不管别人怎么说怎么看，你也会坚持去做，绝不打乱自己的节奏，是一种自我的恒心。

5.你开始炫耀自己，往往都是灾难的开始，就像老子在《道德经》里写到：光而不耀，静水流深。

最后如果觉得我写的还不错，请不要忘记点赞✌，收藏✌，加关注✌哦(｡･ω･｡)

愿我们一起加油，奔向更美好的未来，愿我们从懵懵懂懂的一枚菜鸟逐渐成为大佬。加油，为自己点赞！

对象 管理 内存 指针 c++

0 人点赞