C++：智能指针

于 2024-08-14 08:58:09 发布
阅读量863 收藏 37
点赞数 39
分类专栏： C++学习 文章标签： c++ 开发语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79691881/article/details/141090332
版权

✨✨✨学习的道路很枯燥，希望我们能并肩走下来!

文章目录

目录

文章目录

前言

一 为什么需要智能指针

二 内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害

2.2 内存泄漏分类（了解）

2.3 如何检测内存泄漏（了解） 

2.4 如何避免内存泄漏 

三 智能指针的使用及原理 

3.1 RAII 

3.2 智能指针的原理 

 3.3 智能指针的种类

3.3.1 std::auto_ptr 

3.3.2 std::unique_ptr 

​编辑 3.3.3 std::shared_ptr

std::shared_ptr的线程安全问题  挖坑ing

3.3.4 std::weak_ptr

四 C++11和boost中智能指针的关系 

总

前言

本篇详细介绍了进一步介绍C++中的智能指针，让使用者对智能指针有更加深刻的认知，而不是仅仅停留在表面，更好的模拟，为了更好的使用. 文章可能出现错误，如有请在评论区指正，让我们一起交流，共同进步！

一 为什么需要智能指针

下面我们先分析一下下面这段程序有没有什么内存方面的问题？提示一下：注意分析MergeSort 函数中的问题。

int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void Func()
{
    // 1、如果p1这里new 抛异常会如何？
    // 2、如果p2这里new 抛异常会如何？
    // 3、如果div调用这里又会抛异常会如何？
    int* p1 = new int;
    int* p2 = new int;
    cout << div() << endl;
    delete p1;
    delete p2;
}
int main()
{
    try
    {
        Func();
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

 解答： p1 new抛异常，直接停止向上抛异常，无内存泄漏

             p2 new抛异常，向上抛异常，p1资源泄漏

             div调用抛异常，向上抛异常，p1，p2资源泄漏

二 内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害

        什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对 该段内存的控制，因而造成了内存的浪费。

        内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现 内存泄漏会导致响应越来越慢，最终卡死。 

void MemoryLeaks()
{
    // 1.内存申请了忘记释放
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = new int;

    // 2.异常安全问题
    int* p3 = new int[10];

    Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.

    delete[] p3;
}

2.2 内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏： 

堆内存泄漏(Heap leak)：

        堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分 内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏 ：

        指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放 掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

2.3 如何检测内存泄漏（了解） 

在linux下内存泄漏检测：Linux下几款C++程序中的内存泄露检查工具_c++内存泄露工具分析-CSDN博客 

在windows下使用第三方工具：VS编程内存泄漏：VLD(Visual LeakDetector)内存泄露库_visual leak detector vs2020-CSDN博客

其他工具：内存泄露检测工具比较 - 默默淡然 - 博客园 (cnblogs.com)

2.4 如何避免内存泄漏 

        1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps： 这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智 能指针来管理才有保证。

        2. 采用RAII思想或者智能指针来管理资源。 

        3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

        4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。 

总结一下:

内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄 漏检测工具。 

三 智能指针的使用及原理 

3.1 RAII 

        RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内 存、文件句柄、网络连接、互斥量等等）的简单技术。 

        在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在 对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做 法有两大好处： 

        不需要显式地释放资源。

        采用这种方式，对象所需的资源在其生命期内始终保持有效。 

3.2 智能指针的原理 

        利用对象来控制资源的管理为智能指针，来模仿指针的行为。指针可以解引用，也可 以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其 像指针一样去使用。 

        总结一下智能指针的原理：

        1. RAII特性

        2. 重载operator*和opertaor->，具有像指针一样的行为。 

 3.3 智能指针的种类

3.3.1 std::auto_ptr 

std::auto_ptr文档

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。 

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理 

 auto_ptr的模拟实现

// C++98 管理权转移 auto_ptr
namespace ch
{
    template<class T>
    class auto_ptr
    {
    public:
        auto_ptr(T* ptr)
            :_ptr(ptr)
        {}
        auto_ptr(auto_ptr<T>& sp)
            :_ptr(sp._ptr)
        {
            // 管理权转移
            sp._ptr = nullptr;
        }
        auto_ptr<T>& operator=(auto_ptr<T>& ap)
        {
            // 检测是否为自己给自己赋值
            if (this != &ap)
            {
                // 释放当前对象中资源
                if (_ptr)
                    delete _ptr;
                // 转移ap中资源到当前对象中
                _ptr = ap._ptr;
                ap._ptr = NULL;
            }
            return *this;
        }
        ~auto_ptr()
        {
            if (_ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };
}
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
//int main()
//{
// std::auto_ptr<int> sp1(new int);
// std::auto_ptr<int> sp2(sp1); // 管理权转移
//
// // sp1悬空
// *sp2 = 10;
// cout << *sp2 << endl;
// cout << *sp1 << endl;
// return 0;
//}

3.3.2 std::unique_ptr 

C++11中开始提供更靠谱的unique_ptr 

std::unique_ptr文档

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理 

// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
namespace bit
{
    template<class T>
    class unique_ptr
    {
    public:
        unique_ptr(T* ptr)
            :_ptr(ptr)
        {}
        ~unique_ptr()
        {
            if (_ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
        unique_ptr(const unique_ptr<T>&sp) = delete;
        unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
    private:
        T* _ptr;
    };
}

 有关定制删除器（对应自定义类型和数组）的用法：

 3.3.3 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr 

std::shared_ptr文档

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。 

        1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。 

        2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减 一。

        3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

        4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对 象就成野指针了。

根据以上的条件，我们模拟实现share_ptr

#pragma once
#include<functional>
namespace ch
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr == nullptr)
			: _ptr(ptr)
			, _pcount(new int(1))
		{}
		//定制删除器
		/*template<class D>
		shared_ptr(T* ptr, D del)
			: _ptr(ptr)
			, _pcount(new int(1))
			, _del(del)
		{}*/

		shared_ptr(const shared_ptr<T>& sp)
			: _ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount);
		}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				//_del(ptr) 配合定制删除器
				delete _pcount;
				_ptr = _pcount = nullptr;
			}
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				release();

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

		~shared_ptr
		{
			release();
		}

		int use_count() const
		{
			return *_pcount;
		}

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

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

	private:
		T* _ptr;
		int* _pcount;
		/*function<void(T* ptr)> _del = [](T* ptr) {delete ptr; };*/
	};
}

PS:

区别于unique的定制删除器的传法

make_shared的使用

Make_shared 必须要显示实例化 (不支持自动推导

 使用Make_shared的优势：

Make_shared 会将引用计数和数据放在一起，减少能出分离的小块内存，开辟一整块·

std::shared_ptr的线程安全问题  挖坑ing

3.3.4 std::weak_ptr

用于解决std::shared_ptr的循环引用 的问题

struct ListNode
{
    int _data;
    shared_ptr<ListNode> _prev;
    shared_ptr<ListNode> _next;
    ~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
    shared_ptr<ListNode> node1(new ListNode);
    shared_ptr<ListNode> node2(new ListNode);
    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;
    node1->_next = node2;
    node2->_prev = node1;
    cout << node1.use_count() << endl;
    cout << node2.use_count() << endl;
    return 0;
}

 循环引用分析：

1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动 delete。

2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。

3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上 一个节点。

4. 也就是说_next析构了，node2就释放了。

5. 也就是说_prev析构了，node1就释放了。

6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev 属于node2成员，所以这就叫循环引用，谁也不会释放。

// 解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了

// 原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和 _prev不会增加node1和node2的引用计数。 

四 C++11和boost中智能指针的关系 

1. C++ 98 中产生了第一个智能指针auto_ptr.

2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.

3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。

4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost 的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。 

总结

✨✨✨各位读友，本篇分享到内容是否更好的让你理解C++的智能指针，如果对你有帮助给个👍赞鼓励一下吧！！
🎉🎉🎉世上没有绝望的处境，只有对处境绝望的人。
感谢每一位一起走到这的伙伴，我们可以一起交流进步！！！一起加油吧！！

Chris-zz
关注
专栏目录
C++:智能指针unique_ptr与vector；shared_ptr与vector
mzhan017的博客
11-28 2467
文章目录错误分析 错误 class abc { public: abc(){cout<<"construct"<<endl;} ~abc(){cout<<"destroy"<<endl;} }; int main() { vector<unique_ptr<abc>> v_s_a; unique_ptr<abc> u_s_b (new abc); v_s_a.push_back(u_s_b);
C++: 智能指针 sp 之 Android轻量级智能指针
Change The World
07-31 655
testtest
【C++】智能指针
须知少日拏云志，曾许人间第一流。
06-06 1006
在我们异常一节就已经讲过，当使用异常的时候，几个函数层层嵌套，其中如果抛异常就可能导致没有释放堆区开辟的空间。这样就很容易导致内存泄漏。关于内存泄漏，我也曾在C++内存管理一文中写过。为了觉得这个问题，C++引入了智能指针。
智能指针——C++
mankeywang的博客
04-22 929
先定义一个类~ cat();void cat_info() const //输出一下成员name的值 {} void set_cat_name(const std :: string & name) //修改成员name的值 {"mimi" };使用std::make_unique的方式：推荐使用的方式//方法一 std::make_unique std :: unique_ptr < cat > u_c_p4 = std :: make_unique < cat >("ee");
C++中的智能指针
这里是RabbitTuzi哦~
06-27 5610
本篇文章探讨了C++中的内存管理问题以及解决方案。C++作为一种直接操作内存的语言，开发人员需要自行负责内存的分配和释放，但这容易导致内存泄漏、悬空指针和二次释放等问题的出现。为了解决这些问题，C++提供了智能指针技术。智能指针通过封装指针和引入引用计数等机制，实现了自动化的内存管理和资源释放。本文详细介绍了智能指针的概念、作用和常见类型，如unique_ptr、shared_ptr和weak_ptr，并讨论了它们的实现原理和适用场景。此外，还探讨了智能指针的性能考虑以及如何避免循环引用和内存泄漏的技巧。
C++：智能指针(5)——enable_shared_from_this工作原理、源码分析
weixin_41442027的博客
04-19 2814
文章目录enable_shared_from_this的作用用法问题1分析问题2分析enable_shared_from_this源码分析、工作原理enable_shared_from_this与shared_ptr的耦合关系总结 enable_shared_from_this的作用 在C++：智能指针(3)——无法通过原指针增加共享指针shared_ptr的计数，enable_shared_fr...
C++：智能指针 sp 之手动实现智能指针
Change The World
07-31 1530
自己实现智能指针 指针导致的内存泄漏 #include <iostream> #include <string.h> #include <unistd.h> using namespace std; class Person { public: Person() { cout <<"Pserson()"<<endl; } ~Person() { cout <<
C++: 智能指针 sp 之 Android强弱指针的实现与使用
Change The World
08-02 765
回顾下前面提到的Android 轻量级智能指针 LightRefBase： class Person : public LightRefBase<Person>{} sp<Person>{ .Person *mptr; sp(){ incStrong; } ~sp(){ decStrong; } } 类比，强弱指针可能会有如下统一实现： class RefBase{ private: int mStrong; int mWeak; Public: voi
c++智能指针
02-24
c++中关于auto_ptr指针的详细讲解，指针的含义以及用法还有架构都清晰的给出了解释的操作
C++_智能指针
weixin_41849360的博客
08-18 235
C++ 智能指针
详解C++11智能指针
WindSun's Blog
09-02 608
前言 C++里面的四个智能指针: auto_ptr, unique_ptr,shared_ptr, weak_ptr 其中后三个是C++11支持，并且第一个已经被C++11弃用。 C++11智能指针介绍 智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。C++ 11中最常用的智能指针类型为sh...
C++智能指针
gehulushang的博客
01-06 164
智能指针的由来： 除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：指向一个动态独享的指针，销毁对象，并...
C++之智能指针
最新发布
qq_44753080的博客
03-27 2889
c++智能指针
评论 28
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值