C++知识点 -- 异常

C++知识点 – 异常

---

一、异常概念

当一个函数发现自己无法处理错误时，就可以抛出异常，让函数的直接或间接调用者处理这个错误；
throw：当函数出现问题时，会抛出一个异常，是通过throw关键字完成的；
try：try代码块中标识将被激活的特定异常；
catch：用于捕获异常；

异常捕获的基本格式：

double Div(int a, int b)
{
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	else
	{
		return a / b;
	}
}

void test()
{
	int left, right;
	cin >> left >> right;
	cout << Div(left, right) << endl;
}


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

	return 0;
}

当b输入0时，会引发除零错误，Div函数抛出异常，main函数的catch会接收到异常；

二、异常的使用

1.异常的抛出和捕获

（1）异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码；
（2）被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个；

（3）抛出异常对象后，会生成一个异常对象的拷贝，因为抛出异常的对象可能是一个临时对象，所以会生成一个拷贝，这个拷贝的临时对象在被catch后会销毁；（类似于函数的传值返回）
（4）catch(…)可以捕获任意类型的异常，但是不知道异常错误是什么；

int main()
{
	try 
	{
		test();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const int errid)//异常抛出与捕获的类型一定要匹配，如果catch没有匹配的类型，程序会直接终止
	{
		cout << errid << endl;
	}
	catch (...)//捕获任意类型的异常，防止出现未捕获异常时 ，程序终止
	{
		cout << "未知异常" << endl;
	}

	return 0;
}

（5）实际中抛出和捕获的匹配原则有个例外，可以抛出派生类对象，用基类捕获；

2.异常的重新抛出

double Div(int a, int b)
{
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	else
	{
		return a / b;
	}
}

void test()
{
	int* array1 = new int[10];
	int* array2 = new int[5];

	int left, right;
	cin >> left >> right;
	try 
	{
		cout << Div(left, right) << endl;
	}
	catch (...)
	{
		throw;//捕获什么抛什么
	}
	cout << "delete[]" << array1 << endl;
	delete[] array1;
	cout << "delete[]" << array1 << endl;
	delete[] array2;
}


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

这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去。

可以在异常重新抛出前释放空间：

void test()
{
	int* array1 = new int[10];
	int* array2 = new int[5];

	int left, right;
	cin >> left >> right;
	try 
	{
		cout << Div(left, right) << endl;
	}
	catch (...)
	{
		cout << "delete[]" << array1 << endl;
		delete[] array1;
		cout << "delete[]" << array1 << endl;
		delete[] array2;

		throw;//捕获什么抛什么
	}
}

3.异常安全

（1）最好不要在构造函数中抛异常，否则可能会导致对象不完整或没有完全初始化；
（2）最好不要在析构函数中抛出异常，否则可能导致资源泄露；
（3）c++中经常会在new和delete中间怕抛出异常，导致资源泄露，应使用RAII来解决该问题；

4.异常规范

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

void fun() throw(int, char*);

（2）函数后面接throw()或noexcept，表示函数不抛异常；

void fun() throw();
void fun() noexcept;//c++11中新增的noexcept表示函数不会抛异常

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

三、自定义异常体系

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

	virtual string what() const
	{
		return _errmsg;
	}

	int getid() const
	{
		return _id;
	}

protected:
	string _errmsg;   // 错误信息
	int _id;          // 错误码
};

class SqlException : public Exception
{
public:
	SqlException(const string& errmsg, int id, const string& sql)
		:Exception(errmsg, id)
		, _sql(sql)
	{}

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

		return str;
	}
protected:
	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;
	}

protected:
	// stack _stPath;
};

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 SQLMgr()
{
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", 100, "select * from name = '张三'");
	}

	cout << "本次请求成功" << endl;
}

void CacheMgr()
{
	srand(time(0));
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 200);
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 201);
	}

	SQLMgr();
}

void SeedMsg(const string& s)
{
	// 要求出现网络错误重试三次
	srand(time(0));
	if (rand() % 3 == 0)
	{
		throw HttpServerException("网络错误", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 101, "post");
	}

	cout << "发送成功:" << s << endl;
}

void HttpServer()
{
	// 要求出现网络错误，重试3次
	string str = "今晚一起看电影怎么样？";
	//cin >> 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; // 重新抛出
			}
		}
	}
}
//在这里接收了异常后，如果不重新抛出，外面就接受不到其他异常了
//如果SeedMsg没有抛异常就break
//如果SeedMsg抛异常就会走到catch，如果是网络错误，continue重试3次，3次后还是错误，就重新抛出异常，外面会接收到网络异常
//如果SeedMsg抛出其他异常，直接抛出，让外面接收

int main()
{
	while (1)
	{
		//this_thread::sleep_for(chrono::seconds(1));
		Sleep(1000);

		try
		{
			HttpServer();
		}
		catch (const Exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
			// 记录日志
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}

	return 0;
}

所有的子类异常类都继承于父类异常类，这样在捕获时，统一用父类对象捕获，能够触发多态；

四、C++标准库的异常体系

五、C++异常的优缺点

优点
（1）相比错误码能狗更加清晰地展现出错误信息，能够更好的定位bug；
（2）传统错误码在函数调用链中，深层函数返回了错误，那么我们得层层返回，最外层才能拿到错误，如果是异常体系，我们可以自由设置在哪层接受异常；
（3）很多第三方库都包含异常，所以我么也要使用异常；
（4）部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码处理；

缺点
（1）会导致程序的执行流乱跳；
（2）异常会有一些性能的消耗；
（3）C++没有垃圾回收机制，资源需要自己清理，一般使用RAII；
（4）C++标准库异常体系定义的不好；
（5）尽量规范使用异常，否则后果不堪设想；