C++之智能指针（shared_ptr, unique_ptr, weak_ptr)

谁借莪１个温暖的怀抱￠ 2022-10-15 12:48 19阅读 0赞

## 动态内存与智能指针 ##

1.  C++动态内存是通过new（在堆中为对象分配空间并返回一个指向该对象的指针）和delete（接受一个动态对象指针并销毁它释放内存）完成。
2.  使用动态内存容易出问题：
    
     *  会**忘记释放内存**从而内存泄漏
     *  在还有指针引用内存时候就释放了它从而产生引用非法内存的指针。
3.  C++11 提供了两种**智能指针**类型来管理动态对象。它与普通指针类似，只是它负责自动释放所指向的对象。

### shared\_ptr类 ###

**多个指针指向同一个对象**，当指向一个对象的最后一个shared\_ptr被销毁时，shared\_ptr类会自动销毁（析构函数）此对象。析构函数会递减它所指向的对象的引用计数，如果变为0，则析构函数会销毁对象并释放内存。

初始化shared\_ptr如下：

#include<memory> // shared_ptr<T>的定义位于<memory>头文件
    using namespace std;
    
    // shared_ptr智能指针的创建
    shared_ptr<int> p1; // 不传入任何实参 
    shared_ptr<int> p2(nullptr); // 传入空指针nullptr
    shared_ptr<int> p3(new int(10)); // 也可以明确其指向，指向一块存有10这个int类型数据的堆内存空间
    
    shared_ptr<int> p3 = make_shared<int>(10);// 同上 是一种最安全的分配和使用动态内存的方法
    
    // shared_ptr<T>提供拷贝构造和移动构造函数
    shared_ptr<int> p4(p3); // 拷贝构造函数 或 shared_ptr<int> p4 = 3;
    // p3 和 p4 都是 shared_ptr 类型的智能指针，因此可以用 p3 来初始化 p4，由于 p3 是左值，因此会调用拷贝构造函数。
    // 如果 p3 为空智能指针，则 p4 也为空智能指针，其引用计数初始值为 0；反之，则表明 p4 和 p3 指向同一块堆内存，同时该堆空间的引用计数会加 1。
    
    shared_ptr<int> p5(move(p4)); // 移动构造函数 或 shared_ptr<int> p5 = move(p4);
    // std::move(p4) 来说，该函数会强制将 p4 转换成对应的右值，因此初始化 p5 调用的是移动构造函数。
    // 另外和调用拷贝构造函数不同，用 std::move(p4) 初始化 p5，会使得 p5 拥有了 p4 的堆内存，而 p4 则变成了空智能指针。
    
    // 自定义释放规则
    //指定 default_delete 作为释放规则
    std::shared_ptr<int> p6(new int[10], std::default_delete<int[]>());
    
    //自定义释放规则
    void deleteInt(int*p) {
        
        delete []p;
    }
    //初始化智能指针，并自定义释放规则
    std::shared_ptr<int> p7(new int[10], deleteInt);

测试shared\_ptr如下：

#include<iostream>
    #include<memory>
    using namespace std;
    int main()
    {
        
        // 构建2个shared_ptr
        std::shared_ptr<int> p1(new int(10));
        std::shared_ptr<int> p2(p1);
        // 输出p2指向的数据
        cout<<*p2<<endl;
        cout << p2.use_count() << endl;
        p1.reset(); // 引用计数减1，p1为空指针
        if (p1) {
        
            cout << "p1 is not null" << endl;
        }
        else {
        
            cout << "p1 is nullptr" << endl;
        }
        //以上操作，并不会影响 p2
        cout << *p2 << endl;
        //判断当前和 p2 同指向的智能指针有多少个
        cout << p2.use_count() << endl;
        return 0;
    }

#### 自己实现一个shared\_ptr类 ####

#include<bits/stdc++.h>
    using namespace std;
    
    template<typename T>
    class my_shared_ptr
    {
        
        private:
            T* m_ptr = nullptr;
            unsigned int* m_ref_count = nullptr; // 指向相同资源的所有shared_ptr共享引用计数管理区域
        public:
            // 构造函数
            my_shared_ptr():m_ptr(nullptr), m_ref_count(nullptr){
        }
            my_shared_ptr(T* ptr): m_ptr(ptr), m_ref_count(new unsigned int(1)){
        }
    
            // 拷贝构造函数
            my_shared_ptr(const my_shared_ptr& obj){
        
                m_ptr = obj.m_ptr;
                m_ref_count = obj.m_ref_count;
                if(m_ref_count != nullptr){
        
                    (*m_ref_count)++;
                }
            }
    
            // 拷贝赋值函数
            my_shared_ptr& operator=(const my_shared_ptr& obj){
        
                delete m_ptr;
                m_ptr = obj.m_ptr;
                delete m_ref_count;
                m_ref_count = obj.m_ref_count;
                if(m_ref_count != nullptr){
        
                    *(m_ref_count)++;
                }
                return *this; // *this是自身对象
            }
    
            // 移动构造函数
            my_shared_ptr(my_shared_ptr&& dying_obj):m_ptr(nullptr), m_ref_count(nullptr){
        
                dying_obj.swap(*this);
            }
    
            // 移动赋值函数
            my_shared_ptr & operator=(my_shared_ptr && dying_obj){
        
                //my_shared_ptr(std::move(dying_obj))用移动构造函数创建出一个新的shared_ptr(此时dying_obj的内容被清除了)
                //再和this交换指针和引用计数
                //因为this被交换到了当前的临时创建的my_shared_ptr里，this的引用计数-1
                my_shared_ptr(std::move(dying_obj)).swap(*this);
                return *this;
            }
    
            void swap(my_shared_ptr& other){
        
                std::swap(m_ptr, other.m_ptr);
                std::swap(m_ref_count, other.m_ref_count);
            }
    
            // ->, * 运算符重载
            T* operator->() const{
        
                return m_ptr;
            }
            
            T& operator*() const{
        
                return m_ptr;
            }
    
            // 返回my_shared_ptr对象中保存的指针
            T* get() const{
        
                return m_ptr;
            }
    
            // 获得引用计数
            unsigned int use_count() const{
        
                return m_ref_count == nullptr ? 0 : *m_ref_count;
            }
    
            ~my_shared_ptr(){
        
                if(m_ref_count == nullptr) return;
                (*m_ref_count)--;
                if(*m_ref_count > 0){
        
                    return;
                }
                // *m_ref_count == 0
                if(m_ptr != nullptr){
        
                    delete m_ptr;
                }
                delete m_ref_count;
            }
    };

### unique\_ptr ###

与shared\_ptr不同，某时刻**只能有一个**unique\_ptr指向一个给定对象。当unique\_ptr被销毁，其所指向对象也被销毁。

#include<memory>
    using namespace std;
    
    // 创建空的unique_ptr 指针
    std::unique_ptr<int> p1();
    std::unique_ptr<int> p2(nullptr);
    
    // 明确指向的是可容纳1个整数的堆存储空间
    std::unique_ptr<int> p3(new int);
    
    std::unique_ptr<int> p4(new int);
    // std::unique_ptr<int> p5(p4);//错误，堆内存不共享
    std::unique_ptr<int> p5(std::move(p4));//正确，调用移动构造函数，p5获取p4所指的堆空间所有权，p4变为空指针
    
    // 默认unique_ptr指针采用default_delete<T> 方法释放堆内存
    // unique_ptr自定义释放规则只能采用函数对象方式
    struct myDel
    {
        
        void operator()(int *p){
        
            delete p;
        }
    };
    
    std::unique_ptr<int, myDel> p6(new int);
    //std::unique_ptr<int, myDel> p6(new int, myDel());

#include <iostream>
    #include <memory>
    using namespace std;
    int main()
    {
        
        std::unique_ptr<int> p5(new int);
        *p5 = 10;
        // p 接收 p5 释放的堆内存
        int * p = p5.release();
        cout << *p << endl;
        //判断 p5 是否为空指针
        if (p5) {
        
            cout << "p5 is not nullptr" << endl;
        }
        else {
        
            cout << "p5 is nullptr" << endl;
        }
        std::unique_ptr<int> p6;
        //p6 获取 p 的所有权
        p6.reset(p);
        cout << *p6 << endl;;
        return 0;
    }

### weak\_ptr ###

weak\_ptr不控制所指向对象生存期的智能指针，即绑定到一个shared\_ptr也不会改变shared\_ptr的引用计数。

#include <iostream>
    #include <memory>
    using namespace std;
    int main()
    {
        
        std::shared_ptr<int> sp1(new int(10));
        std::shared_ptr<int> sp2(sp1);
        std::weak_ptr<int> wp(sp2);
        //输出和 wp 同指向的 shared_ptr 类型指针的数量
        cout << wp.use_count() << endl;
        //释放 sp2
        sp2.reset();
        cout << wp.use_count() << endl;
        //借助 lock() 函数，返回一个和 wp 同指向的 shared_ptr 类型指针，获取其存储的数据
        cout << *(wp.lock()) << endl;
        return 0;
    }