【C++从青铜到王者】第二十三篇:C++异常

快来打我* 2022-09-09 13:57 146阅读 0赞

![在这里插入图片描述][450c7d50d1d84a58b31a09f3078e62f0.gif_pic_center]

# 系列文章目录 #

--------------------

### 文章目录 ###

*  系列文章目录
 *  前言
 *  一、C语言传统的处理错误的方式
 *  二、C++异常概念
 *  三、异常的使用
 *   *   *  1.异常的抛出和捕获
         *  2.异常的重新抛出
         *  3.异常安全
         *  4.异常规范
 *  四、自定义异常体系
 *  五、C++标准库的异常体系
 *  六、异常的优缺点
 *   *   *  1.C++异常的优点：
         *  2.C++异常的缺点：
 *  总结

--------------------

# 前言 #

--------------------

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    #include<vector>
    using namespace std;
    int main()
    { 
    	vector<int> v = {  1, 2, 3, 4, 5, 6 };
    	for (int i = 0; i <= v.size(); i++)
    	{ 
    		cout << v[i] << " ";
    		//cout << v.at(i) << " ";
    	}
    	cout << endl;
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16]

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    #include<vector>
    using namespace std;
    int main()
    { 
    	vector<int> v = {  1, 2, 3, 4, 5, 6 };
    	for (int i = 0; i <= v.size(); i++)
    	{ 
    		//cout << v[i] << " ";
    		cout << v.at(i) << " ";
    	}
    	cout << endl;
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 1]

*  **传统的错误处理机制：**
 *  终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
 *  返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误。
 *  C 标准库中setjmp和longjmp组合。这个不是很常用，了解一下。

**实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 2]

# 二、C++异常概念 #

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 3]

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    #include<vector>
    using namespace std;
    int main()
    { 
    	try
    	{ 
    		vector<int> v = {  1, 2, 3, 4, 5, 6 };
    		for (int i = 0; i <= v.size(); i++)
    		{ 
    			//cout << v[i] << " ";
    			cout << v.at(i) << " ";
    		}
    		cout << endl;
    	}
    	catch (exception& e)
    	{ 
    		cout << e.what() << endl;
    	}
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 4]

*  **异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。**
 *  throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
 *  catch: 在您想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异常，可以有多个catch进行捕获。
 *  try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。

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

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

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_7_color_FFFFFF_t_70_g_se_x_16]

# 三、异常的使用 #

### 1.异常的抛出和捕获 ###

*  **异常的抛出和匹配原则：**
 *  异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
 *  被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
 *  抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）。
 *  catch(…)可以捕获任意类型的异常，问题是不知道异常错误是什么。
 *  实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。
 *  **在函数调用链中异常栈展开匹配原则：**
 *  首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。**如果有匹配的，则直接调到catch的地方进行处理。**
 *  没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
 *  如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(…)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。
 *  到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_12_color_FFFFFF_t_70_g_se_x_16]

#define _CRT_SECURE_NO_WARNINGS 
    
    #include<iostream>
    using namespace std;
    namespace yyw
    { 
    	int div(int n, int m)
    	{ 
    		if (m == 0)
    		{ 
    			//throw - 1;
    			//throw "发生除0错误!";
    			throw string("发生除0错误!");
    		}
    		return n / m;
    	}
    }
    int main()
    { 
    	try
    	{ 
    		int n = 0;
    		int m = 0;
    		cin >> n >> m;
    		cout << yyw::div(n, m) << endl;
    	}
    	catch (int err)
    	{ 
    		cout << err << endl;
    	}
    	catch (const char* err)
    	{ 
    		cout << err << endl;
    	}
    	catch (...)
    	{ 
    		cout << "unkown exception!" << endl;
    	}
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 6]

### 2.异常的重新抛出 ###

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    
    
    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;
    	}
    	// ...
    	cout << "delete []" << array << endl;
    	delete[] array;
    }
    int main()
    { 
    	try
    	{ 
    		Func();
    	}
    	catch (const char* errmsg)
    	{ 
    		cout << errmsg << endl;
    	}
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 7]

### 3.异常安全 ###

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

### 4.异常规范 ###

*  异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接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();

# 四、自定义异常体系 #

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    #include<math.h>
    #include<string>
    using namespace std;
    
    class Exception
    { 
    public:
    	Exception(const char* errmsg, int errid)
    		:_errmsg(errmsg)
    		, _errid(errid)
    	{ }
    	virtual string what() = 0;
    protected:
    	string _errmsg;             //错误描述
    	int _errid;                 //错误码
    	//stack<string> _st //调用栈帧
    };
    
    class SqlException :public Exception
    { 
    public:
    	SqlException(const char* errmsg, int errid)
    		:Exception(errmsg, errid)
    	{ }
    	virtual string what()
    	{ 
    		return "数据库错误:" + _errmsg;
    	}
    };
    
    class NetWorkException :public Exception
    { 
    public:
    	NetWorkException(const char* errmsg, int errid)
    		:Exception(errmsg, errid)
    	{ }
    	virtual string what()
    	{ 
    		return "网络错误:" + _errmsg;
    	}
    };
    void ServerStart()
    { 
    	//模拟一下问题抛出异常报错
    	if (rand() % 8 == 0)
    	{ 
    		throw SqlException("数据库启动失败", 1);
    
    	}
    	if (rand() % 7 == 0)
    	{ 
    		throw NetWorkException("网络连接失败", 3);
    	}
    
    	cout << "正常运行" << endl;
    }
    
    int main()
    { 
    	for (size_t i = 0; i < 100; i++)
    	{ 
    		try
    		{ 
    			ServerStart();
    		}
    		catch (Exception& e)
    		{ 
    			cout << e.what() << endl;
    		}
    		catch (...)
    		{ 
    			cout << "未知异常" << endl;
    		}
    	}
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 8]

# 五、C++标准库的异常体系 #

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

# 六、异常的优缺点 #

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 9]

### 1.C++异常的优点： ###

*  异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
 *  返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。
 *   部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T&operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

### 2.C++异常的缺点： ###

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

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

--------------------

# 总结 #

以上就是今天要讲的内容，本文介绍了C++异常概念、用法、以及优缺点，异常提供了大量能使我们快速便捷地了解错误的发生，我们务必掌握。另外如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。  
![在这里插入图片描述][3ac57c3ba5504c69b9af16f73a2722ef.gif_pic_center]

[450c7d50d1d84a58b31a09f3078e62f0.gif_pic_center]: /images/20220829/3b845e9d88664d28864fd93ab0749922.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/a107f75aed194fb1b24a817582317eb7.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/1a35b8f7e5fe43529e3187c01d553d10.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/c5398bcfad91443d821c62302df39829.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/f1947b6687d34c3ab763317afd7ec57e.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/5cf4be4b9e2f49cea8e7591f99dd3640.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_7_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/6fed6f7730fb41b6bfd2c648a0dff071.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_12_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/19d2817a51524b2daa95b2358278a731.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220829/d8f725d96ee045f0933c6e00440088be.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220829/7d7b1889452d4fd9b4ba97b41750b99b.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220829/2bce67b1869f438f80086ece0b8b4bba.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_19_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/91aefb79d46f4ca986994502b0d8e480.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220829/c6bef7911ad64e3c8377e1311b7a11dc.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_14_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/777102c472be48e8936f891c387fac26.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/abc5da66f10a4f238224a27087e8cdb2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qOu5piO5biu5aSn5LqO6buR6JmO5biu_size_20_color_FFFFFF_t_70_g_se_x_16 9]: /images/20220829/bf96963da8aa4183bc1b3fa13b163b02.png
[3ac57c3ba5504c69b9af16f73a2722ef.gif_pic_center]: /images/20220829/1a956a43ed4a4c0baaea4c6db1bec33f.png