一，异常的推演
1.函数与异常
平时我们在函数中出现异常情况时通常通过return终止函数并返回一个值，然后在函数上层来获取值并判断是什么异常情况。因为函数是栈结构的，所以return的时候是通过栈结构逐步往上的，不能够跨函数直接抛出，不方便。所以C++推出了异常机制，通过异常机制我们可以轻松的捕获要出现的异常。
2.C++中异常的基本演示
# include<iostream>
using namespace std; /* 定义求商函数，如果除数为0，抛出double类型异常 */
double div(double d1, double d2)
{
if (d2 == )
{
throw d2;
}
return d1 / d2;
} int main()
{
/* try...catch语句来捕获异常 */
try
{
double result = div(1.02, 0.0);
}
catch (double e)
{
/* C++中的异常严格要求类型匹配,即抛出什么的异常就catch什么类型的异常 */
cout << e << "不能作除数" << endl;
}
catch (...)
{
cout << "未知异常" << endl;
} return ;
}
3.C++中异常的总结
- 异常的捕捉严格匹配数据类型，不支持类型自动转换，throw的是int类型则catch的必须是int类型否则不会匹配。
- 一般我们在异常最后加入catch(...)这样能够捕获任意异常。
二，自定义异常类
1.异常类
按照面向对象的思维，我们的异常也应该是一个对象，所以在抛出异常的时候，我们通常自定义一个异常类，然后把异常信息放入异常类中，然后在捕捉到异常对象的时候，再调用对象的方法，打印出异常的信息。
2.异常类代码演示
# define _CRT_SECURE_NO_WARNINGS
# include<iostream>
using namespace std; /* 自定义异常类 */
class MyException
{
private:
char * content;
public:
/* 异常类构造函数 */
MyException(const char * content)
{
this->content = new char[strlen(content) + ];
strcpy(this->content, content);
cout << "异常类有参构造函数执行" << endl;
}
/* 异常类拷贝构造函数 */
MyException(const MyException& me)
{
this->content = new char[strlen(me.content) + ];
strcpy(this->content, me.content);
cout << "异常类拷贝构造函数执行" << endl;
}
/* 异常类析构函数 */
~MyException()
{
if (this->content != NULL)
{
delete[] this->content;
this->content = NULL;
}
cout << "异常类的析构函数执行" << endl;
}
/* 异常类抛出异常信息 */
void toString()
{
cout << this->content << endl;
}
}; /* 定义测试异常的函数 */
double divide(double d1, double d2)
{
if (d2 == )
{
throw MyException("除数不能为0");
//throw new MyException("除数不能为0");
}
return d1 / d2;
} int main()
{
try
{
double result = divide(, );
cout << "result = " << result << endl;
}
catch (MyException e)
{
// catch的异常是元素类型,执行的是拷贝构造函数,存在两个异常对象,释放两个异常对象,不合理
e.toString();
}
catch (MyException * e)
{
// catch的异常是指针类型,必须我们手动调用delete方法才能调用析构函数,不合理
e->toString();
delete e;
}
catch (MyException& e)
{
// catch的是引用类型,是原先抛出的对象,会自动执行析构函数,我们使用引用来接收抛出的异常对象
e.toString();
}
catch (...)
{
cout << "未知异常" << endl;
} return ;
}
3.自定义异常类总结
- 抛出异常对象通常用引用的方式来catch这个对象，如果是元素catch异常对象则会执行拷贝构造函数，创建两个重复异常对象并释放两次对象，所以说不合理。如果catch的是指针类型，不会自动调用该对象的析构函数必须我们手动delete，也不符合自动调用的逻辑，所以使用引用的方式来catch异常对象。
三，标准异常类
1.标准异常类
C++中提供了标准的异常类，需要# include<exception>，标准异常类为exception，该类有个what函数，可以打印异常对象的异常信息。该what函数是虚函数，我们需要继承exception类并重写该what函数，在捕捉异常的时候，我们用父类的引用来接收自定义的标准异常类的子类对象（类型兼容性原则），然后打印该异常信息即可。
2.标准异常类演示
# include<iostream>
# include<exception>
using namespace std; /* 继承自标准异常类 */
class DivException :public exception
{
private:
const char * ptr;
public:
/* 构造函数接收异常信息 */
DivException(const char * ptr)
{
this->ptr = ptr;
}
/* 重写what函数 */
virtual char const * what() const
{
cout << this->ptr << endl;
return ptr;
}
};
/* 测试异常函数 */
int divi(int a, int b)
{
if (b == )
{
throw DivException("除数不能为0");
}
return a / b;
} int main()
{
try
{
divi(, );
}
catch (exception& e)
{
/* 使用exception引用接收自定义的子类对象 */
e.what();
}
catch (...)
{
cout << "未知异常" << endl;
} return ;
}