C++11（中）：智能指针

news2024/11/20 10:43:34

智能指针

    • 1.内存泄漏
      • 1.1内存泄漏的概念以及危害
      • 1.2内存泄漏的场景
      • 1.3如何避免内存泄漏
    • 2.智能指针的使用及原理
      • 2.1RAII
      • 2.2智能指针的原理
      • 2.3 std::auto_ptr
      • 2.4 定制删除器
      • 2.5 std::unique_ptr
      • 2.6 std::shared_ptr
      • 2.7 std::weak_ptr
        • 2.7.1 std::shared_ptr的循环引用
        • 2.7.2 循环引用的解决

1.内存泄漏

1.1内存泄漏的概念以及危害

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

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


1.2内存泄漏的场景

  • 内存申请了忘记释放
void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
}
  • 异常安全问题，异常会导致执行流乱跳，有可能调用申请了空间，但因为抛出异常而没有得到正常释放，就会导致内存泄漏。
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	int* p1 = new int;
	int* p2 = new int;
	//div抛出异常，执行流跳到main函数导致p1、p2指向空间未释放
	cout << div() << endl;  
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

1.3如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
  2. 使用内存泄漏工具检测。
  3. 采用RAII思想或者智能指针来管理资源，也是本文重点。



2.智能指针的使用及原理

2.1RAII

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

把获取的资源交给一个对象（栈上的），接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
        cout << "资源已释放" << endl;
    }
private:
    T* _ptr;
};
int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}
void Func()
{
    SmartPtr<int> sp1(new int);
    SmartPtr<int> sp2(new int);
    cout << div() << endl;
}

int main()
{
    try {
        Func();
    }
    catch (const exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

2.2智能指针的原理

  • RAII特性
  • 重载operator*和opertaor->，可像指针一样使用。
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
    }
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr;
};
struct Date
{
    int _year;
    int _month;
    int _day;
};
int main()
{
    SmartPtr<int> sp1(new int);
    *sp1 = 10;
        cout << *sp1 << endl;
    SmartPtr<Date> sparray(new Date);
    // 需要注意的是这里应该是sparray.operator->()->_year = 2018;
    // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
    sparray->_year = 2018;
    sparray->_month = 1;
    sparray->_day = 1;
}

2.3 std::auto_ptr

C++的各种智能指针不同点在于对于拷贝的处理，因为指针本身是支持拷贝的。

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

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

namespace SmartPtr
{
    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;
}

auto_ptr的总结：
建议别用，泄漏空间程序还不会挂，起码比访问野指针好点。


2.4 定制删除器

交给智能指针管理的资源，有可能是数组，也可能是单个对象，我们需要在析构的时候进行正确的释放，就需要定制删除器。

定制删除器的实现：

  1. 可用仿函数，仿函数增加对应的模板参数即可。
  2. 也可用包装器，本文采用的就是包装器。

代码看后面的unique_ptr和shared_ptr，这里写太冗余。


2.5 std::unique_ptr

C++11中开始提供更靠谱的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 SmartPtr
{
    template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			cout << "release:" << (int*)_ptr << endl;  //打印
			delete _ptr;
		}

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

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

		unique_ptr(auto_ptr<T>& up) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
	private:
		T* _ptr;
	};
}

int main()
{
     /*bit::unique_ptr<int> sp1(new int);
     bit::unique_ptr<int> sp2(sp1);*/

     std::unique_ptr<int> sp1(new int);
     //std::unique_ptr<int> sp2(sp1);

     return 0;
}

unique_ptr的总结：不需要拷贝的情况用。


2.6 std::shared_ptr

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

拷贝的要点：

  1. 对标指针，拷贝完看到的应该是同一份资源。
  2. 直接值拷贝不可行，会多次析构导致崩溃，应该采用引用计数。

引用计数：

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果引用计数不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
namespace SmartPtr
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _count_ptr(new int(1))
		{}

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

		shared_ptr(shared_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_count_ptr = sp._count_ptr;
			(*_count_ptr)++;  //引用计数加一即可
		}

		void release()
		{
			if (--(*_count_ptr) == 0)
			{
				cout << "release:" << (int*)_ptr << endl;  //打印
				_del(_ptr);
				delete _count_ptr;
				_count_ptr = nullptr;
				_ptr = nullptr;
			}
		}

		~shared_ptr()
		{
			release();
		}

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

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

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (sp._ptr != _ptr)
			{
				release();
				_ptr = sp._ptr;
				_count_ptr = sp._count_ptr;
				(*_count_ptr)++;
			}
			return *this;
		}

		T* get() const
		{
			return _ptr;
		}

		int use_count() const
		{
			return *_count_ptr;
		}
	private:
		T* _ptr;
		int* _count_ptr;
		function<void(T*)> _del = [](T* ptr) { delete[] ptr; };
	};

	void test_shared_ptr1()
	{
		shared_ptr<int> sp1 = new int(1);
		const shared_ptr<int> sp2 = new int(3);
		shared_ptr<int> sp3(new int[10], [](int* ptr) { delete[] ptr; });
		//shared_ptr<int> sp3 = sp2;
		//sp2 = sp1;
		//sp3 = sp1;
	}
}

shared_ptr的总结：需要拷贝的情况用。


2.7 std::weak_ptr

2.7.1 std::shared_ptr的循环引用

先看代码，下面代码存在内存泄漏：

struct ListNode
{
    int _data;
    shared_ptr<ListNode> _prev;
    shared_ptr<ListNode> _next;
};
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. 也就是说node1的_next析构了，node2就释放了。
  5. 也就是说node2的_prev析构了，node1就释放了。
  6. 但是_next属于node1的成员，node1释放了，_next才会析构，而node1由node2成员_prev管理，这就叫循环引用，谁也不会释放。

在这里插入图片描述


2.7.2 循环引用的解决

weak_ptr：只负责存储数值，不参与资源管理，支持用shared_ptr构造。

namespace SmartPtr
{
	//weak_ptr就如同普通的指针一样，不参与资源的管理
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}

		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

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

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

		weak_ptr<T>& operator=(shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
	private:
		T* _ptr;
	};
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1417053.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

《WebKit 技术内幕》学习之十五（4）：Web前端的未来

《WebKit 技术内幕》学习之十五（4）：Web前端的未来

4　Cordova项目 Cordova是一个开源项目&#xff0c;能够提供将Web网页打包成本地应用格式的可运行文件。读者可能对Cordova项目陌生&#xff0c;但是大家可能对它的前身非常熟悉&#xff0c;那就是PhoneGap项目&#xff0c;它后来被Adobe公司收购。 图15-4描述了Cordova的主要工…
阅读更多...
“Morpheus-1”的全新人工智能模型声称能引发清醒梦境

“Morpheus-1”的全新人工智能模型声称能引发清醒梦境

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
探索半导体制造业中的健永科技RFID读写器的应用方案

探索半导体制造业中的健永科技RFID读写器的应用方案

一、引言 在当今高度自动化的工业环境中&#xff0c;无线射频识别&#xff08;RFID&#xff09;技术已经成为实现高效生产的重要一环。特别是在半导体制造业中&#xff0c;由于产品的高价值和复杂性&#xff0c;生产过程的追踪和管理显得尤为重要。健永科技RFID读写器以其出色…
阅读更多...
leetcode 第三弹

leetcode 第三弹

链表声明&#xff1a; * Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNode *next) : val(x), next(n…
阅读更多...
服务端开发小记03——vsftpd

服务端开发小记03——vsftpd

这里写目录标题 vsftpd简介vsftpd在Linux下的安装vsftpd验证vsftpd常用命令 vsftpd简介 vsftpd是“very secure FTP daemon”的缩写&#xff0c;是一个用于Linux环境下的免费开源的ftp服务器软件。vsftpd在Linux发行版中最受推崇&#xff0c;小巧轻快&#xff0c;安全易用&…
阅读更多...
解决：IDEA无法下载源码，Cannot download sources, sources not found for: xxxx

解决：IDEA无法下载源码，Cannot download sources, sources not found for: xxxx

原因 Maven版本太高&#xff0c;遇到http协议的镜像网站会阻塞&#xff0c;要改为使用https协议的镜像网站 解决方案 1.打开设置 2. 拿到settings.xml路径 3. 将步骤2里箭头2的User settings file&#xff1a;settings.xml打开&#xff0c;作以下修改 保存即可。如果还不行…
阅读更多...
《PCI Express体系结构导读》随记 —— 第II篇 第4章 PCIe总线概述（1）

《PCI Express体系结构导读》随记 —— 第II篇 第4章 PCIe总线概述（1）

随着现代处理器技术的发展&#xff0c;在互连领域中&#xff0c;使用高速差分总线替代并行总线是大势所趋。与单端并行信号相比&#xff0c;高速差分信号可以使用更高的时钟频率&#xff0c;使用更少的信号线&#xff0c;完成之前需要许多单端并行数据信号才能达到的总线带宽。…
阅读更多...
多用户多店商城小程序开发价格_高品质源码_免费部署_OctShop

多用户多店商城小程序开发价格_高品质源码_免费部署_OctShop

电商行业不断的发展壮大&#xff0c;市场份额越来越大的形势下&#xff0c;越来越多的企业开始开发自己的商城系统&#xff0c;搭建自己的电商平台&#xff0c;而这其中的一些大中型企业直接就开发像京东淘宝类似的多用户商城系统或多用户商城小程序&#xff0c;来实现将自己的…
阅读更多...
Docker 安装nacos本地服务

Docker 安装nacos本地服务

docker 安装nacos实现服务注册与发现 本篇文章旨在快速搭建本地nacos服务 1 寻找nacos镜像 docker search nacos/nacos-server 2 拉取镜像 docker pull nacos/nacos-server docker pull nacos/nacos-server:v2.3.0 3docker run运行nacos docker run -d --name nacos -p 884…
阅读更多...
GitHub Action 实现超简单的持续集成（CI）

GitHub Action 实现超简单的持续集成（CI）

GitHub Action 官方文档 GitHub Action 中使用 Docker 的官方文档 所用项目代码获取&#xff1a;公众号发送cloud 前言 在上一篇几分钟完成前后端分离项目部署文章中&#xff0c;我们完成了前后端分离项目的部署&#xff0c;但随着开发的进行&#xff0c;我们每次更新都手动打包…
阅读更多...
CMake 完整入门教程（五）

CMake 完整入门教程（五）

CMake 使用实例 13.1 例子一 一个经典的 C 程序&#xff0c;如何用 cmake 来进行构建程序呢&#xff1f; //main.c #include <stdio.h> int main() { printf("Hello World!/n"); return 0; } 编写一个 CMakeList.txt 文件 ( 可看做 cmake 的…
阅读更多...
代码随想录算法训练营29期|day32 任务以及具体安排

代码随想录算法训练营29期|day32 任务以及具体安排

第八章 贪心算法 part02 122.买卖股票的最佳时机II // 贪心思路 class Solution {public int maxProfit(int[] prices) {int result 0;for (int i 1; i < prices.length; i) {result Math.max(prices[i] - prices[i - 1], 0);}return result;} } 思路&#xff1a;将股票问…
阅读更多...
美赛注意事项

美赛注意事项

2024年1月27日 &#xff1a; 赖维杰 同学分享 1、最后的展现必须要漂亮&#xff08;绘图、呈现&#xff09; 李维情 西北建模王 论文位&#xff08;核心&#xff09;必须清楚建模位、编程位知道做了些什么 常见模型&#xff1a; 1、看真题&#xff0c;读往年论文&#xff0c;选…
阅读更多...
一、对人工智能大模型了解与认知

一、对人工智能大模型了解与认知

黑8说 月黑风高&#xff0c;乌云密布&#xff0c;树木低垂&#xff0c;黯淡沉闷。这黎明前的风暴&#xff0c;预示着新时代的变革即将到来。 在一个8线小城市的办公室中 黑8对主任说&#xff1a; 世界上有男人、女人、人妖&#xff0c;米国有1/3男&#xff0c;2/3女…&#xff…
阅读更多...
100天精通鸿蒙从入门到跳槽——第16天：ArkTS条件渲染使用教程

100天精通鸿蒙从入门到跳槽——第16天：ArkTS条件渲染使用教程

博主猫头虎的技术世界 🌟 欢迎来到猫头虎的博客 — 探索技术的无限可能！ 专栏链接： 🔗 精选专栏： 《面试题大全》 — 面试准备的宝典！《IDEA开发秘籍》 — 提升你的IDEA技能！《100天精通Golang》 — Go语言学习之旅！《100天精通鸿蒙》 — 从Web/安卓到鸿蒙大师！100天…
阅读更多...
基于springboot游戏分享网站源码和论文

基于springboot游戏分享网站源码和论文

网络的广泛应用给生活带来了十分的便利。所以把游戏分享管理与现在网络相结合&#xff0c;利用java技术建设游戏分享网站&#xff0c;实现游戏分享的信息化。则对于进一步提高游戏分享管理发展&#xff0c;丰富游戏分享管理经验能起到不少的促进作用。 游戏分享网站能够通过互…
阅读更多...
csp----寻宝！大冒险！

csp----寻宝！大冒险！

题目描述&#xff1a; AC代码如下&#xff1a; /*思路&#xff1a; 把A变成小块 因为B是A里的一部分 通过把A变成小块 去寻找B这样速度更快 如果AB,BA&#xff0c;说明找到了。 */#include <iostream> #include <cstring> #include <algorithm> #include …
阅读更多...
从零开始做题：逆向 ret2shellcode orw

从零开始做题：逆向 ret2shellcode orw

1.题目信息 BUUCTF在线评测 下载orw时防病毒要关闭 2.题目分析 orw是open、read、write的简写。有时候binary会通过prctl、seccomp进行沙箱保护&#xff0c;并不能getshell。只能通过orw的方式拿到flag。 fdopen&#xff08;‘./flag’); # 打开flag文件&#xff0c;得到fd…
阅读更多...
从零开始做题：逆向 ret2libc warmup

从零开始做题：逆向 ret2libc warmup

1.题目信息 warmup.c //gcc -fno-stack-protector -no-pie -z execstack warmup.c -o warmup #include <stdio.h>void init_proc(){setbuf(stdout, NULL);setbuf(stdin, NULL);setbuf(stderr, NULL); }int main(void) {char buf[0x100];init_proc();puts("Hello C…
阅读更多...
burp靶场--CSRF

burp靶场--CSRF

burp靶场–CSRF https://portswigger.net/web-security/csrf#what-is-csrf ### 什么是 CSRF&#xff1f; 跨站请求伪造&#xff08;也称为 CSRF&#xff09;是一种 Web 安全漏洞&#xff0c;允许攻击者诱导用户执行他们不打算执行的操作。它允许攻击者部分规避同源策略&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023