C++ STL——异常

目录

• 一 C++异常机制概述
• 二 栈解旋（unwinding）
• 三 异常接口的声明
• 四 异常类型和异常变量的生命周期
• 五 C++标准异常库
• 六 异常的继承

---

注：原创不易，转载请务必注明原作者和出处，感谢支持！

注：内容来自某培训课程，不一定完全正确！

一 C++异常机制概述

什么是异常处理?一句话，异常处理就是处理程序中的错误。

为什么需要异常处理以及异常处理的基本思想？

C++之父Bjarne Stroustrup在《The C++ Programming Language》中讲到：一个库的作者可以检测出发生了运行时错误，但一般不知道怎样去处理它们（因为和用户具体的应用有关）；另一方面，库的用户知道怎样处理这些错误，但却无法检查它们何时发生（如果能检测，就可以在用户的代码里处理了，不用留给库去发现）。

Bjane Stroustrup说：提供异常的基本目的就是为了处理上面的问题。基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或间接）调用者能够处理这个问题。也就是说，C++将问题的检测与问题的处理相分离。

在异常处理机制出现之前的错误处理方式？在C语言中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单理解为一个全局整型变量）去记录错误。当然C++中仍然可以使用这两种方法。但是这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。还有一个缺点是一个函数的返回值只有一个，你通过函数的返回值标识错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但这可能会令你的程序略微晦涩难懂。

异常的优点在哪里？

（1）函数的返回值可以忽略，但异常不可以忽略。如果程序出现异常，但是没有被捕获，程序就会终止，这多少回促使程序员开发出来的程序更健壮一点。而如果使用C语言的errno宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其妙地终止或者出现错误的结果。

（2）整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。

（3）整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。

（4）异常处理可以在调用时跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需在一处进行处理就可以了，不需要每级函数都处理。

下面是一个异常的基本语法实例。如果除数y为0，则抛出y的值。在Test1()中尝试捕获异常。

// 异常的基本语法
int Divide(int x, int y)
{
	if (y == 0)
	{
		// 抛出异常
		throw y;
	}
	return x / y;
}

void Test1(void)
{
	// 试着捕获异常
	try
	{
		Divide(10, 0);
	}
	// 异常是根据类型进行匹配的
	catch (int e)
	{
		cout << "Error : 除数为" << e << endl;
	}
}

异常可以跳级处理。比如在下面的这个例子中，函数的调用顺序为Test2() --> CallDivide() --> Divide()。异常在Divide()函数中被抛出，但异常的捕获却没有在CallDivide()中进行，而是放到了Test2()中进行。

int Divide(int x, int y)
{
	if (y == 0)
	{
		// 抛出异常
		throw y;
	}
	return x / y;
}

// CallDivide()并未对异常进行处理
void CallDivide(int x, int y)
{
	Divide(x, y);
}

// Divide()所抛出的异常在函数调用顶层Test2()中被捕获
// 如果Test2()中仍然没有捕获到Divide()所抛出的异常，则
// 异常会被抛到函数调用的最顶层main()函数中，如果在main()
// 中异常还没有被捕获并处理，则程序会终止执行！
void Test2(void)
{
	try
	{
		CallDivide(10, 0);
	}
	catch (int e)
	{
		cout << "错误：除数为" << e << endl;
	}
}

二 栈解旋（unwinding）

栈解旋是指当异常被抛出后，从进入try块起，到异常被抛出前，这期间在栈上构造的所有对象，都会被自动析构，析构的顺序与构造的顺序相反。这一过程被称为栈的解旋（unwinding）。

比如下面的例子，进入try语句块之后，先调用的是CallDivide()，在CallDivide()当中先是构建了Person对象p3，然后调用Divide()，在Divide()当中构建了对象p1和p2，直到异常的发生。

class Person
{
public:
	Person(string nm)
	{
		name = nm;
		cout << "Person对象" << name << "构建" << endl;
	}

	~Person()
	{
		cout << "Person对象" << name << "析构" << endl;
	}

private:
	string name;
};

int Divide(int x, int y)
{
	Person p1("p1");
	Person p2("p2");

	if (y == 0)
		throw y;

	return x / y;
}

void CallDivide()
{
	Person p3("p3");
	Divide(10, 0);
}

void Test01()
{
	try
	{
		CallDivide();
	}
	catch (int e)
	{
		cout << "有异常发生！" << endl;
	}
}

上面程序的输出如下，可以看到构建的顺序和析构的顺序刚好相反。

Person对象p3构建
Person对象p1构建
Person对象p2构建
Person对象p2析构
Person对象p1析构
Person对象p3析构
有异常发生！

三 异常接口的声明

（1）为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw (A, B, C)，这个函数func能够且只能抛出类型A，B，C及其子类型的异常。

（2）如果在函数声明中没有包含异常接口声明，则此函数可以抛出任何类型的异常

（3）一个不抛出任何异常的函数可以声明为：void func() throw ()

（4）如果一个函数抛出了它的异常接口声明所不允许抛出的异常，则unexcepted函数会被调用，该函数默认行为调用terminate()函数中断程序。

下面是一个异常接口声明的实例。

// 这个函数只能抛出int float char三种类型的异常，抛出其他异常就报错
void func1() throw (int, float, char)
{
	// 抛出char *会导致程序异常退出
	throw string("abc");
}

// 这个函数不能抛出任何异常
void func2() throw ()
{
	// 抛出异常会导致程序异常退出
	throw 1;
}

// 这个函数可以抛出任何类型异常
void func3()
{
	;
}

四 异常类型和异常变量的生命周期

throw的异常是有类型的，可以是数字、字符串、和类对象等。catch需要严格地匹配异常类型。

void fun1()
{
	throw 1;
}

void fun2()
{
	throw "exception";
}

class MyException
{
public:
	MyException(string msg)
	{
		error = msg;
	}

	void what()
	{
		cout << error << endl;
	}

private:
	string error;
};

void fun3()
{
	// 抛出匿名对象
	throw MyException("我刚写的异常！");
}

void Test1()
{
	try
	{
		fun1();
	}
	catch (int e)
	{
		cout << "int型异常！" << endl;
	}

	try
	{
		fun2();
	}
	catch (char *e)
	{
		cout << "char *型异常！" << endl;
	}

	try
	{
		fun3();
	}
	catch (MyException e)
	{
		// 对象MyException里封装了异常的相关信息
		e.what();
	}
}

下面进行异常变量生命周期分析。首先是使用普通的匿名对象去接抛出异常的情况。

class MyException
{
public:
	MyException()
	{
		cout << "MyException构造函数被调用" << endl;
	}

	MyException(const MyException & ex)
	{
		cout << "MyException拷贝构造函数被调用" << endl;
	}
	~MyException()
	{
		cout << "MyException析构函数被调用" << endl;
	}
};

void fun()
{
	// 抛出匿名异常对象
	throw MyException();
}
void Test()
{
	try
	{
		fun();
	}
	// 使用普通对象去接抛出的异常
	catch (MyException e)
	{
		cout << "异常捕获！" << endl;
	}
}

此时，程序输出结果如下。程序首先是在fun()中调用了MyException的构造函数创建了一个匿名对象，然后将该匿名对象抛出。然后在使用普通元素e接收抛出的异常对象时，调用了拷贝构造函数将匿名对象拷贝至e当中。然后是捕获异常，捕获之后，在catch语句中进行处理。当catch中处理完了异常之后再将对象e和匿名对象析构，所以输出两次“MyException析构函数被调用”。

MyException构造函数被调用
MyException拷贝构造函数被调用
异常捕获！
MyException析构函数被调用
MyException析构函数被调用

接下来是使用引用去接抛出的异常对象的情况。

void Test()
{
	try
	{
		fun();
	}
	// 使用引用去接抛出的异常
	catch (const MyException &e)
	{
		cout << "异常捕获！" << endl;
	}
}

此时程序输出如下。和使用普通元素e接收抛出异常对象相比，使用引用去接收抛出对象少了调用拷贝构造函数的步骤。因为，在catch时直接引用了匿名对象，所以从始至终，只要匿名对象被创建和析构。

我比较菜，我有疑问：参考下面的用指针去接收抛出的异常部分，为什么这里可以在catch语句块里去引用匿名对象？这个匿名对象不是在fun()里创建的吗？随着fun()调用完毕，退栈之后，匿名对象还存在吗？如果不存在，那你还怎么能够引用呢？如果存在，那说明这个匿名异常对象肯定不在栈内存中，不在栈内存中，那它在哪里？在堆区吗？

MyException构造函数被调用
异常捕获！
MyException析构函数被调用

下面是使用指针去接收抛出异常对象的错误示范。

void fun()
{
	// 抛出匿名对象的地址
	throw &(MyException());
}
void Test()
{
	try
	{
		fun();
	}
	// 使用指针去接抛出的异常
	catch (const MyException *e)
	{
		cout << "异常捕获！" << endl;
	}
}

此时，程序输出结果如下。可以看到，在catch块中进行异常处理之前，匿名对象就已经被析构了！此时指针e成了一个野指针，你再也无法通过e来获取e中封装的异常信息了！

MyException构造函数被调用
MyException析构函数被调用
异常捕获！

下面是使用指针去接收抛出异常对象的正确示范。为了防止匿名对象在进行异常处理之前被析构，你需要在堆中创建匿名对象，这也就意味着你需要手动地管理内存！

void fun()
{
	// 抛出匿名对象的地址，匿名对象在堆中创建
	throw new MyException();
}
void Test()
{
	try
	{
		fun();
	}
	// 使用指针去接抛出的异常
	catch (const MyException *e)
	{
		cout << "异常捕获！" << endl;
		// 千万别忘记手动释放匿名对象的内存！
		delete e;
	}
}

此时，程序终于输出正确了！

MyException构造函数被调用
异常捕获！
MyException析构函数被调用

五 C++标准异常库

C++标准异常库的成员

（1）在上述的继承体系中，每个类都提供了构造函数、拷贝构造函数和赋值操作符重载

（2）logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述

（3）所有的异常类都有一个what()方法，返回const char *类型（C风格字符串）的值，描述异常信息。

标准异常类的具体描述

异常名称	描述
exception	所有标准异常类的父类
bad_alloc	当operator new and operator new[]请求分配失败时
bad_exception	这是个特殊的异常类，如果函数的异常抛出列表里声明了bad_exception异常，当函数内部抛出了异常列表中没有的异常，这时调用的unexcepted函数中若抛出异常，不论什么类型，都会被替换为bad_exception类型
bad_type	使用typeid操作符，操作一个NULL指针，而该指针是带有虚函数的类，这时抛出bad_typeid异常
bad_cast	使用dynamic_cast转换引用失败时
ios_base::failure	io操作过程中出现错误
logic_error	逻辑错误，可以在运行前检测的错误
runtime_error	运行时错误，仅在运行时才可以检测的错误

logic_error的子类：

异常名称	描述
length_error	试图生成一个超出该类型最大长度的对象时，例如vector的resize操作
domain_error	参数的值域错误，主要用在数学函数中。例如使用一个负值调用只能操作非负值的函数
out_of_range	超出有效范围
invalid_argument	参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是'0'或者'1'的时候，抛出该异常

runtime_error的子类：

异常名称	描述
range_error	计算结果超出了有意义的值域范围
overflow_error	算数计算上溢
underflow_error	算数计算下溢
invalid_argument	参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是'0'或者'1'的时候，抛出该异常

编写自己的异常类

为什么要编写自己的异常类？

（1）标准库中的异常类是有限的

（2）在自己的异常类中，可以添加自己的信息（标准库中的异常类值允许设置一个用来描述异常的字符串）

如何编写自己的异常类？

（1）建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时

（2）当继承标准异常类时，应该重载父类的what()函数和虚析构函数

（3）因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。

下面是一个C++标准异常库的应用实例

class Person
{
public:
	Person()
	{
		mAge = 0;
	}

	void setAge(int age)
	{
		if (age < 0 || age > 100)
			throw out_of_range("年龄应该在0到100之间");

		this->mAge = age;
	}

private:
	int mAge;
};

void Test()
{
	Person p;

	try
	{
		p.setAge(1000);
	}
	catch (const exception &e)
	{
		cout << e.what() << endl;
	}
}

下面是自己手写的异常类的应用实例。

class MyOutOfRangeException : public exception
{
public:
	MyOutOfRangeException(char *error)
	{
		pError = new char[strlen(error) + 1];
		strcpy_s(pError, strlen(error) + 1, error);
	}
	~MyOutOfRangeException()
	{
		if (pError != nullptr)
		{
			delete[] pError;
		}
	}
	virtual const char *what() const
	{
		return pError;
	}

private:
	char *pError;

};

void Call(void)
{
	throw MyOutOfRangeException("我自己的异常类！");
}

void Test()
{
	try
	{
		Call();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
}

六 异常的继承

下面是一个自己手写异常继承的应用案例。

// 异常基类
class BaseMyException
{
public:
	virtual void what() = 0;
	virtual ~BaseMyException() {}
};

// 继承
class TargetSpaceNullException : public BaseMyException
{
public:
	virtual void what()
	{
		cout << "目标空间为空！" << endl;
	}
	~TargetSpaceNullException() {}
};

// 继承
class SourceSpaceNullException : public BaseMyException
{
public:
	virtual void what()
	{
		cout << "源空间为空！" << endl;
	}
	~SourceSpaceNullException() {}
};

void copy_str(char *target, char *source)
{
	if (target == nullptr)
	{
		throw TargetSpaceNullException();
	}

	if (source == nullptr)
	{
		throw SourceSpaceNullException();
	}

	while (*source != '\0')
	{
		*target = *source;
		target++;
		source++;
	}
	*target = '\0';
}

int main(int argc, char **argv)
{
	char *source = "abcdefg";
	char buf[1024] = { 0 };
	try
	{
		copy_str(nullptr, source);
	}
	catch (BaseMyException &e)
	{
		e.what();
	}

	cout << buf << endl;
	getchar();
	return 0;
}