【C++】：错误处理机制 -- 异常

目录

• 前言
• 一，C语言传统的处理错误的方式
• 二，C++异常的概念
• 三，异常的使用
• • [3.1 异常的抛出和匹配原则](#3.1 异常的抛出和匹配原则)
  • [3.2 在函数调用链中异常栈展开匹配原则](#3.2 在函数调用链中异常栈展开匹配原则)
  • [3.3 异常的重新抛出](#3.3 异常的重新抛出)
  • [3.4 异常规范](#3.4 异常规范)
• 四，自定义异常体系
• 五，异常的优缺点

点击跳转至文章： 【C++11】：lambda表达式&function包装器

前言

前面我们学习了C++11新增的几个常用新语法，本篇文章的重点是理解并学会使用C++中新设计的错误处理方式--异常，并且知道它的优缺点。

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

传统的错误处理机制：

(1) 终止程序，如assert ，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。

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

实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。

代码示例如下：

int main()
{
	FILE* fout = fopen("Test.txt", "r");
	
	cout << fout << endl; // 打开失败返回空
	cout << errno << endl; // 返回错误码
	
	perror("fopen fail"); // 根据错误码打印错误信息

	return 0;
}

二，C++异常的概念

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

• throw ：当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。

• catch ：在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常，可以有多个catch进行捕获。

• try ：try 块中的代码标识将被激活的特定异常，它后面通常跟着一个或多个 catch 块。

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

三，异常的使用

3.1 异常的抛出和匹配原则

(1) 抛出的类型和捕获的类型要严格一致。

如果你在throw时抛出一个字符串,但是在catch捕获异常时的参数却写的是整数，那么这个抛出的异常就不会去这个catch，会继续匹配下面的catch。

try{
	int a,b;
	cin>>a>>b;
	if(b == 0)
		throw "除0错误"
	cout<<(a/b)<<endl;
}
catch(int flag)//类型与throw的不匹配,会跳到下面的catch
{
	//......
}
catch(string str)
{
	//......
}

(2) 异常的抛出和捕获遵循就近原则。

被选中的处理代码 是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。

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;
	try
	{
		cout << Division(len, time) << endl;
	}
	catch (const char* errmsg)
	{
		//这个catch与throw相距最近,会优先到这儿
		cout << errmsg << "->111" << endl;
	}
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	
	return 0;
}

(3) 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 string& s)
	{
		cout << s << endl;
	}
	catch (...) 
	{
		cout << "unkown exception" << endl;
	}

	return 0;
}
 

(4) 抛出异常对象后，会生成一个异常对象的拷贝。

因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）

double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		string s("Division by zero condition!");
		throw s;
	}
	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 string& s)
	{
		cout << s << endl;
	}
	catch (...) 
	{
		cout << "unkown exception" << endl;
	}

	return 0;
}

(5) 基类可以接受抛出的子类对象。

实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

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

(1) 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。

(2) 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中(走完当前函数，回退到调用它的函数中)进行查找匹配的catch。

(3) 如果到达main函数的栈，依旧没有匹配的，则终止程序 。上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。

(4) 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

3.3 异常的重新抛出

为什么在下面的func函数中还要进行异常的重新抛出呢？

因为在这种情况下，如果Division函数发生异常并且抛出异常，就会被catch (...)捕获，释放掉new出的空间，如果Division函数正常执行，就会执行下面的语句，也能释放掉new出的空间。这样就避免了内存泄漏。
但是如果在func函数中没有异常重新抛出，那么这样的程序是十分危险的，因为如果此时Division函数发生异常并且抛出异常，就会直接跳过下面的delete语句，被main函数中的catch捕获异常，这样就会内存泄漏。

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;
}

3.4 异常规范

(1) 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。

(2) 函数的后面接throw()，表示函数不抛异常。

(3) 若无异常接口声明，则此函数可以抛掷任何类型的异常。

// 这里表示这个函数会抛出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;

如果会抛异常但是加上 noexcept，编译时并不会报错，会报警告。运行时如果触发了异常，会直接终止程序，捕获不到异常。

四，自定义异常体系

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

五，异常的优缺点

(1) 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息 ，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。

(2) 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。

(3) C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题 。这个需要使用RAII来处理资源的管理问题。学习成本较高。

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