C++异常

最新推荐文章于 2023-04-26 20:24:16 发布
最新推荐文章于 2023-04-26 20:24:16 发布
阅读量246 收藏 5
点赞数 11
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53421868/article/details/125099925
版权
本文详细介绍了C++异常处理的概念、使用方法，包括抛出和捕获的原则，自定义异常体系的基类捕获和多态获取，异常栈展开和匹配，以及异常安全和规范。讨论了优点如清晰错误信息和异常优势应用，同时也提到了缺点如执行流跳跃和性能开销。
摘要由CSDN通过智能技术生成

在这里插入图片描述

目录

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

传统的错误处理机制：

  1. 终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
int *p = new int[0xffffffffff];
assert(p);

  1. 返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误。

  2. C 标准库中setjmp和longjmp组合。这个不是很常用，了解一下，实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误

C++异常概念

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

  • throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
  • catch: 在您想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异常，可以有多个catch进行捕获。
  • try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。
  • 如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。使用 try/catch 语句的语法如下所示：
try
{
	char* p = new char[0xfffffff];
}
catch (const std::exception& e)
{
	cout << e.what() << endl;  //打印异常原因
}


try
{
	int a = 1 / 0;
}
catch (...)  //捕捉任意类型的异常, 缺点是不知道异常的错误是什么。
{
	cout << e.what() << endl;  //打印异常原因
}

除零错误捕捉该异常

void test(int i, int j) 
{
	if (j == 0) throw j;
	cout << i / j << endl;
}
int main() 
{
	try
	{
		int i = 10, j = 0;
		test(i, j);
	}
	catch (const int error)
	{
		cout << "处理错误" << error << endl;
	}
	return 0;
}

如果需要特殊处理可以使用错误编号，异常特殊处理防止内存泄漏

class Myexception
{
public:
	Myexception(int execid, const string& execmsg)
		:_execid(execid)
		, _execmsg(execmsg)
	{}
	int Geteid()const  { return _execid; }
	string Getemsg()const { return _execmsg; }
private:
	int _execid;
	string _execmsg;
};

void f1() //除零错误
{
	int i = 10, j = 0;
	if (!j) throw (1, "除零错误");
	cout << i / j << endl;
}


int* p1 = nullptr;
FILE* p2 = nullptr;

void f2() //malloc失败错误
{
	p1 = new int[0x7ffffff];
	if (!p1) throw Myexception(2, "malloc失败错误");
}

void f3() //打开文件失败错误
{
	p2 = fopen("./sadasfa.txt", "r");
	if (!p2) throw Myexception(3, "文件打开失败错误");
}

int main() 
{
	try
	{
		f1();
		f2();
		f3();
	}
	catch (const Myexception& e)
	{
		cout << e.Geteid() << e.Getemsg() << endl;
		if (e.Geteid() == 3) //异常特殊处理，防止内存泄漏 
			delete p1; 
	}
	return 0;
}

异常的使用

3.1 异常的抛出和捕获异常的抛出和匹配原则

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

基类类型捕捉异常派生类对象 - 自定义异常体系

只是简单的使用基类引用捕捉子类异常对象的过程，并不对功能做过多的实现， 简述这个过程，当程序在执行的过程中如果遇到了（sql、network、Cache）异常情况，则直接抛出该异常对象，程序执行结束，在main函数中捕捉到该异常对象，最后通过Myexception基类异常类的引用接受抛出的异常对象，那么由于切片动作会将子类的父类成员切片给Myexception引用并打印存放在execid、execmsg中的内容。

class Myexception
{
public:
	Myexception(int execid, const string& execmsg)
		:_execid(execid)
		, _execmsg(execmsg)
	{}
	int Geteid()const { return _execid; }
	string Getemsg()const { return _execmsg; }
private:
	int _execid;
	string _execmsg;
};

class Sqlxception : public  Myexception
{
public:
	Sqlxception(int execid, const string& execmsg)
		:Myexception(execid, execmsg)
	{}
private:
};

class Cachexception : public  Myexception
{
public:
	Cachexception(int execid, const string& execmsg)
		:Myexception(execid, execmsg)
	{}
private:
};

class networkexception : public  Myexception
{
public:
	networkexception(int execid, const string& execmsg)
		:Myexception(execid, execmsg)
	{}
private:
	
};

void f1()
{
	int i = 0;
	cin >> i;
	if(i == 1)  //抛出异常子类对象
	throw Sqlxception(i, "查表访问异常: select * from my_table");
}

void f2()
{
	int i = 0;
	cin >> i;
	if (i == 2)//抛出异常子类对象
		throw networkexception(i, "网络连接异常");
}

void f3()
{
	int i = 0;
	cin >> i;
	if (i == 3)//抛出异常子类对象
		throw Cachexception(i, "缓存存储异常");
}

int main() 
{
	try
	{
		f1();
		f2();
		f3();
	}
	catch (const Myexception &e)  //基类引用类型捕捉子类异常对象
	{
		cout << "异常id: "<< e.Geteid() << "错误信息：" << e.Getemsg() << endl; //打印子类对象的错误信息
	}
	return 0;
}

规范的捕获异常方式 - 自定义异常体系

再来看不使用切片赋值的方式，继而使用多态的方式获取异常信息。
1、子类继承父类后，重写父类的虚函数。
2、父类引用指向子类对象。


class Myexception
{
public:
	Myexception(int execid, const string& execmsg)
		:_execid(execid)
		, _execmsg(execmsg)
	{}
	virtual int Geteid()const { return _execid; }
	virtual string Getemsg()const { return _execmsg; }
private:
	int _execid;
	string _execmsg;
};

class Sqlxception : public  Myexception
{
public:
	Sqlxception(int execid, const string& execmsg)
		:Myexception(execid, execmsg)
		, _execid(execid)
		, _execmsg(execmsg)
	{}
	virtual int Geteid()const { return  _execid; }
	virtual string Getemsg()const { return _execmsg; }
private:
	int _execid;
	string _execmsg;
};

class Cachexception : public  Myexception
{
public:
	Cachexception(int execid, const string& execmsg)
		:Myexception(execid, execmsg)
		, _execid(execid)
		, _execmsg(execmsg)
	{}
	virtual int Geteid()const { return  _execid; }
	virtual string Getemsg()const { return _execmsg; }
private:
	int _execid;
	string _execmsg;
};

class networkexception : public  Myexception
{
public:
	networkexception(int execid, const string& execmsg)
		:Myexception(execid, execmsg)
		, _execid(execid)
		, _execmsg(execmsg)
	{}
	virtual int Geteid()const { return  _execid; }
	virtual string Getemsg()const { return _execmsg; }
private:
	int _execid;
	string _execmsg;
};

void f1()
{
	int i = 0;
	cin >> i;
	if(i == 1)  //抛出异常子类对象
	throw Sqlxception(i, "查表访问异常: select * from my_table");
}

void f2()
{
	int i = 0;
	cin >> i;
	if (i == 2)//抛出异常子类对象
		throw networkexception(i, "网络连接异常");
}

void f3()
{
	int i = 0;
	cin >> i;
	if (i == 3)//抛出异常子类对象
		throw Cachexception(i, "缓存存储异常");
}

int main() 
{
	try
	{
		f1();
		f2();
		f3();
	}
	catch (const Myexception &e)  //基类引用类型捕捉子类异常对象
	{
		cout << "异常id: "<< e.Geteid() << "错误信息：" << e.Getemsg() << endl; //打印子类对象的错误信息
	}
	return 0;
}

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

  1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。
  2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
  3. 如果到达main函数的栈，依旧没有匹配的，则终止程序, 如果已经在最近的地方被捕捉了，那么往后都不会再被其他栈帧的try捕捉， 最后终止程序。上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(…)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。
  4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

在这里插入图片描述

注意事项

异常安全

  • 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
  • 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)
  • C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，关于RAII我们智能指针这节进行讲解

异常规范

  • 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
  • 函数的后面接throw()，表示函数不抛异常。
  • 若无异常接口声明，则此函数可以抛掷任何类型的异常

以下表示函数声明 + 抛异常

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() 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();

异常的重新抛出

思维导图：
在这里插入图片描述

double Division(int a, int b) {
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	return (double)a / (double)b;
}
void Func()
{
	// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
	// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
	// 重新抛出去。
	int* array = new int[10];
	try {
		int len, time;
		cin >> len >> time;
		cout << Division(len, time) << endl;
	}
	catch (...)//中途发现异常，只做特殊处理将内存释放，异常交回给上一层
	{
		cout << "delete []" << array << endl;
		delete[] array;
		throw;
	}
	// 如果再最后并没有抛出异常，那么依旧需要释放array的内存
	cout << "delete []" << array << endl;
	delete[] array;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	return 0;
}

自定义异常体系

所有由子类抛出的异常对象最终都由基类Myexception接受并处理异常
在这里插入图片描述

C++标准库的异常体系

C++ 提供了一系列标准的异常，定义在 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：
在这里插入图片描述

以下是对各个异常的说明：

在这里插入图片描述

说明：实际中我们可以可以去继承exception类实现自己的异常类。但是实际中很多公司像上面一样自己定义一套异常继承体系。因为C++标准库设计的不够好用

int main()
{
	try{
		 vector<int> v(10, 5);
		 // 这里如果系统内存不够也会抛异常
		 v.reserve(1000000000);
		 // 这里越界会抛异常
		 v[10] = 100; 
	 }
	 catch (const exception& e) // 这里捕获父类对象就可以
	 {
	 	cout << e.what() << endl;  //打印异常信息
	 }
	 catch (...)  //接受所有类型的异常对象，缺陷是无法直到具体的异常信息
	 {
	 	cout << "Unkown Exception" << endl;
	 }
	 
	 return 0; 
}

异常的优缺点

C++异常的优点：

  1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
  2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。
// 1.下面这段伪代码我们可以看到ConnnectSql中出错了，先返回给ServerStart，ServerStart再
//返回给main函数，main函数再针对问题处理具体的错误。
// 2.如果是异常体系，不管是ConnnectSql还是ServerStart及调用函数出错，都不用检查，因为抛
//出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。
int ConnnectSql()
{
	 // 用户名密码错误
	 if (...)
	 return 1;
	 // 权限不足
	 if (...)
	 
	 return 2; 
}

int ServerStart() {
	 if (int ret = ConnnectSql() < 0)
	 return ret;
	 int fd = socket() 
	 if（fd < 0）
	 return errno; 
}

int main()
{
	 if(ServerStart()<0)
	 ...
	 return 0; 
}
  1. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。
  2. 很多测试框架都使用异常，这样能更好的使用单元测试等进行白盒的测试。
  3. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

C++异常的缺点：

  1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
  2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
  3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。
  4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
  5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用 func（）throw();的方式规范化。

总结： 异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外OO的语言基本都是用异常处理错误，这也可以看出这是大势所趋

在这里插入图片描述

C++什么时候需要使用“常引用”？
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-14 531
如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名； 例1 int a ; const int &ra=a; ra=1; //错误 不能再被赋值 a=1; //正确 例2 string foo( ); void bar(string & s); //非const //那么下面的表达式将是非法的： bar(foo( )); bar("hello world"); 原因在于foo( )
C# 捕获C/C++异常的例子
04-11
为了在C#中处理C++异常，我们需要使用`extern "C"`和`System::Runtime::InteropServices`命名空间中的特性来定义接口和方法。例如： ```csharp using System; using System.Runtime.InteropServices; ...
C++之异常
Amour_Old_flame的博客
02-03 297
异常：        异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接 的调用者处理这个错误。   C语言中的错误处理 在我们的C语言中遇到了错误通常有这三种处理方法 1.程序终止：比如程序异常，出现了除0错误。还有断言assert引起的终止。 2.返回错误码，然后需要我们自己去查对应的错误。 3.C 标准库中setjmp和longjmp...
【C++】异常，你了解了吗？
最新发布
ChaoFreeandeasy_的博客
04-26 1362
在之前的C语言处理错误时，会通过assert和错误码的方式来解决，这导致了发生错误就会直接把程序关闭，或者当调用链较长时，就会一层一层的去确定错误码，降低效率，所以c++针对处理错误，出现了异常，一起来学习！
C++异常处理解析: 异常的引发(throw), 捕获(try catch)、异常安全
weixin_33862188的博客
12-11 1223
前言: C++的异常处理机制是用于将运行时错误检测和错误处理功能分离的一 种机制(符合高内聚低耦合的软件工程设计要求),  这里主要总结一下C++异常处理的基础知识, 包括基本的如何引发异常(使用throw)和捕获异常(try catch)相关使用注意点, 以及C++标准库提供的一套标准异常类和这些异常类的继承层级结构以及相关使用方法和常用习惯. C++异常的引发(throw): 引发C++...
10.c++的异常处理
zheng131511的博客
11-04 294
异常
C++ 异常处理 catch(…)介绍
01-01
C++标准中定义了一种特殊的catch用法，那就是” catch(…)”。 感性认识 1、catch(…)到底是一个什么样的东东，先来个感性认识吧!看例子先： 代码如下:　int main() { try { cout << “在 try block 中, 准备...
C++ 异常的详细介绍
01-21
c++异常为处理这种情况提供了一种功能强大的而灵活的工具。异常是相对比较新的C++功能，有些老编译器可能没有实现。另外，有些编译器默认关闭这种特性，我们可能需要使用编译器选项来启用它。 一、异常机制的使用 ...
浅谈C++ 异常处理的语义和性能
12-22
3. **C++ 加SEH**（/EHa）：这种模式同时支持C++异常和Windows的SEH异常，因此可以捕获更多类型的错误，包括系统级别的异常。这会进一步增加代码大小，因为需要处理更多的异常情况，但提高了程序的健壮性。 在讨论...
c++异常处理机制示例及详细讲解
01-01
这两天我写了一个测试c++异常处理机制的例子，感觉有很好的示范作用，在此贴出来，给c++异常处理的初学者入门。本文后附有c++异常的知识普及，有兴趣者也可以看看。下面的代码直接贴到你的console工程中，可以运行...
C++异常 返回错误码
weixin_33729196的博客
07-14 597
一种比异常终止更灵活的方法是，使用函数的返回值来指出问题。例如，ostream类的get(void)成员ASCII码，但到达文件尾时，将返回特殊值EOF。对hmean()来说，这种方法不管用。任何树脂都是有效的返回值，因此不存在可用于指出问题的特殊值。在这种情况下，可使用指针参数或引用参数来将值返回给调用能够程序，并使用函数的返回值来指出成功还是失败。istream族重载&gt;&gt;运算符使用...
C++异常 异常机制
weixin_34211761的博客
07-14 142
C++异常是丢程序运行过程中发生的异常情况（例如被0除）的一种响应。异常提供了将控制权从程序的一个部分传递到另一部分的途径。对异常的处理有3个组成部分：* 引发异常；* 使用处理程序捕获异常；* 使用try块。程序在出现问题时将引发异常。throw语句实际上是跳转，即命令程序跳到另一条语句。throw关键字表示引发异常，紧随其后的值（例如字符串或对象）指出了异常的特征。程序使用异常处理程序（exc...
c++函数返回时异常出错原因
大漠苍狼----不抛弃，不放弃
10-15 1410
不断的注释调试，发现分配一个字符数组 char msg[40]; sprintf(msg, "恭喜，突破历史记录，获得最高分%d！", nowScore);  注释掉就不会出错，然后把msg长度设置为100就可以了，原因是字符串太长，函数内参数栈分配的存储空间不够，溢出导致的。。。   打印这个字符串长度 CCLog("%s length=%d", msg, strlen(msg))...
C++ 异常处理
山重水复疑无路,柳暗花明又一村
11-03 257
C++ 异常处理 异常是程序在执行期间产生的问题。C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。 异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw。 throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。 catch: 在您想要处理问题的地方，通过异常处理程序捕获
C++异常处理
the_sea1的博客
10-30 226
异常是程序在执行期间产生的问题。C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。 异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw。 throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。 catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。 ...
详解C++异常
轻松学C语言
08-08 528
点击蓝字关注我们1、异常概念异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。catch: 在您想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异常，可以有多个catch进行捕获。try: tr...
C++异常(exception)第一篇--综合讲解
weixin_30387663的博客
08-02 471
摘要：catch(exception &ex)是捕获所有标准库定义中的类std:exception;catch(...)则是捕获所有的异常。 1.简介 异常是由语言提供的运行时刻错误处理的一种方式。提到错误处理，即使不提到异常，你大概也已经有了丰富的经验，但是为了可以清楚的看到异常的好处，我们还是不妨来回顾一下常用的以及不常用的错误处理方式。 C...
C++异常：exception
weixin_30344131的博客
02-17 254
基本知识 下图表示了标准异常的继承关系 exception是所有标准异常的基类，自定义异常也需要继承exception，如下例： 1 #include "pch.h" 2 #include <iostream> 3 4 using namespace std; 5 6 struct MyException:public exception { ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱生活，爱代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值