CppBoost（智能指针）

已于 2024-09-08 13:26:21 修改
阅读量458 收藏 2
点赞数 8
文章标签： c++ 学习
于 2024-09-05 12:14:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyland11/article/details/141926503
版权

在这里插入图片描述

智能指针基础知识

裸指针

#include<iostream>

using namespace std;

int main()
{
    int *p = new int(10);   //动态分配内存并初始化为10（堆空间）

    *p = 20;                     

    delete p;   //释放内存

    return 0;
}

裸指针可能引发的问题：用户忘记手动释放、程序在 delete 之前某个地方条件成立提前退出等
那我们在使用指针的过程中如何做到无论我们程序发生异常亦或其他情况都能够稳定的释放内存呢？
这里我们引出了 智能指针

智能指针

智能指针其实就是对裸指针的一种封装，那么智能指针是如何做到自动释放内存的呢？一个简单的智能指针封装示例：

template<typename T>
class CSmartPtr
{
public:
	CSmartPtr(T *ptr = nullptr)
		:mptr(ptr) {}
	~CSmartPtr()	{ delete mptr; }
	T& operator*()	{ return *mptr; }

private:
	T *mptr;
};

int main()
{
	CSmartPtr<int> ptr1(new int);
	*ptr1 = 20;

	return 0;
}

从示例代码我们可以看出，构造了一个智能指针类将裸指针包装成私有成员变量使用，并定义了成员方法对裸指针进行解引用操作，main函数中定义了一个智能指针，然后进行解引用操作，当main函数结束，系统会自动调用智能指针中类的析构方法进行堆内存释放，这样就做到了稳定释放内存的效果，其原理是利用了 栈上对象出作用域自动析构 这个特征，来代替 堆上内存的手动释放

智能指针的浅拷贝问题

#include<iostream>
#include<memory>

using namespace std;

template<typename T>
class CSmartPtr
{
public:
    CSmartPtr(T *ptr = nullptr)
        :mptr(ptr){}
    ~CSmartPtr()  { delete mptr; }
    T& operator*() { return *mptr; }
    
private:
    T *mptr;
};

int main()
{
    CSmartPtr<int> p1(new int);
    CSmartPtr<int> p2(p1);
    *p1 = 10;
    cout << *p2 << endl;

    return 0;
}

在这里插入图片描述
我们可以看到，当我们调用拷贝构造构造一个对象 p2 ，再给 p1 赋值最后输出 p2，出现了两次释放内存的报错，这是因为 调用默认拷贝构造函数构造的新对象与原对象共享一块内存，造成的浅拷贝问题，调用 p1 的析构释放内存的时候，原内存已经被释放了；如何解决这样的浅拷贝问题呢？

#include<iostream>
#include<memory>

using namespace std;

template<typename T>
class CSmartPtr
{
public:
    CSmartPtr(T *ptr = nullptr)
        :mptr(ptr){}
    CSmartPtr(const CSmartPtr<T>& src)
    {   
        mptr = new T(*src.mptr);
    }
    ~CSmartPtr()  { delete mptr; }
    T& operator*() { return *mptr; }
    
private:
    T *mptr;
};

int main()
{
    CSmartPtr<int> p1(new int);
    CSmartPtr<int> p2(p1);
    *p1 = 10;
    cout << *p2 << endl;

    return 0;
}

这里我们对加上了一段拷贝构造函数，尝试利用一般的解决浅拷贝问题的方法优化
在这里插入图片描述
输出结果为 0 ，并不与 p1 的值相同，这说明 p1、 p2 都有各自的内存空间，并不指向同一块内存；
从用户需求来看，拷贝构造 p1 之后，新对象 p2 内存中的值应该与 p1 相同（两个不同地址的裸指针可以指向同一块内存），显然这样的避免浅拷贝的方法是不可行的

不带引用计数的智能指针

不带引用计数的智能指针：一个指针只能管理一块资源，不同的指针无法管理同一块资源

auto_ptr(已弃用）

#include<iostream>
#include<memory>
using namespace std;

int main()
{
    auto_ptr<int> p1;
    auto_ptr<int> p2(p1);

    return 0;
}

在这里插入图片描述
auto_ptr 解决浅拷贝的方法是将原指针的内存空间转移到新拷贝的指针空间上，会导致原指针无法使用，但用户无法感知这样的对象资源的转移

scoped_ptr

scoped_ptr 移除拷贝构造和赋值运算符重载，禁止了指针的拷贝，从而解决了浅拷贝问题

unique_ptr

#include<iostream>
#include<memory>
using namespace std;

int main()
{
    unique_ptr<int> p1(new int);

    *p1 = 10;
    
    unique_ptr<int> p2(move(p1));

    cout << *p2 << endl;

    return 0;
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

unique_ptr 同样删除了左值引用的拷贝构造和赋值运算符重载函数，与 scoped_ptr 不同的是其添加了右值引用的拷贝构造和赋值运算符重载函数，通过移动语义调用移动构造，做到了显式的资源转移

带引用计数的智能指针

带引用计数的智能指针：多个智能指针可以管理同一个资源，并给每一个对象匹配一个引用计数
当智能指针管理资源的时候，引用计数加一；不使用资源的时候，引用计数减一，当智能指针引用计数为零时，析构要释放内存,一个带引用计数的智能指针的实现

#include<iostream>
#include<memory>

using namespace std;

template<typename T>
class RefCount
{
public:
    RefCount(T *ptr = nullptr)
        :mptr(ptr)
        {
            if(mptr)
                m_count = 1;
        }
    void addRef(){ m_count++; }
    int delRef() { return --m_count;}

private:
    T *mptr;
    int m_count;
};

template<typename T>
class CSmartPtr
{
public:
    CSmartPtr(T *ptr = nullptr)
        :mptr(ptr)
        {
            refCount = new RefCount<T>(mptr);
        }
    ~CSmartPtr()  
    {
        if(refCount->delRef() == 0)
        {
            delete mptr;
            mptr = nullptr;
        }
        
    }

    CSmartPtr(const CSmartPtr<T>& src)
        :mptr(src.mptr),refCount(src.refCount)
        {
            if(mptr)
                refCount->addRef();
        }

    CSmartPtr<T>& operator=(const CSmartPtr<T>& src)    
    {
        if(this == &src)
            return *this;

        if(0 == refCount->delRef())
        {
            delete mptr;
            mptr = nullptr;
        }

        mptr = src.mptr;
        refCount = src.refCount;
        if(mptr)    
            refCount->addRef();

        return *this;
    }
    T* operator->() { return mptr; }
    T& operator*() { return *mptr; }
    
private:
    T *mptr;
    RefCount<T> *refCount;
};

int main()
{
    CSmartPtr<int> p1(new int);
    CSmartPtr<int> p2(p1);
    *p1 = 10;
    cout << "p2 = " << *p2 << endl;

    return 0;
}

shared_ptr 和 weak_ptr

shared_ptr ：强智能指针，可以改变引用计数
weak_ptr：弱智能指针，不可改变引用计数

shared_ptr 的交叉引用问题

#include<iostream>
#include<memory>
using namespace std;

class B;
class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    shared_ptr<B> _ptrb;
};

class B
{
public:
    B() { cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }
    shared_ptr<A> _ptra;
};

int main()
{
    shared_ptr<A> pa(new A());
    shared_ptr<B> pb(new B());
   
    cout << pa.use_count() << endl;
    cout << pb.use_count() << endl;

    return 0;
}

在这里插入图片描述

int main()
{
    shared_ptr<A> pa(new A());
    shared_ptr<B> pb(new B());
   
    pa->_ptrb = pb;
    pb->_ptra = pa;
    
    cout << pa.use_count() << endl;
    cout << pb.use_count() << endl;

    return 0;
}

在这里插入图片描述
可以看到，当增加 pa->_ptrb = pb; pb->_ptra = pa;时，输出结果没有调用析构函数，会造成内存泄露
在这里插入图片描述
如何解决强智能指针的交叉引用问题？
定义对象用强智能指针，引用对象用弱智能指针
引用对象时需要二者一起使用，参考如下代码 ：

#include<iostream>
#include<memory>
using namespace std;

class B;
class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void testA()    { cout << "this is a good way" << endl;}
    weak_ptr<B> _ptrb;
};

class B
{
public:
    B() { cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }
    void func()
    {
        shared_ptr<A> ps = _ptra.lock();	//方法提升
        if(ps)
        {
            ps->testA();
        }
    }
    weak_ptr<A> _ptra;
};



int main()
{
    shared_ptr<A> pa(new A());
    shared_ptr<B> pb(new B());
   
    pa->_ptrb = pb;
    pb->_ptra = pa;
    
    cout << pa.use_count() << endl;
    cout << pb.use_count() << endl;

    return 0;
}

运行：
在这里插入图片描述

多线程访问共享对象的线程安全问题

#include<iostream>
#include<memory>
#include<thread>

using namespace std;

class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void func() { cout << "this is a good way" << endl; }   
};

void handler(A* p)
{
    std::this_thread::sleep_for(std::chrono::seconds(20));
    p->func();
}

int main()  
{
    A *p = new A(); 
    thread t(handler, p);
    
    delete p;
    t.join();	//等待子线程结束

    return 0;
}

上述代码提供了一个场景，当子线程 t 调用 p对象中的 func 函数之前会睡眠 20 秒，但此时主线程中
对象p资源已经被释放，显然是不合理的；handler 线程调用func函数在安全的情况下，应该先侦测A对象是否存活，这里我们使用强智能指针和弱智能指针优化：

#include<iostream>
#include<memory>
#include<thread>

using namespace std;

class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void func() { cout << "this is a good way" << endl; }   
};

void handler(weak_ptr<A> pw)
{
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    shared_ptr<A> ps = pw.lock();
    if(ps)
    {
        ps->func();
    }
    else
    {
        cout << "ps is null" << endl;
    }
}

int main()  
{
    {
        shared_ptr<A> p(new A());
        thread t(handler, weak_ptr<A> (p));
        t.detach();
    }
    
    std::this_thread::sleep_for(std::chrono::seconds(10));

    return 0;
}

在这里插入图片描述
可以看到，此时主函数中 A 对象出作用域析构时，fun睡眠 2 秒，未被调用，尝试让线程 t 在 A 未被析构前调用方法，加上睡眠函数：

int main()  
{
    {
        shared_ptr<A> p(new A());
        thread t(handler, weak_ptr<A> (p));
        t.detach();

        std::this_thread::sleep_for(std::chrono::seconds(5));
    }
    
    std::this_thread::sleep_for(std::chrono::seconds(10));

    return 0;
}

在这里插入图片描述

Eyelar
关注
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
智能指针讲稿11111
07-14
《智能指针详解》 智能指针是C++11新引入的重要特性，它是一种自动管理内存的对象，旨在解决传统指针在内存管理中可能引发的问题，如野指针、内存泄漏和重复释放等。本文将详细介绍C++11中的三种智能指针：unique_...
智能指针ppt1111
07-14
智能指针是C++中用于自动管理动态内存的一种工具，它们在程序运行过程中自动负责对象的创建和销毁，从而避免了常见的内存管理问题，如野指针、重复释放和内存泄漏。在C++98中引入了`auto_ptr`，而在C++11标准中，...
Android系统智能指针
09-21
在计算机系统中，资源是数量有限且对系统正常运行具有一定作用的元素。...不过系统为我们提供了智能指针，避免出现上述问题，本文将系统地分析Android系统智能指针（轻量级指针、强指针和弱指针）的实现原理。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1700
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C语言】数据类型和变量
2302_76713442的博客
10-06 1381
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
C++：图的最短路径问题
han2205277149的博客
10-04 1078
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
贪心算法c++
最新发布
hjxxlsx的博客
10-07 1557
贪心选择性质活动安排问题问题描述选择。
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 422
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1399
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
Ddddddd_158的博客
10-01 380
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
【C++】STL--vector
2301_78724721的博客
10-03 897
/类模板只能实例化//初始化10个1//遍历i++)//范围for。
(C语言贪吃蛇)13.实现贪吃蛇四方向的移动
Botwo的博客
10-03 518
实现贪吃蛇四方向走位
【C语言从不挂科到高绩点】25-C语言中的共用体以及Main函数详解【重点知识】
yueyehuguang的博客
09-30 981
结构体是一种构造类型或者复杂类型，它可以包含多个类型不同的成员。union 共用体名{成员列表;结构体的各个成员会占用不同的内存，相互之间是没有影响的。而共用体的所有成员占用同一段内存，修改了一个成员会影响其余所有的成员结构体占用的内存大于或等于成员所占用的内存的综合。共用体占用的内存等于最长的成员所占用的内存。共用体使用内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会把原来成员的值覆盖掉。/**1. 结构体的各个成员会占用不同的内存，相互之间是没有影响的。
PD协议芯片ECP5701+充电管理芯片+升压芯片搭配应用TYPE-C口充电及升压供电系统
2403_86681464的博客
10-05 640
能芯科技ECP5701是一颗PD取电芯片，支持PD和QC取电，兼容USB PD3.0规范，并向下支持USB PD2.0，支持QC3.0和QC2.0，支持PD取电5、9、12、15、20V电压，QC取电9V和12V，芯片采用SOP8封装，外围简单。然而，TYPE-C接口，全称USB Type-C，迅速取代了传统的USB接口，不仅如此，TYPE-C接口的普及和PD（Power Delivery）取电协议芯片的出现，这一切便有了转机，这在快节奏的现代生活中，为我们的设备充电带来了极大的便利。
【C++单调队列 滑动窗口】1438. 绝对差不超过限制的最长连续子数组|1672
闻缺陷则喜何志丹
09-30 887
给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。 如果不存在满足条件的子数组，则返回 0 。
C++随心记 续一
Coniary的博客
10-03 642
平常做项目不推荐使用using namespace std使用标准库，这会让你的项目在移植后或者编译后产生错误，虽然加了using namespace std可以让你使用标准库时变得轻松多了，但是可能会产生重名的问题，如何创建自己的namespace代码示例如下。两片代码的效果是相同的，但是用template后的代码更简单易读，需要注意的是，template后的函数为随用随编，也就是当程序中调用才进行编译，这点与一般的函数不同，我们可以通过实验加深理解。模板可以解决多次的代码重复问题，如以下场景。
C++ 语言特性05 - 右值引用
GPU全栈博主-程序哥
10-01 415
右值引用是 C++11 引入的一种新特性，主要用于实现移动语义，从而优化资源管理和性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值