异常(C++)

前言

        异常是一种处理错误的方式，在C语言中是没有这种处理错误的机制的，在C语言中处理错误通常是终止程序和返回错误码，它们都有不足的地方。所以后来在C++中又引入了新的处理错误的机制-异常。让我们一起来了解一下它是怎么样处理错误的吧。

目录

1.C语言中处理错误的方式

2.C++异常的概念

3.异常的使用

        3.1异常的捕获和抛出

        3.2异常的再抛出

        3.3异常安全

        3.4异常规范  

4.自定义异常机制

5.C++标准库的异常体系

6.异常的优缺点 

---

1.C语言中处理错误的方式

        在C语言中通常有两种处理错误的方式：结束程序和返回错误码。

        结束程序：比如通过assert函数，发生越界访问或者除零错误。缺陷：用户使用感受会很差。

        返回错误码：缺陷如果程序嵌套调用很多的函数，就要逐层判断错误码，需要程序猿自己去查找对应的错误码，如系统的很多库的接口函数都是通常将错误码放在errno中表示错误。

int fun1()
{
	//异常返回-1
	//...
	return 0;
}
int fun2()
{
	//异常返回-1
	//...
	int ret = fun1();
	if (ret == -1)
	{
		//进行处理
	}
	return 0;
}
int fun3()
{
	//异常返回-1
	//...
	int ret = fun2();//需要对函数进行层层判断
	if (ret == -1)
	{
		//进行处理
	}
	return 0;
}
int main()
{
	int ret = fun3();//需要对函数进行层层判断
	if (ret == -1)
	{
		//进行处理
	}
	return 0;
}

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

2.C++异常的概念

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

         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代码块
    } 

3.异常的使用

        3.1异常的捕获和抛出

        异常的抛出和匹配原则

        1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪一个catch的处理代码。

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

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

        4.catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么？

        5.实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出派生类的对象。使用基类进行捕获，这个在实际中是很有用的。

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

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

        2.没有匹配的catch则退出当前函数栈，继续在调用函数的栈中查找匹配的catch。

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

        4.站到匹配的catch子句并处理后，会继续沿着catch子句后面继续执行。 

 

double Divsion(int a, int b)
{
	if (b == 0)
	{
		//抛出除零异常
		throw "Divsion by zero condition!";
	}
	return a / b;
}
void Fun()
{
	int len, time;
	cin >> len >> time;
	cout << Divsion(len, time) << endl;
}
int main()
{
	try
	{
		Fun();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (...)
	{
		cout << "未知错误" << endl;
	}
	return 0;
}

        3.2异常的再抛出

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

double Divsion(int a, int b)
{
	if (b == 0)
	{
		//抛出除零异常
		throw "Divsion by zero condition!";
	}
	return a / b;
}
void Fun()
{
	int* array = new int[] {1};
	try
	{
		int len, time;
		cin >> len >> time;
		cout << Divsion(len, time) << endl;
	}
	catch (...)
	{
		//如果调用的函数Divsion抛异常这里就会重新捕获异常，再抛出，并释放开辟的array
		cout << "delete []" << array << endl;
		delete[] array;
		throw;
	}
	cout << "delete []" << array << endl;
	delete[] array;
}
int main()
{
	try
	{
		Fun();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (...)
	{
		cout << "未知错误" << endl;
	}
	return 0;
}

        3.3异常安全

        1.构造函数完成对对象的构造和初始化，最好不要在构造函数中抛异常，否则可能导致对象不完整或者没有完全初始化。

        2.析构函数主要完成对对象的清理，最好不要在析构函数内抛异常，否则可能导致资源泄露（内存泄露，句柄未关闭等）。

        3.C++中异常经常会导致资源泄露的问题，比如在new和delete中抛异常，导致内存泄露，在lock和unlock之间抛异常会导致死锁，C++经常使用RAII来解决以上的问题。关于 RAII和智能指针

        3.4异常规范  

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

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

        3.若无异常接口声明，则此函数可以抛出任意类型的异常。

//这里表示函数会抛出A，B，C, D四种类型的某种类型的异常
void Fun()throw(A, B, C, D);
//这里表示函数不会抛出异常。
void Fun()throw();
//这里表示这个函数只会抛出bad_alloc的异常
void* operator new(std::size_t size)throw(std::bad_alloc);
//C++11中新增的noexcept,表示不会抛异常
thread()noexcept;
thread(thread&& x)noexcept; 

4.自定义异常机制

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

         

#include
#include
#include
//服务器开发中通常使用的异常继承体系
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, const string& sql, int id)
		:Exception(errmsg, id)
		, _sql(sql)
	{

	}
	virtual string what()const
	{
		string str = "SqlException:";
		str += _errmsg;
		str += "->";
		str += _sql;
		return str;
	}

private:
	const string _sql;
};
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 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:
	string _type;
};


void SQLMgr()
{
	//使用随机数进行随机触发异常，当是7的倍数时触发 SqlException中的异常
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", "select * from name = '张三'", 100);
	}
}
void CacheMgr()
{
	//使用随机数进行随机触发异常，当是5或者6的倍数时触发 CacheException中的异常
	srand(time(0));
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 100);
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 101);
	}
	//并且调用函数SQLMgr
	SQLMgr();
}
void HttpServer()
{
	//...
	srand((unsigned)time(NULL));
	//使用随机数进行随机触发异常，当是3或者4的倍数时触发 CacheException中的异常
	if (rand() % 3 == 0)
	{
		throw HttpServerException("请求资源不存在", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 101, "post");
	}
	//并且调用CacheMgr
	CacheMgr();
}
int main()
{
	while (1)
	{
		Sleep(1000);
		try
		{
			HttpServer();
		}
		catch (const Exception& e)
		{
			cout << e.what() << endl;
		}
		catch (...)//捕获任意类型的异常
		{
			cout << "Unknown Exception" << endl;
		}
	}
}

 

5.C++标准库的异常体系

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

        下图是对上面层次结构中出现的异常的说明：

         

        实际中我们可以自己去继承exception类实现我们自己异常类。 但是很多人不喜欢用官方库的异常，因为它不够完善，所以会自己定义一套自己的异常体系。

#include
int main()
{
	try
	{
		vector v(10, 5);
	}
	catch (const exception& e)//这里捕获父类对象的就可以
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "unknown Exception" << endl;
	}
	return 0;
}

6.异常的优缺点 

        异常的优点：

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

        2.返回错误码的传统方式有一个很大的问题，就是在函数调用链中，深层的函数返回了错误码，那我们得层层返回，最外层才能拿到错误信息。

//下面这段伪代码我们可以看出Connectsql中出错先返回ServerStart，ServeStart再返回给main函数，让main函数进行处理
//如果是异常体系，不管是Connectsql还是ServerStart及调用函数出错，都不用检查，因为抛出的异常会直接跳到main函数中catch捕获的位置，main函数直接处理错误
int Connectsql()
{
    //用户名密码错误
    if (...)
    {
        return 1;
    }
    //权限不足
    if (...)
    {
        return 2;
    }
}
int ServerStart()
{
    if (int ret = Connectsql() < 0)
    {
        return ret;
    }
    int fd = socket();
    if (fd < 0)
    {
        return errno;
    }
}
int main()
{
    if (ServerStart() < 0)
        ...
    return 0;
}

        3.很多的第三方库都包含异常，比如boost，gtest，gmock ，等等常用的库，那么我们使用它们也是会使用异常。

        4.部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式返回处理。比如T&operator这样的函数，如果pos越界了只能使用异常停止或者终止程序处理，没有办法通过返回值表示错误。  

        异常的缺点：

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

        2.异常会有一些性能开销。当然现在的硬件速度很快可以忽略不计。

        3.C++没有垃圾回收机制，资源需要我们自己管理，有了异常很容易造成内存泄露，死锁等异常安全问题，这个需要RAII来对资源进行管理，学习成本会提高。

        4.C++标准库的异常体系定义的不够好，导致大家各自定义各自的异常体系，非常的混乱。

        5.异常尽量规范使用，否则会造成不可设想的后果，随意的抛异常，外层捕获的用户会苦不堪言。所以异常的规范有两点：1.抛出异常类型都继承自一个基类，2.函数是否抛异常，抛什么异常，都要使用func（）throw()；的方式规范化。

          总之：异常总体而言是一个利大于弊的东西，所以规范的使用异常还是可取的。另外高级语言基本都是异常处理错误，可以看出这也是大势所趋。