异常和智能指针

智能指针的认识

智能指针是一种C++语言中用于管理动态内存的工具，它们可以自动管理内存的分配和释放，从而避免内存泄漏和悬空指针等问题。智能指针可以跟踪指向的对象的引用次数，并在需要时自动释放被引用的内存，这极大地提高了内存管理的安全性和便利性。

C++标准库提供了三种类型的智能指针：

  • std::auto_ptr：管理权转移的思想，当进行赋值操作时会将原对象置空，而新对象指向该空间。
     

  • std::unique_ptr：独占型智能指针，表示它所指向的对象只能被一个指针拥有（即不能进行赋值），一旦该指针销毁，它所指向的对象也会被销毁。

  • std::shared_ptr：共享型智能指针，允许多个指针共同管理同一个对象，通过引用计数来跟踪对象的引用次数，当引用计数为0时自动释放对象内存。

 其实智能指针的使用是在异常时引出的，所以我们先了解一下异常：

异常

首先我们其实在堆区new空间的时候就见过异常，当我们想要开辟的空间太大而无法申请到就会抛异常：

概念

异常是我们处理错误的一种方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。

  • throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
  • catch: 在您想要处理问题的地方，通过异常处理程序捕获异常 catch 关键字用于捕获异常，可以有多个catch进行捕获。
  • try:try 块中放置可能抛出异常的代码,它后面通常跟着一个或多个 catch 块。

使用

double Division(int a, int b)//除法计算
{// 当b == 0时抛出异常if (b == 0)throw "不能除0";elsereturn ((double)a / (double)b);
}
void Func()
{int len, time;cin >> len >> time;cout << Division(len, time) << endl;
}
int main()
{try {Func();}catch (const char* errmsg)//抛出什么类型就捕获什么类型的数据{cout << errmsg << endl;}catch (...)//捕获抛出的未知异常{cout << "unkown exception" << endl;}return 0;
}

我们要知道当我们在throw抛出异常的时候，此时就会立马调用最近的catch进行，捕获异常， 如果没有调用到catch的话，或者catch的类型不匹配的话就会出现：

而且我们抛异常之后会被立马捕获异常，而这之间的代码并不会执行，直接就开始执行catch后续代码 。 但是也别忘了在此我们调用函数的过程中是创建了栈帧的，所以我们catch捕获异常后会销毁之前的栈帧空间。

实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获。这里就引入C++标准库异常体系了：

C++标准库异常体系

这个exception类就是所有标准C++异常的父类，所以当我们C++程序内部抛异常时都可以用父类对象接受捕获异常。

int main()
{try {new int[7000000000];}catch (const exception& e){cout << e.what() << endl;}catch (...){cout << "Unkown Exception" << endl;}return 0;
}


 

异常规范 

//C++11
thread() noexcept;//表示函数体内一定不会抛异常，如果抛了就运行出错
thread (thread&& x) noexcept;//C++98
void fun() throw();//表示函数体内一定不会抛异常，如果抛了也会捕获// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void fun() throw (std::bad_alloc);

我们是否注意到异常的一点缺陷，当抛异常后就会立马执行到捕获异常的位置，这中途的栈帧都将销毁，而代码也不会执行，但是如果这之中需要我们释放堆区空间的话，那么就会造成内存泄漏。所以我们就有了智能指针的引出：

智能指针使用与实现

我们知道catch接受异常时可能会导致从堆区动态开辟的空间未释放从而造成内存泄漏，所以我们就采用了智能指针去构造的对象，然后在栈帧销毁的时候就会自动调用析构函数了，而不需要我们进行手动调用。

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;//调用div()函数delete p1;delete p2;
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

这里我们发现会调用div函数，然后如果抛异常的话就会造成delete函数未执行，从而导致内存泄漏的情况，因此我们就通过智能指针的方式进行改造（以shared_ptr为例）：

template<class T>
class Smart_ptr
{
public:Smart_ptr(T* ptr = nullptr):_ptr(ptr){}~Smart_ptr(){delete _ptr;cout << "delete[] " << _ptr << endl;}
private:T* _ptr;
};int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{Smart_ptr<int> p1 = new int;Smart_ptr<int> p2 = new int;cout << div() << endl;  
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

通过以上的方式，我们将需要创建的对象去构造智能指针，此时当战争销毁的时候就会自动调用类的析构函数，从而释放空间。而这种方式的原理就是就是RAII：

RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内
存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处：

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

 shared_ptr

template<class T>
class Smart_ptr
{
public:Smart_ptr(T* ptr = nullptr):_ptr(ptr),_count(new int(1)){}Smart_ptr(const Smart_ptr<T>& tmp)//拷贝构造（浅拷贝）:_ptr(tmp._ptr),_count(tmp._count){(*_count)++;//引用计数++}Smart_ptr<T>& operator=(const Smart_ptr<T>& tmp){if(_ptr!=tmp._ptr)//防止自己给自己赋值(){//this->~Smart_ptr();//没问题但是不好if (--(*_count) == 0)//该空间可能不仅被一个对象所指，所以当前的记数-1{delete[] _ptr;delete _count;//cout << "delete[] " << _ptr << endl;}_ptr = tmp._ptr;_count = tmp._count;(*_count)++;return *this;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~Smart_ptr(){if (*_count > 1)(*_count)--;else{delete _ptr;delete _count;//cout << "delete[] " << _ptr << endl;}}
private:T* _ptr;int* _count;//引用计数(关键就是指针存放)//光整型存放会有问题，会导致拷贝构造后的数据不是同一个记数
};

虽然说shared_ptr可以解决这种问题，但是shared_ptr最大的缺陷就是循环引用，而对于循环引用问题的解决就引出了weak_ptr。先看一下什么是循环引用：

循环引用

循环引用是指在编程中，两个或多个对象相互引用，形成一个循环的引用链，导致它们无法被正常地回收或释放。

struct ListNode
{int val;Smart_ptr<ListNode> next;Smart_ptr<ListNode> pre;~ListNode(){cout << "~ListNode" << endl;}
};void test()
{Smart_ptr<ListNode> n1(new ListNode);Smart_ptr<ListNode> n2(new ListNode);n1->next = n2;n2->pre = n1;
}
int main()
{test();return 0;
}

在该种情形时可以分析出：n1->next=n2;这段代码使得n2指针指向的空间计数为2,而n2->pre=n1；使得n1指向的空间记数也为2，而且当该栈帧空间销毁时会先析构n2这块空间，再析构n1这块空间：

    ~Smart_ptr(){if (*_count > 1)(*_count)--;else{delete _ptr;delete _count;//cout << "delete[] " << _ptr << endl;}}

当析构n2空间时会先引用计数--，然后发现n2该对象成员函数是两个内置类型，不做处理，所以就开始析构n1对象，同样是引用计数--，此时就程序结束了。

但是_next还指向下一个节点。而且_prev还指向上一个节点。从而导致堆区内存空间未释放所以造成了内存泄漏。所以想要正确释放空间就要析构n1的_next节点（释放n2）和n2的_pre节点（释放n1），但是_next是n1的成员，_pre又是n2的成员，所以想要析构_next和_pre的话就又要析构n1和n2，从而形成了闭环。

而以上情形就是循环引用。最终谁都不会释放，从而造成内存泄漏。

std::weak_ptr是一种用于解决shared_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<T>& operator=(const shared_ptr<T>& sp){_ptr = sp.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

此时的_next和_pre 的指针类型就可以是weak_ptr的类型：

定制删除器

当我们使用智能指针的时候其实都疏忽了一点，空间释放delete对象时的方式，当我们new的是单一的空间的时候就直接delete就行了，而当我们new的是一段连续的空间的时候就需要delete[]来释放空间，此时就很容易的联想到仿函数。我们库里的是采用重载构造函数模版的方式来解决问题：

所以我们就可以按照库的解决方式进行改造我们所写的代码：

namespace cr
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr), _count(new int(1)){}template<class D>//模版类型shared_ptr(T* ptr, D del)//重载构造函数: _ptr(ptr), _count(new int(1)), _del(del)//设置为类成员用于析构调用{}shared_ptr(const shared_ptr<T>& tmp)//拷贝构造（浅拷贝）:_ptr(tmp._ptr), _count(tmp._count){(*_count)++;}shared_ptr<T>& operator=(const shared_ptr<T>& tmp){if (_ptr != tmp._ptr)//防止自己给自己赋值{if (--(*_count) == 0){del(_ptr);//相当于调用operator()delete _count;}_ptr = tmp._ptr;_count = tmp._count;(*_count)++;return *this;}}~shared_ptr(){if (*_count > 1)(*_count)--;else{_del(_ptr);//相当于调用operator()delete _count;}}private:T* _ptr;int* _count;function<void(T*)> _del = [](T* ptr)->void {delete ptr; };//默认给缺省值//因为不知道_del的类型，采用function包装器包装，可以接受函数指针、lambda表达式、仿函数};
}

 主函数中进行测试调用：

template<class T>
struct del//仿函数
{void operator()(T* ptr){delete[] ptr;}
}; 
struct ListNode
{int val;cr::shared_ptr<ListNode> next;cr::shared_ptr<ListNode> pre;~ListNode(){cout << "~ListNode" << endl;}
};
int main()
{cr::shared_ptr<ListNode> p1(new ListNode[10],del<ListNode>());cr::shared_ptr<ListNode> p2(new ListNode[10],[](ListNode* ptr)->void{delete[]ptr; });cr::shared_ptr<ListNode> p3(new ListNode);return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

github新建仓库推送代码教学

github新建仓库推送代码教学

之前一直用gitee&#xff0c;准备转到github。因为一步一步尝试。如果是新手或许文章会有帮助 点击 new 创建 拉代码 Idea 打开 复制一个 pom 文件作为 maven 管理 提交代码 不出意外的出意外&#xff0c;报错 点击authorize JetBrains 失败 分析问题 本质就是没有…
阅读更多...
ICC2：add text脚本

ICC2：add text脚本

我正在「拾陆楼」和朋友们讨论有趣的话题，你⼀起来吧？ 拾陆楼知识星球入口 相关文章链接: ICC2：gds to ndm流程 #ICC2 add text参考脚本 set_snap setting -enabled {false} f
阅读更多...
043、循环神经网络

043、循环神经网络

之——RNN基础 杂谈 第一个对于序列模型的网络&#xff0c;RNN。 正文 1.潜变量自回归模型 潜变量总结过去的信息&#xff0c;再和当前信息一起结合出新的信息。 2.RNN 循环神经网络将观察作为x&#xff0c;与前层隐变量结合得到输出 其中Whh蕴含了整个模型的时序信息&#xf…
阅读更多...
RK3588平台开发系列讲解（AI 篇）RKNN rknn_query函数详细说明

RK3588平台开发系列讲解（AI 篇）RKNN rknn_query函数详细说明

文章目录 一、查询 SDK 版本二、查询输入输出 tensor 个数三、查询输入 tensor 属性(用于通用 API 接口)四、查询输出 tensor 属性(用于通用 API 接口)五、查询模型推理的逐层耗时六、查询模型推理的总耗时七、查询模型的内存占用情况八、查询模型里用户自定义字符串九、查询原…
阅读更多...
MySQL的事务-隔离级别

MySQL的事务-隔离级别

上篇&#xff0c;整理了MySQL事务的原子性&#xff0c;这篇继续整理MySQL事务的一致性、隔离性和持久性。 2. 一致性指的是事务开始前和结束后&#xff0c;数据库的完整性约束没有被破坏&#xff0c;这保证了数据的完整性和一致性。一致性必须确保数据库从一个一致的状态转换到…
阅读更多...
【MYSQL】MYSQL 的学习教程（七）之 慢 SQL 优化思

【MYSQL】MYSQL 的学习教程（七）之 慢 SQL 优化思

1. 慢 SQL 优化思路 慢查询日志记录慢 SQLexplain 分析 SQL 的执行计划profile 分析执行耗时Optimizer Trace 分析详情确定问题并采用相应的措施 1. 慢查询日志记录慢 SQL 如何定位慢SQL呢&#xff1f; 我们可以通过 慢查询日志 来查看慢 SQL。 ①&#xff1a;开启慢查询日志…
阅读更多...
Redis缓存穿透、缓存击穿、缓存雪崩介绍

Redis缓存穿透、缓存击穿、缓存雪崩介绍

一、Redis的缓存穿透 1.什么是缓存穿透&#xff1f; 缓存穿透是指&#xff1a;客户端请求的数据在缓存中和数据库中都不存在&#xff0c;这时缓存就永远不会生效&#xff0c;这些请求都打到数据库从而导致数据库压力过大。 2.出现缓存穿透的解决方案&#xff0c;以下是常用的两…
阅读更多...
力扣经典面试题——搜索旋转排序数组及最小值（二分搜索旋转数组系列一次搞定）

力扣经典面试题——搜索旋转排序数组及最小值（二分搜索旋转数组系列一次搞定）

我们先来看看一个常规的二分搜索是如何进行的&#xff1f; 例如要找一个有序数组的某个数 【1&#xff0c;2&#xff0c;4&#xff0c;5&#xff0c;9&#xff0c;11&#xff0c;15&#xff0c;19】 我们要找11&#xff0c;每次我们分割半边判断然后看到底在哪一边。 这里为什么…
阅读更多...
TCP 三次握手:四次挥手

TCP 三次握手:四次挥手

TCP 三次握手/四次挥手 TCP 在传输之前会进行三次沟通&#xff0c;一般称为“三次握手”&#xff0c;传完数据断开的时候要进行四次沟通&#xff0c;一般称为“四次挥手”。 数据包说明 源端口号&#xff08; 16 位&#xff09;&#xff1a;它&#xff08;连同源主机 IP 地址…
阅读更多...
sql_lab之sqli注入中的cookie注入

sql_lab之sqli注入中的cookie注入

Cookei注入&#xff08;gxa的从cookei注入&#xff09; 1.打开控制台 2.验证id2时的值 document.cookie"id2" 3.判断是上面闭合方式 document.cookie"id2 -- s" 有回显 说明是’单引号闭合 4.用order by 判断字段数 5.用联合查询判断回显点 接下来的…
阅读更多...
Flowable-升级为7.0.0.M2-第一节

Flowable-升级为7.0.0.M2-第一节

目录 升级jdk升级springboot到3.1.3升级数据库连接池druid-spring-boot-3-starter到1.2.20升级mybatis-plus到3.5.3.2升级flowable到7.0.0.M2 最近有些读者一直问flowable如何升级到7.0.0.M2&#xff0c;接下来我就一步步的把flowable升级到7.0.0.M2 升级jdk flowable7.x采用的…
阅读更多...
框架面试题

框架面试题

文章目录 1. spring中的bean是线程安全的吗2. 事务的实现--AOP3. 项目中用到的AOP4.spring中事务的失效场景5. Bean的生命周期6.spring中的循环引用问题7. springMVC的执行流程8. springboot自动装配原理9. 常见注解10 Mybatis11 Mybatis一二级缓存 1. spring中的bean是线程安全…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023