【C++11】异常

news/2024/12/2 20:27:24/

🌈1.C语言传统处理错误的方式

在讲解C++的异常机制之前我们先来复习一下传统的处理错误的方式。

传统的错误处理机制：

  • 1.终止程序、如assert , 缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
  • 2.返回错误码、缺陷：需要程序员自己去寻找对应的错误，如系统的很多库的接口函数都是通过把错误码放到error中来表示错误。

实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。 

🌈2.C++异常概念

异常是一种处理错误得方式，当一个函数发现自己无法处理的错误时就可以抛异常，让函数直接的或者间接的调用者处理这个错误。异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw:

  • throw: 当问题出现，程序通过throw抛出一个异常;
  • catch: 在你想要处理问题的地方，通过异常处理程序捕获异常;
  • try: try 块中的代码标识将被激活的特定异常。它后面允许跟着一个或多个 catch 块;
    使用 try/catch 语句的语法：

如果有一个块抛出一个异常，捕获异常的方法会使用try和catch关键字。try块中放置可能抛异常的代码，try块中的代码被称为保护代码。使用try/catch语句的语法如下：

try 
{// 保护代码
}catch( ExceptionName e1 ) 
{// catch 块
}catch( ExceptionName e2 ){// catch 块
}catch( ExceptionName eN ) 
{// catch 块
}

🌈 3.异常的使用

🍄3.1异常的抛出和使用

🌼异常的抛出和匹配原则：

  • 1.异常是通过抛出对象而引发的，该对象的类型决定了应该激活那个catch的处理代码。
  • 2.被选中的处理代码（catch块）是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
  • 3.抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（类似于函数的传值返回）
  • 4.catch(...)可以捕获任意类型的异常，但捕获后无法知道异常错误是什么。
  • 5.实际异常的抛出和捕获的匹配原则有个例外，捕获和抛出的异常类型并不一定要完全匹配，可以抛出派生类对象，使用基类捕获。

异常必须捕获，不捕获就会报错。

🌼在函数调用链中异常展开栈展开匹配原则

  1. 当异常被抛出后，首先检查throw本身是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。
  2. 如果当前函数栈没有匹配的catch则退出当前函数栈，继续在上一个调用函数栈中进行查找匹配的catch。找到匹配的catch子句并处理以后，会沿着catch子句后面继续执行，而不会跳回到原来抛异常的地方。
  3. 如果到达main函数的栈，依旧没有找到匹配的catch，则终止程序。
  4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

 例如以下代码：

#include<iostream>
using namespace std;double Division(int a, int b)
{//当b==0时抛异常if (b == 0)throw "Division by zero condition!";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;}return 0;
}

当Division中的异常被抛出后：

  • 首先会检查throw本身是否在try块内部，这里由于throw不在try块内部，因此会退出Division所在的函数栈，继续在上一个调用函数栈中进行查找，即Func所在的函数栈。
  • Func中也没有匹配的catch，于是就会在main所在的函数栈中进行查找，最终在main函数栈中找到了匹配的catch。
  • 这时就会跳到main函数中对应的catch块中执行对应的代码块，执行完后继续执行该代码块后续的代码.

此代码抛出了一个类型为 const char* 的异常，因此捕获异常时，须在 catch 块中使用 const char*。

  • 如果您想让 catch 块能够处理 try 块抛出的任何类型的异常，则必须在异常声明的括号内使用省略号 ...，如下所示:
try {// 保护代码}
catch(...) {// 能处理任何异常的代码
}

这个可以防止出现未捕获的异常时程序崩溃。

🍄3.2异常的重新抛出 

有时候单个的catch可能不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可通过重新抛出将异常传递给更上层的函数进行处理。

但如果直接让最外层捕获异常进行处理可能会引发一些问题。

double Division(int a, int b)
{if (b == 0)  //b==0时会抛出异常{throw" Division by zero condition!";}return (double)a / (double)b;
}
void Func()
{int* array = new int[10];int len, time;cin >> len >> time;cout << Division(len, time) << endl;cout << "delete []" << array << endl;delete[] array;}int main()
{try {Func();}catch (const char* errmsg){cout << errmsg << endl;}return 0;
}

  •  我们就先看Func功能函数那一块，先new一块空间，然后就可以通过delete释放了，这种情况是未抛异常是的运行，但是肯定会有点不正常的情况--------->>>>>>>
  • 如果说Division函数抛出一个异常，这时会直接跳转到main函数中的catch块执行对应的异常处理程序，并且在处理完后继续沿着catch块往后执行。
  • 这时就导致Func中申请的内存块没有得到释放，造成了内存泄露。

  • 这时可以在Func中先对Func抛出的异常进行捕获，捕获后先将申请到的内存释放再将异常重新抛出，这时就避免了内存泄露。
void Func()
{int* array = new int[10];int len, time;cin >> len >> time;try{cout << Division(len, time) << endl;}catch(...){cout << "delete []" << array << endl;delete[] array;throw;  //捕获什么抛出什么}cout << "delete []" << array << endl;delete[] array;}

🍄3.3异常安全问题

将抛异常导致的安全问题叫做异常安全问题，对于异常安全问题下面给出几点建议：

  1. 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化。
  2. 析构函数主要完成对象资源的清理，最好不要在析构函数中抛出异常，否则可能导致资源泄露（内存泄露、句柄未关闭等）。
  3. C++中异常经常会导致资源泄露的问题，比如在new和delete中抛出异常，导致内存泄露，在lock和unlock之间抛出异常导致死锁，C++经常使用RAII的方式来解决以上问题。

🍄3.5异常规范 

为了让函数使用者知道某个函数可能抛出哪些类型的异常，C++标准规定：

  1. 在函数的后面接throw(type1, type2, ...)，列出这个函数可能抛掷的所有异常类型。
  2. 在函数的后面接throw()或noexcept（C++11），表示该函数不抛异常。
  3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。（异常接口声明不是强制的）。

例如以下代码：

//表示func函数可能会抛出A/B/C/D类型的异常
void func() throw(A, B, C, D);
//表示这个函数只会抛出bad_alloc的异常
void* operator new(std::size_t size) throw(std::bad_alloc);
//表示这个函数不会抛出异常
void* operator new(std::size_t size, void* ptr) throw();

🌈4.自定义异常体系 

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。

查看源图像

 例如以下代码：

//父类接口
class Exception
{
public:Exception(int errid = 0, const string& errmsg = ""):ErrId(errid), ErrMsg(errmsg){}virtual string what() const{return ErrMsg;}
protected:int ErrId;string ErrMsg;//异常消息
};//子类进行继承
//定义一个内存错误
class MemException :public Exception
{
public:MemException(int errid = 0, const string& errmsg = "", const string& memstring = ""):Exception(errid, errmsg), MemString(memstring){}virtual string what() const{string str = "MemError: ";str += ErrMsg;str += "[Mem:";str += MemString;str += "]";return str;}private:string MemString;
};//定义一个链接错误
class LinkException :public Exception
{
public:LinkException(int errid = 0, const string& errmsg = "", const string& linkstring = ""):Exception(errid, errmsg), LinkString(linkstring){}virtual string what() const{string str = "LinkError:";str += ErrMsg;str += "[Link:";str += LinkString;str += "]";return str;}private:string LinkString;
};void func()
{int val = rand() % 10;if (val == 2)//假设为内存错误{MemException e(1, "内存错误", "申请内存过大");//构建一个异常对象throw e;}else if (val == 3)//假设为链接错误{LinkException e(2, "链接错误", "链接对象过多");//构建一个链接异常对象throw e;}else if (val == 4){vector<int>(1000000000, 110000000);//使用系统异常}}
int main()
{srand((unsigned)time(NULL));for(int i=0;i<100;i++){try{func();}catch (const Exception& e){cout << "自定义异常体系：" << e.what() << endl;}catch (const exception& e){cout << "C++自带异常体系" << e.what() << endl;}catch (...){cout << "未知异常" << endl;}}return 0;
}

（这个代码是@今天我要写bug大佬写的，我借用以下）

 🌈5.C++标准库的异常体系

 C++标准库当中的异常也是一个基础体系，其中exception就是各个异常类的基类，我们可以在程序中使用这些标准的异常，它们之间的继承关系如下：

71. 异常

 71. 异常

 

🌈6.异常的优缺点 

  • 异常的优点：
  1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用等信息，这样可以帮助更好的定位程序的bug。
  2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误码，最终最外层才能拿到错误。
  3. 很多的第三方库都会使用异常，比如boost、gtest、gmock等等常用的库，如果我们不用异常就不能很好的发挥这些库的作用。
  4. 很多测试框架也都使用异常，因此使用异常能更好的使用单元测试等进行白盒的测试。
  5. 部分函数使用异常更好处理，比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。
  • 异常的缺点：
  1. 异常会导致程序的执行流乱跳，并且非常的混乱，这会导致我们跟踪调试以及分析程序时比较困难。
  2. 异常会有一些性能的开销，当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
  3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄露、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题，学习成本比较高。
  4. C++标准库的异常体系定义得不够好，导致大家各自定义自己的异常体系，非常的混乱。
  5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，也会让外层捕获的用户苦不堪言。
  6. 异常接口声明不是强制的，对于没有声明异常类型的函数，无法预知该函数是否会抛出异常。

既然C++11提出了异常，那它就是利大于弊的，但是各位小伙伴在使用时一定要注意操作规范！


http://www.ppmy.cn/news/7020.html

相关文章

AUTOSAR开发

AUTOSAR开发

综述 本文档主要描述了VP项目MCU芯片TC297的AUTOSAR方案。MCU的基础软件由AUTOSAR软件实现&#xff0c;AUTOSAR可简易理解为如下层次。 MCU芯片驱动层&#xff1a;MCU芯片的抽象层&#xff0c;目的是将各类MCU芯片进行抽象&#xff0c;向上统一接口&#xff0c;隔离其他层次软件…
阅读更多...
关于json.dumps中的参数详解

关于json.dumps中的参数详解

中文编码问题 这样一段代码&#xff1a; import json dict {id: 1, title: b\xe7\xac\xac\xe4\xb8\x80\xe7\xab\xa0 \xe7\xa7\xa6\xe7\xbe\xbd} dup json.dumps(dict ,ensure_asciiFalse) print(dup)Python2执行输出&#xff1a; {"id": 1, "title": …
阅读更多...
【vue设计与实现】编译器 - 转换上下文与节点操作 进入与退出

【vue设计与实现】编译器 - 转换上下文与节点操作 进入与退出

context.nodeTransforn 数组&#xff0c;这里的 context 可以看作AST转换函数过程中的上下文数据。所有 AST转换函数都可以通过 context来共享数据。上下文对象中通常会推护程序的当前状态。上下文对象中包含的信息对于编写复杂的转换函数非常有用。接下来我们要做的就是构造转…
阅读更多...
详解SpringBean的作用域（Scopes）

详解SpringBean的作用域（Scopes）

文章目录一、SpringBean作用域总览二、"singleton" Bean作用域三、"prototype" Bean作用域1、验证singleton、prototype类型的Bean2、总结四、"request" Bean作用域1、配置2、简介五、"session" Bean作用域1、配置2、简介3、总结sessi…
阅读更多...
MyBatis 中的动态 sql

MyBatis 中的动态 sql

动态 sql 简单来讲就是我们能通过条件的设置生成不同的 sql&#xff0c;MyBatis 中常用的动态 sql 表达式主要是有五种&#xff1a; if choose (when, otherwise) trim, where, set foreach sql if 动态 sql 中最常见的场景是根据条件查询&#xff0c;比如要实现一个查询…
阅读更多...
好书推荐《C++17 in Detail》

好书推荐《C++17 in Detail》

无意中发现作者的博客&#xff08;https://www.cppstories.com/&#xff09;和这本书。这本书算是对C17新增特性较为全面的介绍&#xff0c;而且从实战出发&#xff0c;不流于语法细枝末节&#xff0c;简洁清晰&#xff0c;可以作为Scott Meyers那本非著名的《Effective Modern…
阅读更多...
青少年等级考试【Python通关干货】（二级）

青少年等级考试【Python通关干货】（二级）

青少年等级考试【Python通关干货】（二级）1.列表类型的概念 2.序列的通用操作 3.可变序列及列表的通用操作 4.列表的特有操作 5.元组类型的概念与操作
阅读更多...
Hive+Spark离线数仓工业项目--数仓维度层DWS层构建（1）

Hive+Spark离线数仓工业项目--数仓维度层DWS层构建（1）

维度建模回顾&#xff1a;建模流程 目标&#xff1a;掌握维度建模的建模流程 实施 step1-需求调研&#xff1a;业务调研和数据调研 - 了解整个业务实现的过程 - 收集所有数据使用人员对于数据的需求 - 整理所有数据来源 step2-划分主题域&#xff1a;面向业务将业务…
阅读更多...
最新文章

Copyright @ 2022~2023