C++ 异常处理_c++错误处理

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

传统的错误处理机制:

• 终止程序,如assert. 缺陷: 很容易因为一些程序的一些小的错误而终止程序.
• 返回错误码. 缺陷: 需要程序员自己去查找错误码中对应的错误信息.例如: Linux系统中很多库的接口函数都是通过错误码放到errno中来表示错误.

C++异常概念

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

• throw: 当问题出现时,程序会抛出一个异常,这是通过throw关键字来完成的.
• catch: 在我们想要处理问题的地方,通过异常处理程序捕获异常,catch关键字用于捕获异常,刻意呦多个catch进行捕获.
• try: try中的代码标识码将被激活特定异常,它后面通常跟着一个或多个catch块.

使用try/catch语句的语法如下:

异常的用法

try
{
  // 保护的标识代码
}catch( ExceptionName e1 )
{
  // catch 块
}catch( ExceptionName e2 )
{
  // catch 块
}catch( ExceptionName eN )
{
  // catch 块
}
catch( ... )  //接收任意类型的异常.
{
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

异常的使用

• 异常是通过抛出对象而引发的,该对象的类型决定了应该激活哪个catch的处理代码.
• 被选中的处理代码是在调用链中离该对象类型匹配且离抛出异常位置最近的那一个.
• 抛出异常对象后,会生成一个异常对象的拷贝(类似于传值返回),但是在C++11以后,我们可以通过移动构造的减少拷贝,提高效率.
• catch(…)可以捕获任意类型的异常,但是我们不知道异常错误是什么.

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

• 首先检查throw本身是否在try块内部,如果是再查找匹配的catch语句.如果有匹配的,则调到catch的代码块中处理.
• 如果在当前函数栈中没有匹配到合适的catch,则退出当前函数栈,继续在调用的函数栈中查找匹配的catch.
• 如果到达main函数栈,依旧没有匹配的catch,则终止程序.其中,上述沿着调用栈查找匹配的catch子句的过程叫做栈展开.但是在实际上中,我们最后都要加上catch(…)来捕获任意类型的异常,否则当有异常没捕获,程序就会终止.
• 当找到答匹配的catch子句处理后,会继续沿着catch的子句后面执行.

使用代码如下:

double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";
	else
		return ((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;
	}
	catch (...)    //接收任意类型的异常.
	{
	   cout << "unkown exception" << 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

自定义异常体系

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者就要写很多种catch来匹配对应的异常.所以在实际中都会定义一套继承的规范体.这样大家抛出的都是继承的派生类对象,捕获一个基类就可以了.此时,该catch中,异常对象e使用的虚函数为派生类中重写的虚函数.(构成多态).

例如:
以下代码中,写了一个异常类Exception(基类),以及一个HttpServerException类(派生类).在抛异常时抛出的对象为派生类,捕获的类型为基类.

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 HttpServerException : public Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{}
	virtual string what() const
	{
		string str = "HttpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};
void HttpServer()
{
	// ...
	srand(time(0));
	if (rand() % 3 == 0)
	{
		throw HttpServerException("请求资源不存在", 100, "get");       //抛出派生类
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 101, "post");
	}
}

int main()
{
	while (1)
	{   
		Sleep(1);
		try {
			HttpServer();
		}
		catch (const Exception& e) // 使用基类类型捕获.
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)  //捕获任意类型对象.
		{
			cout << "Unkown Exception" << 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

注意:
为了让代码更加规范,在公司中我们一般抛出的类型为类,我们可以通过带调用类的成员函数来处理相应异常问题.

重新抛出

• 场景一:
  在服务器项目中,如果我不希望一出网络错误就抛异常,如果是网络异常,我们还可以再尝试两次,当第三次还是网络异常,则抛出异常,由main函数中的catch捕获,如果是权限异常则直接由main函数中的catch捕获.

class Exception                
{
public:
	Exception(const string& errmsg, int id)
		:_errmsg(errmsg)
		, _errid(id)
	{}
	virtual string what() const
	{
		return _errmsg;
	}
	int GetId() const
	{
		return  _errid;
	}
protected:
	string _errmsg;
	int _errid;
};

class HttpServerException : public Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{}
	virtual string what() const
	{
		string str = "HttpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};
void SeedMsg( const string& str )
{
	//要求出现网络错误,重试三次.
	srand(time(0));
	
	  if (rand() % 3 == 0)
	  {
		throw HttpServerException("网络错误", 100, "get");
	  }
	 else if (rand() % 4 == 0)
	  {
		throw HttpServerException("权限不足", 101, "post");
	  }
	cout << "发送成功:" << str << endl;
}

void HttpSever()
{
	//如果出现网络错误,重试三次.
	string str("今晚一起去看电影");
	
	int n = 3;
	
	while ( n-- )
	{
		try
		{
			SeedMsg(str);
			//如果没有异常,则直接退出.
			break;
		}

		catch (const Exception& e)  //可以接收权限导致的异常和网络错误导致的异常,我们要分开进行处理.
		{
			//网络错误,且重试3次内.
			if (e.GetId() == 100 && n > 0 ) 
			{
				continue;
			}
			else     
			{
			//异常的重新抛出.
				throw e;   //1.为了防止权限错误全被该catch所捕获,导致main函数里面的catch无法被捕获,所以我们需重新抛出权限错误所导致的异常.
				           //2.为了由main函数里面的catch接受网络错误且重试等于三次时的异常,此时也可以重新抛出异常,由main函数里面的catch接收,打印相应字符串.			          
			}
		}
		
	}
}

int main()
{
	while(1)
	{
		try
		{
			HttpSever();
		}
		catch ( const Exception& e )                //什么派生类抛出,就分别调用什么.
		{
			cout << e.what() << endl;         
		}
		catch ( ... )
		{
			cout << "Unkown Exception" << 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

总结:
异常一般由main函数中的catch所处理,中间中的catch一般根据问题类型,分别处理后,再重新抛出,由main函数中的catch处理.

• 情景二
  通过以下代码,我们了解,当Division函数发生异常时,此时便会直接由main函数中的catch捕获.可是这样就会导致我们new出的数组array1,array2无法及时被销毁,进而造成内存泄露.
  
  所以,针对该情况,当Division函数异常时,而不直接由main函数的catch捕获,在当前函数栈帧捕获,在catch中先将new出来的数组集中delete,然后再重新抛出该异常,由外部catch处理.

double Division(int a, int b)  //表示该函数不会抛异常,但是不会强制.
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";
	else
		return ((double)a / (double)b);
}
void Func()
{
	int* array1 = new int[10];

    int* array2 = new int[10];
	
	int len, time;
	
	cin >> len >> time;
	try
	{
		cout << Division(len, time) << endl;
	}
	catch (...)   //捕获Division中抛出的异常.
	{
		cout << " delete [] array1 " << endl;
		
		delete[] array1;
        
        delete[] array2;
		
		throw;                 //重新抛出.
	}
}
int main()
{
	try 
	{
	    
		Func();
	} 
	catch ( const char* errmsg )
	{
	    cout << errmsg << endl;
	}
	catch (...)
	{
		cout << "unkown exception" << 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

可是,这样写还是有一个隐患:
当第一个new成功,第二个new失败时,此时就会抛出异常,就会由main函数中的catch捕捉,此时,array1没有及时被销毁,又造成了内存泄露.

解决办法如下:
我们可以将有可能发生异常的(new array2)放入异常捕获范围中(try中),当new array2抛出异常,可由当前栈帧catch(…)捕获,再将array1销毁,再重新抛出.

double Division(int a, int b)  //表示该函数不会抛异常,但是不会强制.
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";
	else
		return ((double)a / (double)b);
}
void Func()
{
	int* array1 = new int[10];
	
	int len, time;
	
	cin >> len >> time;
	try
	{
		int* array2 = new int[10];

		cout << Division(len, time) << endl;
	}
	//不去区分异常,抛出任何类型的异常都进行捕获,但是处理一般放在main函数的catch中处理.
	catch (...)
	{
		cout << " delete [] array1 " << endl;

		delete[] array1;
		
		throw;
	}
}
int main()
{
	try 
	{
		Func();
	} 
	catch ( const char* errmsg )
	{
	    cout << errmsg << endl;
	}
	catch (...)
	{
		cout << "unkown exception" << 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

特殊说明:
这样处理固然可以解决array1造成的内存泄露,可是,如果我new了多个数组,这些数组都有可能创建失败,抛出异常,这样就会造成多种情况的内存泄漏,那么针对不同情况,又要分开处理.这样会导致代码过于繁琐.因此实际上一般不用异常处理,这在我们学习的智能指针可以解决.

异常规范

• 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些,可以在函数的后面接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 delete (std::size_t size, void* ptr) throw();
// C++11 中新增的noexcept，表示不会抛异常,如果发生了异常,则会终止程序.
thread() noexcept;
thread (thread&& x) noexcept;
1
2
3
4
5
6
7
8
9

异常的优缺点

异常的优点:

• 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包
  含堆栈调用的信息，这样可以帮助更好的定位程序的bug.
• 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那
  么我们得层层返回错误，最外层才能拿到错误.而抛出的异常会直接跳到main函数中catch捕获的地方,由main函数直接处理错误.
• 很多第三方库都包含异常,如boost,gtest等常用的库,那么我们使用它们也需要使用异常.
• 部分函数使用异常更好处理,比如构造函数没有返回值,不方便使用错误码方式处理,operator[](size_t ](pos)返回值一般为对象,pos越界了只能使用异常或者断言程序处理(但是只可在debug程序下使用),没办法通过返回值表示错误.

异常的缺点:

• 异常会导致程序执行流乱跳,并且非常的混乱,并且是运行时出错抛异常就会乱跳,这会导致我们跟着调试时,比较困难.
  比如: 我们以为程序会执行到func3,因而在func3处打了断点,可是因为函数func1抛出异常,程序直接跳到了func4,此时fun3并没有执行,无法定位到func3中.
  
• 抛出的异常一般为一个对象,会有一些性能的开销,但是由于现代硬件很快的情况下,这个影响基本忽略不计.
• C++没有垃圾回收机制,资源需要自己管理,有了异常非常容易导致内存泄露,死锁等异常安全问题,这个需要RAII机制处理.
• C++标准库中异常体系定义得不好,在公司中大家使用的都是自定义得异常体系,非常混乱.
• 异常尽量规范使用,如果随意抛异常,外层捕获的用户苦不堪言.所以,异常的规范有两点:
  ( 1 ):抛出异常类型都继承自一个基类.
  ( 2 ): 函数是否抛异常,抛什么异常都是用func() throw()形式的方式规范化.但是由于历史原因,异常规范并不是强制的.