目录
异常的概念
在 C++ 中，异常处理的过程是：某个库软件或者代码提供的机制，能在异常处理情况时发出信号，这称为抛出异常（throwing the exception）。在程序的另一个地方，需要添加合适的代码处理异常情况，这称为处理异常（handing the exception）。这种编程方式可生成更有条理的代码
- C 语言处理异常的方式
int test(int x, int y) {
if (!y) return -1; // 用 -1 表示失败
else return x / y;
}用 -1 表示失败，但是如果传入的 x 和 y 为 10 和 -10 时，是允许的，但返回的 -1 却也可以是失败的意思
- C++异常优点
- 函数返回值可以忽略，异常不可以忽略。如果程序出现异常，但没有被获取，程序就会终止，使程序更具有健壮性，而如果使用 C语言 的 error 宏或者函数返回值，调用者可能会忘记检查，从而没有对错误进行处理，产生错误结果
- 整形返回值没有任何语义信息，异常包含语义信息
- 整形返回值缺乏相关的上下文信息，异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息
- 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在多个函数的调用栈中出现了某个错误，使用整形返回码要求你在每一级函数中都要进行处理，而使用异常处理的栈展开机制，只需要在一处进行处理就可以，需要每级函数都处理
异常的基本语法
抛出异常：可以使用 throw 语句在代码块中的任何地方抛出异常，throw 语句的操作数可以是任意的表达式（常量或者变量表达式），表达式的结果的类型决定抛出异常的类型
int divide(int x, int y) {
if (!y) {
throw y; // 抛异常
}
return x / y;
}捕获异常：catch 块跟在 try 块后面，用于捕获异常，可以指定想要捕获的异常类型，类型由 catch 关键字后面的括号内的异常声明决定的。
try
{
// 保护代码
}catch( ExceptionName e )
{
// 能处理任何异常的代码
}捕获任意异常：如果想让 catch 块能处理 try 块抛出的任何类型异常，则可以在异常声明的括号里使用 ...
try
{
// 保护代码
}catch(...)
{
// 能处理任何异常的代码
}小示例
代码示例：
#include<iostream>
using namespace std;
int divide(int x, int y) {
if (y == 0) {
throw y; // 抛异常
}
return x / y;
}
// 异常基本语法
void test01() {
// 试着捕获异常
try {
divide(10, 0);
}
// 异常根据类型进行匹配
catch(int e) {
cout << "除数为 " << e << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}运行结果：
C++异常是必须处理的，一场会随着函数不断往上走，直到捕获异常，且可以跨函数
测试代码：
#include<iostream>
using namespace std;
int divide(int x, int y) {
if (y == 0) {
throw y; // 抛异常
}
return x / y;
}
void CallDivide(int x, int y) {
divide(x, y);
}
void test02() {
try {
CallDivide(10, 0);
} catch (int e) {
cout << "除数为 " << e << endl;
}
}
int main() {
test02();
system("pause");
return 0;
}运行结果：
栈解旋（unwinding）
异常被抛出后，从进入 try 块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。析构的顺序和构造的顺序相反，这一过程称为栈的解旋（unwinding）
#include<iostream>
using namespace std;
class Person {
public:
Person() {
cout << "Person 构建" << endl;
}
~Person() {
cout << "Person 析构" << endl;
}
};
int divide2(int x, int y) {
Person p1, p2;
if (!y) throw y; // 抛出异常，可以理解为函数退出
// 下面的都不执行，Person类的对象也就析构了
cout << "不会打印" << endl;
return x / y;
}
int main() {
try {
divide2(10, 0);
}
catch (int) {
cout << "异常捕获" << endl;
}
system("pause");
return 0;
}运行结果：
异常接口声明
- 为加强程序的可读性，可以在函数声明中列出抛出异常的所有类型，例如 void func() throw(A, B, C);，就只能抛出 A，B，C及其子类型的异常
- 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如：void func()
- 一个不抛任何类型异常的函数可以声明为：void func() throw()
- 如果一个函数抛出了它的异常接口声明锁不允许抛出异常，unexcepted 函数会被调用，该函数默认行为调用 terminate 函数中断程序
- 函数 func01() 只能抛出 int，float，char 三种类型异常，抛出其他类型就会报错
void func01()throw(int, float, char) {
}- 函数 func02() 不能抛出任何异常
void finc02()throw() {
}- 函数 func03() 可以抛出任何异常
void func03() {
}异常类型
- throw 的异常是有类型的，可以是数字，字符串，类对象
- throw 的异常有类型，catch 需严格匹配异常类型
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
void func01() {
throw 1; // 抛出 int 类型异常
}
void func02() {
throw "exception"; // 抛出 const char* 类型异常
}
// 自定义的异常类
class MyException {
public:
// 有参构造
MyException(const char* str) {
error = new char[strlen(str) + 1];
strcpy(error, str);
}
// 拷贝构造
MyException(const MyException& me) {
this->error = new char[strlen(me.error) + 1];
strcpy(this->error, me.error);
}
// 重载 = ，深拷贝
MyException& operator=(const MyException& me) {
if (this->error != NULL) {
delete[] error;
error = NULL;
}
this->error = new char[strlen(me.error) + 1];
strcpy(this->error, me.error);
return *this;
}
void what() {
cout << error << endl;
}
// 析构
~MyException() {
if (error != NULL) {
delete[] error;
error = NULL;
}
}
public:
char* error;
};
void func03() {
throw MyException("<异常信息>"); // 抛出匿名对象异常
}
void test01() {
try {
func01();
}
catch (int) {
cout << "异常捕获" << endl;
}
//-----------------------------------
try {
func02();
}
catch (const char*) {
cout << "异常捕获" << endl;
}
//-----------------------------------
try {
func03();
}
catch (MyException e) {
e.what(); // 调用异常对象
}
//-----------------------------------
}
int main() {
test01();
system("pause");
return 0;
}异常对象生命周期
catch 捕获完后生命周期结束
普通的 = 方式取捕获
// 自定义异常类
class MyException {
public:
// 构造
MyException() {
cout << "构造函数" << endl;
}
// 拷贝构造
MyException(const MyException& me) {
cout << "拷贝构造" << endl;
}
// 析构
~MyException() {
cout << "析构函数" << endl;
}
};
void func() {
throw MyException(); // 创建匿名对象，调用构造
}
void test01() {
// 普通元素，异常对象 catch 处理完后就析构
try {
func();
}
catch (MyException ex) // 调用拷贝构造
{
cout << "异常捕获" << endl;
}
}运行结果：
先在抛出异常匿名对象时调用构造函数，然后捕获异常匿名对象调用拷贝构造函数，最后在处理完异常匿名对象调用析构函数。
引用 & 的方式捕获
// 自定义异常类
class MyException {
public:
// 构造
MyException() {
cout << "构造函数" << endl;
}
// 拷贝构造
MyException(const MyException& me) {
cout << "拷贝构造" << endl;
}
// 析构
~MyException() {
cout << "析构函数" << endl;
}
};
void func() {
throw MyException(); // 创建匿名对象，调用构造
}
void test02() {
// 引用 不用调用拷贝构造，异常对象 catch 处理完析构
try {
func();
}
catch (MyException& ex) // 不调用拷贝构造
{
cout << "异常捕获" << endl;
}
}运行结果：
在抛出异常匿名对象时调用构造函数，引用是给匿名对象其的别名，没有调用拷贝构造函数，最后在异常处理结束后匿名对象调用析构函数。
指针 * 的方式捕获
// 自定义异常类
class MyException {
public:
// 构造
MyException() {
cout << "构造函数" << endl;
}
// 拷贝构造
MyException(const MyException& me) {
cout << "拷贝构造" << endl;
}
// 析构
~MyException() {
cout << "析构函数" << endl;
}
};
void func() {
throw new MyException();
}
void test03() {
// 指针，抛异常的时候就要抛出地址
try {
func();
}
catch (MyException* ex) // 不调用拷贝构造
{
cout << "异常捕获" << endl;
delete ex; // 手动释放
}
}运行结果：
指针的方式去接受匿名对象，就要在抛出异常的时候抛出地址，但要使用 new 出来的对象，因为不适用new，只是单纯的对匿名对象取地址，在函数 func3() 结束完，就被析构了，通过 new 出来的对象需要手动去释放（析构）。
C++标准异常exception处理类
C++给我们提供了标准的异常处理类，它用来抛出C++标准库中函数执行时的异常
使用C++自带的标准异常类，需要包含对应的头文件
C++提供的标准异常类的层次结构如图：
所有的异常类都继承自exception基类，exception类下的logic_error和runtime_error又是两个比较大类，包含有多个子类，它们分表代表逻辑类错误和运行时错误。
- 使用new开辟内存时，如果遇到空间不足，则会抛出bad_alloc异常。
- 使用dynamic_cast（）进行动态类型转化失败时，则抛出bad_typeid异常。
- 计算数值超过该类型表示的最大范围时，则抛出overflow_error异常。
- 使用string类下标但越界时，则抛出out_of_range异常。
| 异常 | 描述 |
| std::exception | 所有标准C++异常的父类 |
| std::bad_alloc | 该异常可以通过 new 抛出 |
| std::bad_cast | 该异常可以通过 dynamic_cast 抛出。 |
| std::bad_exception | 这在处理 C++ 程序中无法预期的异常时非常有用 |
| std::bad_typeid | 该异常可以通过 typeid 抛出。 |
| std::logic_error | 理论上可以通过读取代码来检测到的异常。 |
| std::domain_error | 当使用了一个无效的数学域时，会抛出该异常。 |
| std::invalid_argument | 当使用了无效的参数时，会抛出该异常。 |
| std::length_error | 当创建了太长的 std::string 时，会抛出异常 |
| std::out_of_range | 该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator[]()。 |
| std::runtime_error | 理论上不可以通过读取代码来检测到的异常。 |
| std::overflow_error | 当发生数学上溢时，会抛出该异常。 |
| std::range_error | 当尝试存储超出范围的值时，会抛出该异常。 |
| std::underflow_error | 当发生数学下溢时，会抛出该异常。 |
编写自己的异常类
- 建议自己写的异常类要继承标准异常类，因为C++可以抛出任何异常类型，所以我们的异常类可以不继承标准异常类，但是这样可能会导致程序混乱，尤其协同开发。
- 当继承标准异常类时，应该重载父类的 what 函数和虚析构函数。
- 因为栈展开的过程中，需要复制异常类型，所以就要根据类中添加的成员考虑是否提供自己的复制构造函数。
代码示例：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<stdexcept>
// 自定义异常类
class MyOutOfRange :public exception { // 继承标准异常类
public:
// 有参构造
MyOutOfRange(const char* error) {
this->pError = new char[strlen(error) + 1];
strcpy(this->pError, error);
}
// 析构
~MyOutOfRange() {
if (pError != NULL) {
delete[] pError;
pError = NULL;
}
}
// what 方法
virtual char const* what() const {
return pError;
}
public:
char* pError;
};
void func01() {
throw MyOutOfRange("<自定义异常>");
}
void test01() {
try {
func01();
}
catch (exception& e) {
cout << e.what() << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}运行结果：
用基类去接受异常可以省去多个catch去捕获
继承在异常中的应用
代码示例：
#include<iostream>
using namespace std;
// 异常基类
class BaseMyException {
public:
virtual void what() = 0; // 纯虚函数
virtual ~BaseMyException() {} // 虚析构
};
// 目标文件异常类
class TargetSapceNullException :public BaseMyException {
public:
// 重写父类纯虚函数
virtual void what() {
cout << "目标空间为空" << endl;
}
~TargetSapceNullException() {}
};
// 源文件异常类
class SourceSpaceNullException :public BaseMyException {
public:
// 重写父类纯虚函数
virtual void what() {
cout << "源空间为空" << endl;
}
~SourceSpaceNullException() {}
};
void copy_str(char* target, const char* source) {
if (target == NULL) {
throw TargetSapceNullException();
}
if (source == NULL) {
throw SourceSpaceNullException();
}
while (*source != '\0') {
*target = *source;
target++;
source++;
}
}
int main() {
const char* source = "hello";
char buf[1024] = { 0 };
try {
copy_str(buf, source);
}
catch (BaseMyException& e) {
e.what();
}
cout << buf << endl;
system("pause");
return 0;
}当buf位置传入空指针，source位置不为空
运行结果：
当buf位置不为空，source 位置为空指针
运行结果：
184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
