【1++的C++进阶】之异常

👍作者主页：进击的1++
🤩 专栏链接：【1++的C++进阶】

一，什么是异常

程序的错误大致可以分为三类：分别是语法错误；逻辑错误以及运行时错误。
语法错误在编译链接阶段就能够被发现，只有100%符合代码规则的语法才能够 被编译通过，生成可执行程序。
逻辑错误是指我们编写代码的思路发生问题，达不到预期目标，对于这种问题我们要进行调试解决。
运行时错误是在程序运行期间发生的错误，如数组越界，除0错误，内存申请失败等，我们今天要学习的异常就是为了解决这种问题而引入的。

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

1. assert断言，直接终止程序。当由于某些小问题就使得程序终止，影响用户体验。
2. 返回错误码：需要程序员自己去查找对应的错误。

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

throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
catch: 在您想要处理问题的地方，通过异常处理程序捕获异常.catch 关键字用于捕获异
常，可以有多个catch进行捕获。
try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。
通俗来说就是：catch让try去检测一下程序有没有异常，有的话就告诉它，没有就不要理它。

二，异常的使用

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
3. catch(…)可以捕获任意类型的异常，问题是不知道异常错误是什么。
4. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，(可能会有向上转型）可以抛出的派生类对象，使用基类捕获.

我们以下面的代码为例：

double divide(int a, int b)
{
	if (b == 0)
		throw "除0错误";
	else
		return a / b;
}
void func()
{
	try
	{
		int a, b;
		cin >> a >> b;
		divide(a, b);
	}
	catch (const char* errmsg)
	{
		cout << "func:" << errmsg << endl;
	}
}
int main()
{
	try
	{
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (int a)
	{
		cout << a << endl;
	}
	catch (...)
	{
		cout << "错误" << endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

从运行结果我们可以验证上述的1，2条结论。

异常调用链中异常栈展开匹配原则：

1. 首先throw会检查自身是否在try代码块中，如果在并且有匹配的catch的话，就直接进行了处理
2. 没有匹配的catch，就退出当前栈帧，再到调用该函数的栈帧中去找。
3. 若是在main中也没有找到，那么就会终止程序。上述这个沿着调用链查找匹配的catch的过程叫做栈展开。为了使得抛出的异常不会因为没有被捕获到而终止程序，因此我们都会在最后加一个catch（…),其可以捕获任意类型的异常，就是不知道错误是什么。
4. 如果找到了配皮的catch，那么执行完catch后，就会继续执行catch后的语句。而抛异常处后的语句就不会再执行。因此异常就会像go语句一样，使得代码跳过来跳过去，执行流就会比较混乱。

C++中存在着许多的类型转换，我们以普通函数为例，若实参与形参的匹配机制不是那么严格，那么实参的类型将会进行转换，以适应形参的类型，这些转换包括：

1. 算数转换：int转换为float,char转换为int,double转换为int 。
2. 向上转型：派生类向基类的转换。
3. const类型转换，也就是非const类型向const类型转换。
4. 数组或函数指针转换：若函数形参不是引用类型的话，那么数组名树转换为数组指针，函数名会转换为函数指针。

catch在进行类型匹配时，也会发生类型转换，但是，由于这种转化受到了限制，因此只支持向上转型，const和数组或函数指针转换，其它都不可以进行转换。

class A
{
public:
	void func(int a)
	{
		if (a == 0)
		{
			throw* this;
		}
	}

	const char* getstr()
	{
		return astr;
	}
private:
	int _a;
	const char* astr = "A::func";

};

class B:public A
{
public:
	void func(int b)
	{
		if (b == 0)
		{
			throw *this;
		}
	}

	const char* getstr()
	{
		return bstr;
	}
private:
	int _b;
	const char* bstr = "B::func";
};

int main()
{
	A base1;
	B base2;
	int a;
	cin >> a;
	try
	{
		base2.func(a);
	}
	catch (A a)
	{
		cout << a.getstr() << endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

通过如上结果我们可以看到其确实支持向上转型。

三，异常的重新抛出

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

double divide(int a, int b)
{
	if (b == 0)
		throw "除0错误";
	else
		return a / b;
}
void func()
{
	int* arr = new int[10];//申请空间
	try
	{
		int a, b;
		cin >> a >> b;
		divide(a, b);
	}
	catch (...)
	{
		//在这里进行校对后，再抛出
		delete[]arr;
		cout << "delete[]arr" << endl;
		throw;
	}

	delete []arr;//若出现异常，则不会执行到这里，会造成内存泄漏。
	cout << "delete[]arr" << endl;

}
int main()
{
	try
	{
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (...)
	{
		cout << "错误" << endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

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

C++11中新增的noexpect表示不会抛异常。

四，自定义异常体系

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

//服务器中的异常继承体系
class Exception
{
public:
	Exception(const string& errmsg,int id)
		:_errmsg(errmsg)
		,_id(id)
	{}

	virtual string what()const
	{
		return _errmsg;
	}

protected:
	string _errmsg;
	int _id;

};

class sqlException :public Exception
{
public:
	sqlException(const string& errmsg, int id)
		:Exception(errmsg,id)
	{}

	virtual string what()const
	{
		string str = "sqlexception:";
		str += _errmsg;
		return str;
	}

};

class cacheException :public Exception
{
public:
	cacheException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{}

	virtual string what()const
	{
		string str = "cacheexception:";
		str += _errmsg;
		return str;
	}

};

class httpException :public Exception
{
public:
	httpException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{}

	virtual string what()const
	{
		string str = "httpexception:";
		str += _errmsg;
		return str;
	}

};

void SQL()
{
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw sqlException("数据库错误",100);
	}
	
}

void Cache()
{
	srand(time(0));
	if (rand() % 8 == 0)
	{
		throw cacheException("内存错误", 101);
	}
	SQL();
}

void Http()
{
	srand(time(0));
	if (rand() % 9 == 0)
	{
		throw cacheException("网络错误", 102);
	}
	Cache();
}

int main()
{
	while (1)
	{
		Sleep(1000);
		try
		{
			Http();
		}
		catch (Exception& e)
		{
			cout << e.what() << endl;;
		}
		catch (...)
		{
			cout << "未知错误" << endl;
		}
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

五，异常的优缺点

C++异常的优点：

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

C++异常的缺点：

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