C++进阶 智能指针

news2024/12/23 13:58:13

本篇博客简介:介绍C++中的智能指针

智能指针

  • 为什么会存在智能指针
    • 内存泄露
      • 内存泄漏定义
      • 内存泄漏的危害
      • 如何检测内存泄漏
      • 如何避免内存泄漏
  • 智能指针的使用及其原理
    • RAII
    • 设计一个智能指针
    • C++官方的智能指针
  • 定制删除器
  • 智能指针总结

为什么会存在智能指针

我们首先来看下面的这段代码

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;

	cout << div() << endl;
	
	delete p1;
	delete p2;
	cout << "delete success!" << endl;
}


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

在上面这段代码中有着一个很明显的内存泄露风险

当我们的程序运行在Func函数内的div函数时 很可能因为除0错误而跳转到另外一个执行流从而导致Func函数内两个new出来的内存没法被回收

为了解决这个问题我们发明了内存指针

内存泄露

内存泄漏定义

通常是由于我们的疏忽或者是程序错误导致未使用的内存没有被及时释放

这里有个经典的面试题 内存泄漏是内存丢了还是指针丢了

答案是指针丢了 因为我们能够找到指针就能够释放内存

内存泄漏的危害

内存泄漏会导致运行环境越来越慢 最终导致服务器崩溃

如何检测内存泄漏

Linux检测 : Linux内存泄漏检测工具

windows检测: Windows下内存泄漏检测工具

如何避免内存泄漏

  • 良好的编程习惯 主动申请的资源记得要主动释放
  • 利用RAII思想或智能指针来管理资源
  • 有些公司内部规范使用内部实现的私有内存管理库 这套库自带内存泄漏检测的功能选项
  • 出问题了使用内存泄漏工具检测

智能指针的使用及其原理

RAII

RAII的英文全称是 Resource Acquisition Is Initialization 直译过来即为 资源请求后初始化

它是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术

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

  • 不需要显式地释放资源。
  • 采用这种方式,对象所需的资源在其生命期内始终保持有效。

设计一个智能指针

我们将上面的代码放在Linux平台下编译运行 能够得到这的结果

在这里插入图片描述
我们发现 没有除0错误的时候能正常delete掉new出来的空间

可是一旦发生了除0错误就会造成内存泄漏

为了防止这种情况 我们结合上面的RAII技术自己写出一个智能指针出来

template<class T>      
class SmartPtr      
{      
  private:      
    T* _ptr;      
  public:      
    SmartPtr(T* ptr)      
      :_ptr(ptr)      
    {}      
    ~SmartPtr()      
    {      
      delete _ptr;
      cout << "delete success!" << endl;                                                 
    }           
}; 

之后将源代码中的指针使用智能指针管理起来后重新编译运行

在这里插入图片描述
此时我们就会发现 不管有没有发生除0错误 new出来的内存都会被delete

为了让定义出来的智能指针对象更加符合原生指针的操作 我们使用operator操作符重载下 *->

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

C++官方的智能指针

这里介绍一个C++98版本中就有的指针指针 auto_ptr

它的头文件是memory

演示代码如下

  #include <iostream>    
  using namespace std;    
  #include <memory>    
      
      
  class A    
  {    
    public:    
      ~A()    
      {    
        cout << "delete A" << endl;    
      }    
  };    
      
      
  int main()    
  {    
W>  auto_ptr<A> ap1(new A);                                     
    return 0;    
  }   

编译运行之后我们可以发现 即使我们没有主动析构 它也自动帮我们调用了析构函数

(这里报警告的原因是auto_otr并不安全 实际上std::auto_ptr 已经在 C++11 中被弃用 并且在C++11中被删除 )

在这里插入图片描述
实际上auto_ptr能够做到的事情我们自己写的SmartPtr一样可以做到

而智能指针的难点也并不在这里 而在拷贝

如果我们写出这样子的代码

  SmartPtr<A> sp1(new A);    
  SmartPtr<A> sp2(sp1);   

那么编译运行之后就会出现双重释放问题

在这里插入图片描述
为什么会出现这样子的现象呢?

如下图
在这里插入图片描述
本来是只有一个sp1对象管理着一份资源

然后我们使用拷贝构造构造出了第二个对象sp2 由于我们没有写构造函数 所以说类使用默认构造函数浅拷贝同样指向了sp1的资源

那么此时两个对象同时管理同一份资源 当析构的时候自然会析构两次 自然就会出现上面的双重释放的错误了

那么我们应该如何解决这个错误呢?

方案一: 写一个深拷贝

这个方案虽然理论上可行 但是实际上它严重违背了我们使用智能指针的初衷 我们当初使用智能指针的目的就是为了管理资源 而如果使用了这个方案则进行拷贝构造的时候还会额外的占用资源 未免太得不偿失了

方案二: 管理权转移

auto_ptr使用的就是该方案

它的具体思路就是 将被拷贝对象管理的指针置空 将原来的指针拷贝到拷贝后的对象中

这是一种很不负责任的做法 因为如果使用了该方法 我们就极有可能遇到空指针的问题 实际上也就是因为这点auto_ptr在C++11以后被弃用

auto_ptr的赋值运算符重载思路

假设现在智能指针ap1管理着一个资源 指针指针ap2管理一个资源

进行了 ap1 = ap2 操作之后

ap1改为管理ap2的资源 ap1之前的资源会被释放掉 ap2的指针置空

当然 这是一个很差的设计思路 我们学习这个东西的意义仅仅在于了解 大家做项目的时候不要去使用这种思路

方案三:禁用拷贝

在C++11中的 unique_ptr就是使用的这种方案

实现方式也很简单

在C++11之后的版本 在构造函数后面加上 =delete 就可以

在C++11之前的版本 我们需要将拷贝构造函数和赋值函数只声明不实现并且私有化

方案四:引用计数

shared_ptr就是使用的这个方案

设计方案如图

在这里插入图片描述

我们每次创建一个对象就在计数器中加上一个数字 每次删除一个对象就在计数器中减去一个数字

直到计数器中的数字为0时 我们才真正的删除资源

那么我们如何定义这个计数器呢? 使用静态变量嘛?

使用静态变量肯定是不可以的 因为静态变量是一个全局变量 它虽然能解决多个对象管理一个资源的问题 但是却解决不了多个对象管理多个资源的问题

我们这里的解决方案应该是使用一个int类型的指针

当我们创建对象的时候给这个指针new出来一块空间作为计数器

每次拷贝的时候将这个int类型的指针也同样赋值 之后让计数器++即可

shared_ptr如何实现赋值运算符重载

shared_ptr的赋值运算符重载跟其他智能指针不同的一点是 它是多个对象共同管理者一个资源的

所以说我们赋值后不能简单的置空 还要考虑–计数器 如果–之后计数器为0 则还要考虑释放资源的问题

并且还要注意下一份资源不能给相同资源赋值的问题 (判断指向资源的指针是否相等即可)

循环引用问题

假如说我们现在用智能指针管理两个节点

在这里插入图片描述
现在自动释放还没有问题

可是如果我们做出下面两步操作 就会造成一个循环引用从而无法释放的问题

  1. 我们让n1的_next节点指向n2
  2. 我们让n2的_prev节点指向n1

在这里插入图片描述
到函数最后会按照定义的先后顺序反向析构 假设我们先定义的n1 后定义的n2 就会先析构n2 再析构n1

可以析构之后我们会发现这样子的场景

在这里插入图片描述

析构一次n2之后 由于计数器不为0 所以说n2资源依旧存在

析构一次n1之后 由于计数器不为0 所以说n1资源依旧存在

而由于n1的资源由n2的_prev指针管理
n2的资源由n1的_next指针管理

所以说

要想析构n1 首先要析构掉n2

而要想析构n2 首先要析构掉n1

这样子就形成了一个死循环 这个就是shared_ptr的循环引用问题 这个问题内部没有解决方式

为了解决这个问题 C++11发明了weak_ptr用来解决 shared_ptr的循环引用问题

我们可以把weak_ptr理解为shared_ptr的小跟班 它不单独出现

在节点里面的智能指针我们可以使用weak_ptr来进行定义

weak_ptr不会增加引用计数 但是可以正常的访问修改资源 从而也就不会存在循环引用问题了

代码表示如下

	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}
		
		weak_ptr& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}

	
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		T* get()
		{
		    return _ptr;
		}
	private:
		T* _ptr; //管理的资源
	};

定制删除器

我们在上面试验的代码全部都是new的单个元素 在这种环境下没有析构没有暴露出问题

可以一旦我们使用 new [] 情况就复杂起来了 如下图

在这里插入图片描述

假设A类定义出来的对象大小为20个字节 new五个对象 那么我们实际开辟的空间为64字节 前面四个字节会存放着我们开辟了对象的个数 (int类型存放)

那么此时我们就不能简单的调用delete了 我们还要考虑指针偏移的问题

这个时候就到我们的定制删除器上场了

其实呢 定制删除器的写法很简单

我们只需要在模板处加上这行代码

  template<class T ,class D> 

删除处加上这两行代码就可以

        D del;    
        del(_ptr);

不过这样子写有个小问题 就是以后的shared_ptr就必须要传入两个参数了

当然这个问题也可以解决 我们给他设置一个默认的模板参数 delete即可

template<class T>                                                                   
struct DELETE                                                                       
{                                                                                   
  public:                                                                           
    void operator()(T* ptr)                                                         
    {                                                                               
      delete ptr;                                                                   
    }                                                                               
};                                                                                  
                                                                                    
template<class T ,class D = DELETE<T>>  

智能指针总结

为什么需要智能指针?

因为可能忘记释放资源造成内存泄漏

加上异常安全的原因 防不胜防

RAII机制是什么

英文是 Resource Acquisition Is Initialization 直译过来即为 资源请求后初始化

它是一种利用对象管理资源的思路 实际上将管理的责任托管给了对象

这种做法有两个好处

  • 不需要显式地释放资源。
  • 采用这种方式,对象所需的资源在其生命期内始终保持有效。

智能指针的发展历史

auto_ptr 到 bosst库中的三个智能指针 再到C++11中的三个智能智能

auto_ptr 在C++11被弃用 在C++17被彻底废除

auto_ptr unique_ptr shared_ptr weak_ptr的区别

前三个智能指针在RAII和模拟指针行为方面区别不大 主要区别在于拷贝方式

auto_ptr是一种不负责任的管理权转移

unique_ptr是简单粗暴的不准拷贝

shared_ptr则是引用计数

weak_ptr是shared_ptr的小跟班 来解决shared_ptr循环引用的问题

模拟实现一个智能指针

如果没有特殊要求我们优先实现unique_ptr 因为比较简单

如果有特殊要求那么一般就是实现shared_ptr了

这里比较难的主要是拷贝构造和赋值运算符重载的实现 下面给出实现代码

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

赋值运算符重载的注意点比较多

首先不能是自己给自己赋值 其次要想到赋值后原资源有没有消失

最后赋值的资源记得++

   SmartPtr& operator=(const SmartPtr<T>& sp)
    {        
      if (_ptr == sp._ptr)                                                                                            
      {
        return *this;
      }

      if (--(*_pcount) == 0)
      {
        delete _ptr;
        delete _pcount; 
      }

      _ptr = sp._ptr;
      _pcount = sp._pcount;
      (*_pcount)++;

      return *this;
    }

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

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

相关文章

消息队列(11) - 通信协议的设计

目录 通信协议设计代码实现 通信协议设计 对于我们客户端与服务器之间的通信协议我们约定如下&#xff1a; 具体的协议设计: 之后我们传递的参数也是这些 关于 type其实是在描述当前这个请求 、 响应是在调用那个API 约定如下 对于channel ,是tcp链接中的一个逻辑上的链接,…

Python实现图片文本支持中文,自定义字体

Python实现图片文本支持中文&#xff0c;自定义字体 # 支持中文 import matplotlib #用下载好的字体文件设置字体&#xff0c;从而正确显示中文 myfont matplotlib.font_manager.FontProperties(fnamer"./simsun.ttc") # 自定义的字体文件 plt.figure(figsize (1…

udp一般不会存在错数据

UDP在传输过程中会出现丢包的情况&#xff0c;但不会导致数据错乱的情况&#xff0c;这涉及到UDP协议的特性和工作原理。 无连接性&#xff1a;UDP是一种无连接的传输协议&#xff0c;每个UDP数据包都是独立的&#xff0c;没有依赖关系。因此&#xff0c;即使发生数据包丢失&am…

Golang 局部变量、全局变量 声明

文章目录 一、局部变量二、全局变量 一、局部变量 四种声明方式 多变量声明&#xff1a; package mainimport "fmt"//局部变量声明 func main() {//方法一: 声明一个变量和数据类型&#xff0c;不初始化值&#xff1b;默认值为0&#xff1b;var lvA intfmt.Printl…

圆圈中最后剩下的数字——剑指 Offer 62

文章目录 题目描述解法一题目描述 解法一 class Solution

Spring MVC静态资源映射

Spring MVC静态资源映射 静态资源映射。使用容器的默认Servletlocationmapping&#xff1a;cache-periodorder Spring MVC需要对RESTful风格的URL提供支持&#xff0c;而真正的RESTful风格的URL不应该带有任何后缀&#xff0c;因此将Spring MVC拦截的URL改为“/”&#xff08;正…

使用蓝牙外设却不小心把台式机电脑蓝牙关了

起因 今天犯了一个贼SB的错误&#xff0c;起因是蓝牙键盘突然就不能输入了&#xff08;虽然是连接状态&#xff0c;但是按什么键都没有反应&#xff09; 原来我的解决方法就是重启一下电脑&#xff0c;但是那会电脑开了贼多的软件。我就想重启也太麻烦了&#xff0c;既然重启…

Java之继承

继承 继承为什么使用继承继承是什么继承的语法访问父类成员访问父类成员变量访问父类成员方法 super关键字子类构造方法super和this异同分别的使用方法 继承的方式final关键字 作者简介&#xff1a; zoro-1&#xff0c;目前大一&#xff0c;正在学习Java&#xff0c;数据结构等…

【算法挨揍日记】day02——双指针算法_快乐数、盛最多水的容器

202. 快乐数 202. 快乐数https://leetcode.cn/problems/happy-number/ 题目&#xff1a; 编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为&#xff1a; 对于一个正整数&#xff0c;每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个…

Python接口自动化之request请求封装

我们在做自动化测试的时候&#xff0c;大家都是希望自己写的代码越简洁越好&#xff0c;代码重复量越少越好。那么&#xff0c;我们可以考虑将request的请求类型&#xff08;如&#xff1a;Get、Post、Delect请求&#xff09;都封装起来。这样&#xff0c;我们在编写用例的时候…

OptaPlanner笔记2

1.5.3 使用maven 修改pom.xml 导入optaplanner-bom以避免为每一个依赖项重复添加版本号 <project>...<dependencyManagement><dependencies><dependency><groupId>org.optaplanner</groupId><artifactId>optaplanner-bom</art…

使用 CycleGAN 进行图像到图像转换

介绍 在人工智能和计算机视觉领域,CycleGAN 是一项非凡的创新,它重新定义了我们感知和操作图像的方式。这种尖端技术彻底改变了图像到图像的转换,实现了领域之间的无缝转换,例如将马变成斑马或将夏日风景变成雪景。在本文中,我们将揭开 CycleGAN 的魔力,并探索其在各个领…

微信小程序开发价格

小程序开发费用 小程序的开发费用是很多企业和个人在规划项目时需要重点考虑的一个方面。本文将从微信认证费、域名、服务器、程序开发费用、微信支付费率以及维护费用等多个角度为大家分析小程序开发费用的组成。 1. 微信认证费&#xff1a;作为小程序的一种信任凭证&#xf…

对文件的读取和修改 JAVA

目录 1、try catch:2、hasNextLine():3、java读取某个文件夹信息&#xff1a;4、修改&#xff1a; 1、try catch: 1、try语句对你觉得可能会有问题的语句进行尝试 2、try内语句出现错误会被catch语句捕捉&#xff0c;且整个程序不会崩溃 3、try语句出错才会执行下方catch语句…

机器学习实战4-数据预处理

文章目录 数据无量纲化preprocessing.MinMaxScaler&#xff08;归一化&#xff09;导库归一化另一种写法将归一化的结果逆转 preprocessing.StandardScaler(标准化)导库实例化查看属性查看结果逆标准化 缺失值impute.SimpleImputer另一种填充写法 处理分类型特征&#xff1a;编…

C++ 学习系列3 -- 函数压栈与出栈

在C中&#xff0c;函数压栈&#xff08;函数调用&#xff09;和出栈&#xff08;函数返回&#xff09;是函数调用过程中的两个关键步骤。下面将逐步解释这两个过程&#xff1a; 一 函数压栈与出栈过程简介 函数压栈&#xff08;函数调用&#xff09;的过程如下&#xff1a; …

深入Python字典

在Python中&#xff0c;字典是通过哈希表实现的。也就是说&#xff0c;字典是一个数组&#xff0c;而数组的索引是键经过哈希函数处理后得到的。哈希函数的目的是使键均匀地分布在数组中。由于不同的键可能具有相同的哈希值&#xff0c;即可能出现冲突&#xff0c;高级的哈希函…

开封Geotrust单域名https证书推荐

Geotrust作为全球领先的数字证书颁发机构之一&#xff0c;拥有多年的数字证书颁发经验&#xff0c;其数字证书被广泛应用于电子商务、在线支付、企业通讯、云计算等领域&#xff0c;为用户提供了安全可靠的保障。而Geotrust旗下的单域名https证书是大多数客户创建网站时的选择之…

最容易理解的C51单片机4位密码锁示例代码(附proteus电路图)

说明&#xff1a;开机启动就是上图这样的&#xff0c;密码正确显示P&#xff08;pass&#xff09;,密码错误显示E&#xff08;error&#xff09; #include "reg51.h" #include "myheader.h" #define uchar unsigned char long int sleep_i0; int pwd[4]{0…

Linux 库文件——静态库和共享库

一、库文件的概念 库是一组预先编译好的方法&#xff08;.o文件&#xff09;的集合。Linux系统存储的库的位置一般在&#xff1a;/lib 和 /usr/lib。 在 64 位的系统上有些库也可能被存储在/usr/lib64 下。库的头文件一般会被存储在/usr/include 下或其子目录下。 库有两种&…