C++进阶 智能指针

这篇具有很好参考价值的文章主要介绍了C++进阶 智能指针。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

本篇博客简介:介绍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平台下编译运行 能够得到这的结果

C++进阶 智能指针,C++进阶,c++,开发语言
我们发现 没有除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;                                                 
    }           
}; 

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

C++进阶 智能指针,C++进阶,c++,开发语言
此时我们就会发现 不管有没有发生除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中被删除 )

C++进阶 智能指针,C++进阶,c++,开发语言
实际上auto_ptr能够做到的事情我们自己写的SmartPtr一样可以做到

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

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

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

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

C++进阶 智能指针,C++进阶,c++,开发语言
为什么会出现这样子的现象呢?

如下图
C++进阶 智能指针,C++进阶,c++,开发语言
本来是只有一个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就是使用的这个方案

设计方案如图

C++进阶 智能指针,C++进阶,c++,开发语言

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

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

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

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

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

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

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

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

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

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

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

循环引用问题

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

C++进阶 智能指针,C++进阶,c++,开发语言
现在自动释放还没有问题

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

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

C++进阶 智能指针,C++进阶,c++,开发语言
到函数最后会按照定义的先后顺序反向析构 假设我们先定义的n1 后定义的n2 就会先析构n2 再析构n1

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

C++进阶 智能指针,C++进阶,c++,开发语言

析构一次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 [] 情况就复杂起来了 如下图

C++进阶 智能指针,C++进阶,c++,开发语言

假设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)++;
    }        
       

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

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

最后赋值的资源记得++文章来源地址https://www.toymoban.com/news/detail-643977.html

   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;
    }

到了这里,关于C++进阶 智能指针的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 『C语言进阶』指针进阶(二)

    🔥 博客主页 : 小羊失眠啦 🔖 系列专栏 : C语言 🌥️ 每日语录 : 无论你怎么选,都难免会有遗憾。 ❤️ 感谢大家点赞👍收藏⭐评论✍️ 在上篇指针进阶中,我们对字符指针、指针数组、数组指针以及数组传参和指针传参有了一定的了解,你以为指针进阶就只有这些内

    2024年02月07日
    浏览(39)
  • 『C语言进阶』指针进阶(一)

    🔥 博客主页 : 小羊失眠啦 🔖 系列专栏 : C语言 🌥️ 每日语录 : 无论你怎么选,都难免会有遗憾。 ❤️ 感谢大家点赞👍收藏⭐评论✍️ 在C语言初阶中,我们对指针有了一定的了解,指针是个变量,是用来存放地址的,指针的大小是固定的4/8个字节,指针是有类型的

    2024年02月09日
    浏览(36)
  • 【C语言】指针进阶:字符指针&&数组指针&&函数指针

    ✨作者:@平凡的人1 ✨专栏:《C语言从0到1》 ✨一句话:凡是过往,皆为序章 ✨说明: 过去无可挽回, 未来可以改变 🌹 感谢您的点赞与关注,同时欢迎各位有空来访我的 🍁平凡舍 回想之前,我们学了 指针 的一些基础👉 指针与结构体 我们知道了指针的概念: 指针就是

    2023年04月08日
    浏览(42)
  • 【C语言进阶】指针数组 —— 数组指针

    🎬 鸽芷咕 : 个人主页  🔥 个人专栏 : 《C语言进阶篇》 《C语言初阶篇》 ⛺️生活的理想,就是为了理想的生活!    🌈 hello! 各位宝子们大家好啊,前面我们已经把指针大部分内容给学完了,今天就给大家带来数组指针or指针数组!    ⛳️ 很多说这俩名字不是差不

    2024年02月14日
    浏览(35)
  • 进阶C语言-指针的进阶(三)

    📝关于 qsort函数 ,我们可以先去cpluplus网站上面了解一下: ✅运行示例: 🔎我们发现上述代码只适用于整型数据,那么我们是否能写出更一般的更普遍的代码呢? ✅运行示例: 📖运行流程如下: 🔎按照年龄排序: ✅运行示例: 🔎按照姓名排序: ✅运行示例: 好啦,

    2024年02月05日
    浏览(45)
  • C语言进阶之指针的进阶

    指针的主题,我们在C语言初阶博客已经接触过了,我们知道了指针的概念: 指针就是个变量,用来存放地址,地址唯一标识一块内存空间。 指针的大小是固定的4/8个字节(32位平台/64位平台)。 指针是有类型,指针的类型决定了指针的±整数的步长,指针解引用操作的时候

    2024年02月16日
    浏览(38)
  • 进阶C语言-指针的进阶(中)

    数组指针 - 指向数组的指针 - 存放的是数组的地址 - 数组名就是数组的地址。 函数指针 - 指向函数的指针 - 存放的是函数的地址 - 函数名就是函数的地址。 🔭阅读下面这两段代码: 🔭 指针数组: 字符指针数组 - 数组 - 存放的是字符指针 整型指针数组 - 数组 - 存放的是整

    2024年02月09日
    浏览(39)
  • 进阶C语言-指针的进阶(二)

    数组指针 - 指向数组的指针 - 存放的是数组的地址 - 数组名就是数组的地址。 函数指针 - 指向函数的指针 - 存放的是函数的地址 - 函数名就是函数的地址。 🔭阅读下面这两段代码: 🔭 指针数组: 字符指针数组 - 数组 - 存放的是字符指针 整型指针数组 - 数组 - 存放的是整

    2024年02月07日
    浏览(36)
  • 进阶C语言-指针的进阶(一)

    通过前面的学习,我们了解了指针的概念: 指针变量就是一个变量,用来存放地址,地址唯一标识一块内存空间。 指针的大小是固定为 4/8 个字节( 32位平台/64位平台 )。 指针是有类型的,指针的类型决定了指针的±整数的步长,指针解引用操作的时候的权限。 指针的运算

    2024年02月07日
    浏览(38)
  • 进阶C语言-指针的进阶(上)

    通过前面的学习,我们了解了指针的概念: 指针变量就是一个变量,用来存放地址,地址唯一标识一块内存空间。 指针的大小是固定为 4/8 个字节( 32位平台/64位平台 )。 指针是有类型的,指针的类型决定了指针的±整数的步长,指针解引用操作的时候的权限。 指针的运算

    2024年02月09日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包