C++异常的规则

最新推荐文章于 2023-12-11 12:03:25 发布
最新推荐文章于 2023-12-11 12:03:25 发布
阅读量2.5k 收藏 2
点赞数 4
分类专栏： C/C++学习 文章标签： c++ 异常 异常安全 异常规范
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w903414/article/details/114208768
版权

异常是指存在于程序运行时的异常行为，这些行为超出了函数正常功能的范围，当程序的某部分检测到一个无法处理的问题时，就需要用到异常处理。

目录

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

终止程序：如assert，当发生错误时，直接终止程序，这样的作法不友好。

返回错误码：如果函数体里发生错误时，将错误码返回给coder，需要去查找对应的错误，系统的库函数接口就是通过把错误码放到errno中，表示错误。

Windows下，使用perror打印全部错误：

	for (int i = 0; i < 43; ++i)
	{
		cout << i << " :  ";
		perror(strerror(i));
		cout << endl;
	}

大部分情况下，C语言出现错误，都是使用的是返回错误码的方式处理，部分情况下使用终止程序来处理十分严重的错误。

2. C++中处理异常的方式

如果程序中含有可能引发异常的代码，那么通常也需要有专门的代码处理问题，如：程序的问题是输入无效，则异常处理部分可能会要求用户重新输入正确的数据。

异常处理机制为程序中异常检测和异常处理这两部分的协作提供支持，C++中，异常处理包括：

  1. throw：异常检测部分使用throw来表示它遇到了无法处理的问题，此时就会抛异常；
  2. catch：用于捕获异常，可以有多个catch同时进行捕获；
  3. try：try块中的代码抛出的异常通常会被一个或多个catch处理，因为catch处理异常，所以他们也被称为异常处理代码。

2.1 throw

程序的异常检测部分使用throw抛出一个异常，throw后紧跟一个表达式，该表达式的类型就是抛出的异常类型。

一般来说，直接将异常抛出，交给后面的程序处理异常，不应该将异常信息给直接输出。

int main()
{
	FILE* fp = fopen("a.txt", "a");

	//抛出异常的类型为string类型
	if (fp == nullptr)
		throw string("请检查文件是否存在");

	return 0;
}

2.2 try

try关键字后，紧跟着一个块，这个块中是花括号扩起来的语句序列，跟在try块之后的是一个或多个catch子句；

catch子句包括三部分：关键字catch、括号内的对象声明（异常声明，异常类型，抛出异常的类型要和catch处理的异常类型相同），一个处理异常的代码块；

当选中某个catch子句处理异常后，执行与之对应的块，catch一旦完成，程序跳转到try语句最后一个catch之后的语句继续执行。

int main()
{
	try
	{
		FILE* fp = fopen("a.txt", "r");// 以只读方式打开一个文件

		if (fp == nullptr)
			throw string("请检查文件是否存在");
	}
	catch (const char* msg)// char*类型异常
	{
		cout << msg << endl;
	}
	catch (const string& msg)//string类型异常
	{
		cout << msg << endl;
	}
	catch (...)//...  代表可以捕获任意类型的异常
	{
		cout << "出现了无法解决的异常" << endl;
	}
	return 0;
}

3. 异常抛出和捕获的规则

  1. 异常是通过抛出对象而引起的，该对象的类型决定了应该匹配哪个catch的处理代码；
  2. 异常处理部分catch，是调用链中与该类型匹配且抛出异常位置最近的那一个；
  3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的对象可能是一个临时对象，所以会生成一个拷贝对象，该拷贝的临时对象会在catch结束后销毁；
  4. catch(...)可捕获任意类型异常，代表了不知道出现异常的错误是什么，也就无法进行解决；
  5. 在异常的抛出和捕获中，并不是类型的完全匹配，可以抛出派生类对象，使用基类捕获（很重要）。

在函数调用链中异常栈展开的匹配规则：

  1. 先检查throw是否在try块内部，如果是则再查找匹配的catch语句，如果有匹配则调用catch的异常处理代码；
  2. 若没有匹配的catch异常处理代码，则退出当前函数栈，继续在调用函数栈中查找匹配catch；
  3. 如果达到main函数栈中，仍没有匹配，则终止程序，沿着调用栈查找匹配的catch子句的过程称为栈展开；所以一般情况下，都要在最后加一个catch(...)捕获任意类型的异常，否则当有异常没有被捕获时，就会导致程序终止；
  4. 找到匹配的catch子句后，会沿着catch之后的代码继续执行。

注意：

  1. throw可以抛出任意类型的异常，抛出的异常必须进行捕获，否则程序就会终止；
  2. throw抛出异常后，若是在多个函数栈中调用时，会直接跳转到有匹配的catch子句中，若没有匹配的子句时，程序终止；
  3. catch(...)可捕获任意类型异常。

3.1 异常重新抛出

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

double Div(int a, int b)
{
	if (b == 0)
		throw string("发生了除0错误");
	return a / b;
}

void func()
{
	int *p = new int(10);

	int b = 0;
	cout << Div(*p, b);

	delete p;
}

int main()
{
	try
	{
		func();
	}
	catch (const string& s)
	{
		cout << s << endl;
	}
	return 0;
}

上述代码中，会出现内存泄漏，throw抛出的异常，直接跳转到main函数栈中，则会导致func中，申请的空间没有释放，造成内存泄漏，则需要对该异常进行重新捕获，并且释放该空间，避免内存泄漏。

这样修改就不会存在内存泄漏：

void func()
{
	int *p = new int(10);
	try
	{
		int b = 0;
		cout << Div(*p, b);
	}
	catch (...)
	{
		delete p;
		throw;
	}

	delete p;
}

4. 异常安全

异常安全：异常导致的安全问题。

异常中断了程序的正常流程，异常发生时，调用者请求的一部分计算可能已经完成了，另一部可能还没完成。通常情况下，略过部分程序意味着某些对象处理到一般就戛然而止了，从而导致对象处于无效或未完成的状态，或者资源没有被正常释放。
那些在异常发生期间正确执行了“清理”工作的程序被称为异常安全的代码。

注意：

  1. 构造函数完成对象的构造和初始化，最好不要在构造函数中抛异常，否则可能导致对象不完整或者没有完全初始化；
  2. 析构函数主要完成资源的清理，最好不要在析构函数中抛出异常，否则可能导致资源泄漏；
  3. C++中经常会导致资源泄漏的问题，如new 和 delete中抛出异常，导致内存泄漏，lock和unlock之间抛出遗产，导致死锁，C++经常使用RAII来解决上述问题；

4.1 异常规范

  1. 异常规则说明说明的目的是为了让函数使用者知道该函数可能抛出什么异常，在函数后面接throw，列出这个函数可能抛出的所有异常类型；
void func() throw(string, char, char*);//可抛出三种类型的异常
void* operator new(size_t) throw(bad_alloc);//只会抛bad_alloc异常
  1. 函数后面接throw()，表示不会抛出异常；
void func() throw();//不抛异常
void* operator new(size_t) throw();//不抛异常
  1. 如果没有异常接口声明，则可以抛任意类型的异常。

5. 自定义异常体系

自定义异常的体系，一般情况下，抛出派生类的异常，由基类捕获，这样在不同的派生类中，可以抛出许多不同的异常，而且具有相同的调用方式（由基类调用），避免调用混乱，方便管理。

class Exception
{
public:
	Exception(const char* msg)
		:_errmsg(msg)
	{}

	virtual string what() = 0;//纯虚函数，接口类
	string _errmsg;
};

class NetException : public Exception
{
public:
	NetException(const char* msg)
		:Exception(msg)
	{}
	virtual string what()
	{
		return "网络错误" + _errmsg;
	}
};

class SqlException : public Exception
{
public:
	SqlException(const char* msg)
		:Exception(msg)
	{}
	virtual string what()
	{
		return "数据库错误" + _errmsg;
	}
};

那么在捕获的时候，只需要捕获基类的异常即可：

void Func()
{
	if (rand() % 33 == 0)
		throw SqlException("数据库启动出错");
	else if(rand() % 17 == 0)
		throw NetException("网络连接出错");
}


int main()
{
	for (int i = 0; i < 188; ++i)
	{
		try
		{
			Func();
		}
		catch (Exception& e)//捕获基类 即可
		{
			cout << e.what() << endl;
		}
	}
	return 0;
}

6. 标准异常

stdexcept头文件定义了几种常用的异常类：

异常描述
logic_error程序逻辑出错，一般通过读取代码来解决
domain_error逻辑错误，参数 对应的结果值不存在
invalid_argument逻辑错误：无效参数
length_error逻辑错误：创建一个超出该类型最大长度的对象
runtime_error运行时才能检测出的问题，一般无法通过读取代码来解决
range_error运行时出错：生成的结果超出了有意义的值域范围
overflow_error计算上溢
underflow_error计算下溢出

new头文件中，定义了bad_alloc异常类型：

异常描述
bad_allocnew分配内存失败时导致的异常

typeinfo头文件定义了两个异常类型：

异常描述
bad_typeid对null指针的的typeid抛出异常
bad_cast动态转换失败时引发异常

7. 异常优缺点

优点：

  1. 清晰的包含错误信息；
  2. 如果有越界问题时，可以很方便的处理；
  3. 多层调用时，里层发生错误，不会层层调用，最外层可直接捕获；
  4. 一些第三方库也是使用异常，使用异常时可以很方便使用这些库：如boost

缺点：

  1. 异常会导致执行流跳转，分析程序时会有一些问题；
  2. C++中没有GC，异常可能会导致资源泄漏的风险；
  3. C++库中定义的异常体系，可用性不高，一般自己定义；
  4. C++可以抛任意类型的异常，则需要对异常最很好的规范管理，否则就会非常混乱，所以一般定义出继承体系下的异常规范。
[C++]---异常及处理方法
夜微雨的博客
03-06 520
一.C语言传统的处理错误的方式 传统的错误处理机制： 1. 终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。 2. 返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误。 实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。 二. C++异常概念 ...
C++ 异常说明/规范
生命不息, 战斗不止!
12-08 1958
1. 概念  异常说明/规范(exception specification)指定, 如果函数抛出异常, 被抛出的异常将是包含在该说明中的一种, 或者是从列出的异常中派生的类型.  2. 定义 异常说明跟在函数形参表之后. 一个异常说明在关键字throw之后跟着一个(可能为空的)由圆括号括起来的异常类型列表. 如: void foo(int) throw (std::l
10.5 异常规范
芝麻软件工作室的专栏
06-15 586
◆ 1、异常规范（exception specification）是指：提供了一种方案，可以随着函数声明列出该函数可能抛出的异常，并保证该函数不会抛出任何其他类型的异常。例如，在stack类定义中可有：     void Push(const T&data) throw(pushOnFull) ;     T Pop() throw(popOnEmpty); //红色部分是异常规范
c++ 异常规范
強雲的博客
08-23 187
在C++中，可以在函数声明后指明可能会抛出的异常类型。但是，异常规范的使用是有争议的，而且在某些情况下可能会引发不预期的问题。：当函数实现变更时，异常规范可能需要重新评估和更新，这可能会导致维护问题。：异常规范限制了函数可能抛出的异常类型。如果函数抛出了异常规范外的异常，：在某些编译器和平台上，异常规范可能导致额外的运行时开销。对性能的影响更为正面，并且在现代C++编码中更为推荐。这可能导致程序意外地终止。规范，它表示函数不会抛出异常。：从C++11开始，引入了。
C++中的异常规范
woaiyu6464的专栏
10-13 687
以前在网上看到有人问函数后面加throw()的用处。今天在C++PRIMER中看到了异常规范一章，总结一下吧。理论书上已经讲得很清楚，咱就直接上代码实践一把吧。代码均用g++（3.4.2版本）编译，微软的cl编译器会出现不同结果，估计是用非标准C++的结果。首先定义一个简单的异常类===============================#includeusing namespace std;class myException{public:myException(string err):_ms
MISRA C++ 2008 规则整理.pdf
09-15
MISRA C++ 2008 规则整理中包含了大量的规则和指南，涵盖了函数定义、参数使用、返回值、循环语句、判断语句、异常处理等多个方面。 首先，让我们来看一下函数定义方面的规则。在 MISRA C++ 2008 规则整理中，定义...
C++ 98相关 规则 C++ 98 C++ 98
最新发布
05-28
该标准定义了C++编程语言的基本语法和语义规则，以及相关的程序设计指南。它为C++语言提供了一个统一的标准框架，使得开发者可以在不同的平台上编写可移植的代码。 ### 二、C++ 98标准的关键特点 #### 2.1 语言...
c++实现关联规则Apriori算法
10-30
总的来说，"c++实现关联规则Apriori算法"涉及的知识点包括数据挖掘、关联规则学习、Apriori算法、C++编程、VS2010开发环境、数据结构和算法优化。掌握这些知识，将有助于我们开发出适用于各种场景的高效数据挖掘工具...
C_C++函数符号生成规则（函数名的修饰）；C++ 函数重载.pdf
09-30
C_C++函数符号生成规则（函数名的修饰）；C++ 函数重载.pdf 本文主要介绍了C和C++函数符号生成规则，以及C++函数重载机制。 一、C函数符号生成规则 在C语言中，函数符号生成规则主要有三种：cdecl调用约定、std ...
C++异常规范
shangcangriluo的专栏
12-21 381
void func() throw(int);表示只抛出int类型异常 void func() throw(int，char);表示抛出in，char类型异常 void func() throw();表示不会抛出任何类型异常 void func() throw(...);表示抛出任何类型异常 更多：http://blog.csdn.net/zdl1016/article/details
【C++】C++异常语法、使用、规范、异常安全及异常的优缺点
weixin_51692487的博客
12-11 417
实际中我们可以可以去继承exception类实现自己的异常类。但是实际中很多公司像上面一样自己定义一套异常继承体系。因为C++标准库设计的不够好用。如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。C++ 提供了一系列标准的异常，定义在 中，我们可以在程序中使用这些标准的异常。异常是一种处理错误的方式，
【C++】一文读懂C++中的异常处理机制
Friday
06-24 1964
程序有时会遇到运行阶段错误，导致程序无法正常地运行下去。例如，程序可能试图打开一个不可用的文件，请求过多的内存，或者遭遇不能容忍的值。通常，程序员都会试图预防这种意外情况。C++异常为处理这种情况提供了一种功能强大而灵活的工具。对于上述表达式，如果y是x的负值，则上述公式将导致被零除——一种不允许的运算。对于被零除的情况，很多新式编译器通过生成一个表示无穷大的特殊浮点值来处理，cout将这种值显示为Inf、inf、INF或类似的东西；而其他的编译器可能生成在发生被零除时崩溃的程序。
异常的规则
Lna的博客
07-30 405
需要进行异常处理的代码应该放入 try 代码块内，以便捕获潜在的异常。每个 try 或 throw 代码块必须至少拥有一个对应的 catch 代码块。使用多个 catch 代码块可以捕获不同种类的异常。 可以在 try 代码块内的 catch 代码块中再次抛出（re-thrown）异常。 简而言之：如果抛出了异常，就必须捕获它。
C++中的异常处理机制以及异常规范
热门推荐
scmuzi18的博客
04-04 1万+
以下代码运行环境为64位系统下的VS2013 C++中的异常情况： 语法错误（编译错误）：比如变量未定义、括号不匹配、关键字拼写错误等等编译器在编译时能发现的错误，这类错误可以及时被编译器发现，而且可以及时知道出错的位置及原因，方便改正。 运行时错误：比如数组下标越界、系统内存不足等等。这类错误不易被程序员发现，它能通过编译且能进入运行，但运行时会出错，导致程序崩溃。 为了有效
异常规范 C++11
xkdlzy的专栏
04-23 9384
异常规范 C++11 noexcept throw
异常处理的规则
tomkerry的专栏
02-25 223
  本文收藏自网络   1、  只记录技术上的异常，不记录用户异常       像“用户名已存在”这种异常是不用记录的，但是你需要把它们展示给用户。你需要记录的是类似“磁盘已满”这种技术上的异常，并对这些异常进行相应的处理。如果你把所有的异常都记录到你的日志中，那么你会因为有太多的异常记录，而无法对你日志文件中的异常做出有效处理。你需要研究日志文件中的每一个异常，猜测造成它的原因...
异常处理规则
longming丶123的博客
08-24 743
一.不要过度使用 异常 不可否认，Java的异常机制确实方便，但滥用异常机制也会带来一些负面影响。过度使用异常主要有两个方面。 1.把异常和普通错误混淆在一起，不再编写任何错误处理代码，而是以简单地抛出异常来代替所有的错误处理。 2.使用异常处理来代替流程控制。 异常处理机制的初衷是将不可预期异常的处理代码和正常的业务逻辑处理代码分离，因此绝不要使用异常处理来代替正常的业务逻辑判断。 异
C++异常处理深度探索
2. C++中异常处理的游戏规则：这可能解释了C++异常处理的一些规范和最佳实践，例如何时应该抛出异常，如何设计自定义异常类，以及如何避免异常传播时的问题。 3. C++中catch(…)的使用：`catch(...)`是一个通配符...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值