异常
01.异常基本概念（了解）
异常处理就是处理程序中的错误。所谓错误是指在程序运行的过程中发生的一些异常事件
02.异常的作用（了解）
//C语言处理异常的方法的缺陷：
//1.返回值意思不明确
//2.返回值只能返回一条信息
//3.返回值可以忽略 返回值可以不当左值
C++的异常可以解决上面的问题
03.异常的基本语法（重点）
int func(int a, int b)
{
if (b == 0)
{
//2.抛出异常
throw 10;//抛出一个int类型的异常，
}
return a / b;
}
void test()
{
int a = 10;
int b = 0;
//1.把有可能出现异常的代码块放到try中
try
{
func(a, b);
}
catch (int)//3.接收一个int类型的异常
{
cout << "接收一个int类型的异常" << endl;
}
}
---------------------------------
打印：接收一个int类型的异常
04.异常代码的执行流程（了解）
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
int func(int a, int b)
{
if (b == 0)
{
//第二步：
throw 10;//抛出一个int类型的异常， //相当于return
cout << "throw后的代码" << endl;
}
return a / b;
}
void test()
{
int a = 10;
int b = 0;
try
{
func(a, b);//第一步：
cout << "func后的代码" << endl; //如果出现异常不会执行这行 会执行catch 捕捉异常
}
catch (int) //第三步：
{
cout << "接收一个int类型的异常" << endl;
}
}
int main()
{
test();
system("pause");
return EXIT_SUCCESS;
}
---------------------------------
打印：接收一个int类型的异常
05.异常的优势（重点）
1.用户不知道返回值是什么意思，异常可以抛出对象，对象中可以包含很多成员函数，可以有很信息
class Maker
{
public:
void printMaker()
{
cout << "除数不能为0" << endl;
}
};
int func(int a, int b)
{
if (b == 0)
{
Maker m;
throw m;
}
return a / b;
}
void test()
{
int a = 10;
int b = 0;
try
{
func(a, b);
}
catch (Maker maker)
{
cout << "接收一个Maker类型的异常" << endl;
maker.printMaker();
}
}
2.返回值用户可以忽略，但异常不能忽略，如果忽略给你报错
不用catch来解决抛出的异常 就会报错
3.返回值只能返回一条信息，但是对象有成员函数，可以包含多个信息
4.逐层依赖处理异常
int func(int a, int b)
{
if (b == 0)
{
throw 20.22; //抛出一个double类型的异常
}
return a / b;
}
void test()
{
int a = 10;
int b = 0;
try
{
func(a, b);
}
catch (int)
{
cout << "接收一个int类型的异常" << endl;
}
catch (Maker maker)
{
cout << "接收一个Maker类型的异常" << endl;
maker.printMaker();
}
catch (double s)
{
//不想处理异常，可以往上抛出，抛给调用本函数的函数
throw;
}
}
int main()
{
try
{
test();
}
catch (double d)
{
cout << "接收一个double类型的异常" << endl;
}
}
---------------------------------
打印：接收一个double类型的异常
06.异常的严格类型匹配（重点）
int func(int a, int b)
{
if (b == 0)
{
throw 20.0f; //抛出float类型异常
}
return a / b;
}
void test()
{
int a = 10;
int b = 0;
try
{
func(a, b);
}
catch (int)
{
cout << "接收一个int类型的异常" << endl;
}
catch (double s)
{
cout << "接收一个double类型的异常" << endl;
}
catch (char)
{
cout << "接收一个char类型的异常" << endl;
}
catch (...)//接收其他类型的异常
{
cout << "接收一个其他类型的异常" << endl;
}
}
-----------------------------
打印：接收一个其他类型的异常
07.异常的接口声明（了解）
//只能在QT或者别的编译器实现
void func() throw(int,char) //只允许抛出 int 或者 char异常
{
throw 3.14; //抛出一个double类型的异常，QT上程序会档
}
int main()
{
try
{
func();
}
catch(int)
{
cout << "int";
}
catch(...)
{
cout << ".....";
}
return 0;
}
08.栈解旋(重点)
1在抛出异常的函数中，如果抛出异常之后，但函数没有结束，这时，栈上申请的对象都会被释放这就叫栈解旋
class Maker
{
public:
Maker()
{
cout << "Maker的构造" << endl;
}
Maker(const Maker &m)
{
cout << "Maker的拷贝构造" << endl;
}
~Maker()
{
cout << "Maker的析构" << endl;
}
};
void func()
{
//在抛出异常的函数中，如果抛出异常之后，但函数没有结束，这时，栈上申请的对象都会被释放
//这就叫栈解旋
Maker m;
throw m;//这个m是Maker m拷贝一份的
cout << "func函数结束" << endl;
}
void test()
{
try
{
func();
cout << "func()代码后" << endl;
}
catch (Maker)
{
cout << "接收一个Maker类型的异常" << endl;
}
}
9.异常变量的生命周期（重点难点）
1.产生三个对象
class Maker
{
public:
Maker()
{
cout << "Maker的构造" << endl;
}
Maker(const Maker &m)
{
cout << "Maker的拷贝构造" << endl;
}
~Maker()
{
cout << "Maker的析构" << endl;
}
};
//产生三个对象
void func1()
{
Maker m;//第一个对象，在异常接收前被释放
throw m;//第二个对象，是第一个对象拷贝过来的
}
void test01()
{
try
{
func1();
}
catch (Maker m1) //第三个对象，是第二个对象拷贝过来的 拷贝后执行栈解旋
{
cout << "接收一个Maker类型的异常" << endl;
//第二个和第三个对象在catch结束时释放
}
}
//输出:
//Maker的构造
//Maker的拷贝构造
//Maker的拷贝构造
//~Maker的析构
//接受一个Maker类型的异常
//~Maker的析构
//~Maker的析构
2.产生二个对象
void func2()
{
//第一个对象
throw Maker(); //匿名对象 这里匿名对象不在当前行结束 在catch后
}
void test02()
{
try
{
func2();
}
catch (Maker m1) //第二个对象 拷贝构造
{
cout << "接收一个Maker类型的异常" << endl;
//第一个和第二个对象在catch结束时释放
}
}
//输出
//Maker的构造
//Maker的拷贝构造
//接受一个Maker类型的异常
//~Maker的析构
//~Maker的析构
3.产生一个对象（常用这个）
//以上操作比较耗费内存，常用这一个，只生成一个对象
void func3() {
throw Maker();//匿名对象
}
void test03() {
try {
func3();
}
catch (Maker& m1) {
//引用接收，不能用指针接受，会宕掉，因为编译器不允许对栈中的匿名对象取地址操作
//但编译器允许对堆区中的匿名对象取地址操作,见test04()
cout << "接受一个Maker类型的异常" << endl;
//对象释放
}
}
//输出：
//Maker的构造
//接受一个Maker类型的异常
//~Maker的析构
4.注意：
void func4() {
//throw Maker(); //错误,若非要用指针接受，需要在堆区开辟一个对象
throw new Maker();//匿名对象
}
void test04() {
try {
func4();
}
catch (Maker* m1) {
cout << "接受一个Maker类型的异常" << endl;
//对象释放
delete m1;
}
}
//输出：
//Maker的构造
//接受一个Maker类型的异常
//~Maker的析构
10.异常的多态（重点）
//异常的基类
class Father
{
public:
virtual void printM()
{
}
};
//1.有继承
class SonNULL :public Father
{
public:
virtual void printM()//2.重写父类的虚函数
{
cout << "空指针异常" << endl;
}
};
class SonOut :public Father
{
public:
virtual void printM()
{
cout << "越位溢出" << endl;
}
};
void func(int a,int b)
{
if (a == 0)
{
throw SonNULL();
}
if (b == 0)
{
throw SonOut();
}
}
void test()
{
int a = 0;
int b = 10;
try
{
func(a,b);
}
catch (Father &f)//3.父类引用指向子类对象
{
f.printM();
}
}
11.系统提供的标准异常（重点）
11.系统的标准异常类
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include<stdexcept> //2013以上Vs可以不用
#include<string>
class Maker
{
public:
Maker(int age)
{
if (age<0 || age>150)
{
throw out_of_range("年龄不在范围内");
//异常范围 类的构造函数 对象用.what()打印
}
else
{
this->age = age;
}
}
public:
int age;
};
void test()
{
try
{
Maker m(200);
}
catch (out_of_range &ex)
{
cout << ex.what() << endl;
}
}
int main()
{
test();
system("pause");
return EXIT_SUCCESS;
}
2.自己编写的异常类
class MyOut_of :public exception
{
public:
MyOut_of(const char* errorinfo)
{
this->m_Info = string(errorinfo); //const char*转换string
}
MyOut_of(const string errorinfo) //接受自己的异常反馈
{
this->m_Info = errorinfo;
}
const char* what() const
{
return this->m_Info.c_str(); //把string转换const char*
}
public:
string m_Info;
};
class Maker
{
public:
Maker(int age)
{
if (age<0 || age>150)
{
throw MyOut_of("自己的异常类，年龄不在范围内");
}
else
{
this->age = age;
}
}
public:
int age;
};
void test()
{
try
{
Maker m(200);
}
catch (MyOut_of& ex)
{
cout << ex.what() << endl;
}
}
浙公网安备 33010602011771号