1 异常理论
1.1 何为异常？
在实际运行环境中发生，却在设计、编码、测试阶段无法预料的，各种潜在的问题。
1.2 报告异常的2种机制
1）通过 return 返回值报告异常信息：
所有局部对象都能正确地被析构、被释放
定位错误点，需要逐层判断，流程繁琐
2）抛出--捕获异常对象：
所有局部对象都能正确地被析构、被释放
定位错误点，可一步到位，流程简单
cpp
// return.cpp 1)通过return报告异常信息
#include <iostream>
#include <cstdio>
using namespace std;
class A {
public:
A() { cout << "A() is invoked" << endl; }
~A() { cout << "~A() is invoked" << endl; }
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int foo() {
cout << "foo出错前的几百行代码" << endl;
A a;
FILE* pfile = fopen("./cfg", "r");
if( !pfile )
return -1; // (1)将数据返回给调用者 (2)跳转至右花括号
cout << "foo出错后的几百行代码" << endl;
return 0;
} // a.~A() 释放a本身所占内存空间
int bar() {
cout << "bar出错前的几百行代码" << endl;
A b;
if( foo()==-1 )
return -1;
cout << "bar出错后的几百行代码" << endl;
return 0;
} // b.~A() 释放b本身所占内存空间
int hum( ) {
cout << "hum出错前的几百行代码" << endl;
A c;
if( bar()==-1 )
return -1;
cout << "hum出错后的几百行代码" << endl;
return 0;
} // c.~A() 释放c本身所占内存空间
int main( void ) {
cout << "main出错前的几百行代码" << endl;
A d;
if( hum()==-1 )
return -1;
cout << "main出错后的几百行代码" << endl;
return 0;
} // d.~A() 释放d本身所占内存空间2 抛出异常(throw异常对象)
1）可以抛出基本类型的对象，如：
throw -1;
throw "内存分配失败";
2）可以抛出类类型的对象，如：
MemoryException ex;
throw ex; // 栈对象
throw MemoryException(); // 匿名堆对象
3）但不要抛出++局部对象的指针++，如：
MemoryException ex;
throw &ex; // 错误！（同C中，不要返回局部变量的地址）
3 捕获异常(try catch)
try { 可能引发异常的语句; }
catch ( 异常类型1& ex ) { 针对异常类型1的异常处理; }
catch ( 异常类型2& ex ) { 针对异常类型2的异常处理; }
...
catch ( 异常类型n& ex ) { 针对异常类型n的异常处理; }
cpp
// throwPre.cpp 利用throw报告异常信息
// 对于能解决的异常，尽早捕获；
// 对于不能解决的异常，远点捕获，使程序尽早结束。
#include <iostream>
#include <cstdio>
using namespace std;
class A {
public:
A() { cout << "A() is invoked" << endl; }
~A() { cout << "~A() is invoked" << endl; }
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo() {
cout << "foo出错前的几百行代码" << endl;
A a;
FILE* pfile = fopen("./cfg", "r");
if( !pfile )
throw -1;
cout << "foo出错后的几百行代码" << endl;
} // a.~A() 释放a本身所占内存空间
void bar() {
cout << "bar出错前的几百行代码" << endl;
A b;
// try {
foo();
// }
// catch( int e ) {
// cout << "bar函数中捕获异常信息: " << e << endl;
// }
cout << "bar出错后的几百行代码" << endl;
} // b.~A() 释放b本身所占内存空间
void hum( ) {
cout << "hum出错前的几百行代码" << endl;
A c;
// try {
bar();
// }
// catch( int e ) {
// cout << "hum函数中捕获异常信息: " << e << endl;
// }
cout << "hum出错后的几百行代码" << endl;
} // c.~A() 释放c本身所占内存空间
int main( void ) {
cout << "main出错前的几百行代码" << endl;
A d;
try {
hum();
}
catch( int e ) {
cout << "main函数中捕获异常信息: " << e << endl;
}
cout << "main出错后的几百行代码" << endl;
return 0;
} // d.~A() 释放d本身所占内存空间4 建议、要求、总结
1）建议：在catch子句中使用引用接收异常对象，减少一次克隆。
建议：以匿名临时对象的形式抛出异常，编译器优化会减少一次克隆。
2）对于能解决的异常，尽早捕获；对于不能解决的异常，远点捕获，使程序尽早结束。
3）要求：异常对象必须允许被拷贝构造和析构
4）匹配顺序：根据异常对象的类型，自上至下顺序匹配，而非最优匹配
因此对子类类型异常的捕获，要放在对基类类型异常的捕获之前。
5）可以抛出基本类型、类类型的异常，建议抛类类型的异常，携带更多诊断信息，以便查错
6）可在catch中继续抛出所捕获的异常，或其他异常
7）任何未被捕获的异常，默认的处理方式就是中止进程
8）忽略异常：捕获异常，但不做处理： catch (...){} //三个点
cpp
// 关于 异常处理的 几点建议
#include <iostream>
#include <cstdio>
using namespace std;
class A {
public:
A() {}
A( const A& that ) { cout << "A类的拷贝构造函数被调用" << endl; }
~A() {}
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( ) {
A a;
throw A(); //建议抛出的为 匿名临时对象（编译器将优化，减少1次克隆）
}
int main( void ) {
try {
foo();
}
catch( A& e ) { // 建议利用引用 接收异常对象，减少1次克隆
// ...
}
return 0;
}
cpp
// throw2.cpp 建议将 子类类型异常捕获 放在 基类类型异常捕获 之前
// （顺序匹配，而非最优匹配）
#include <iostream>
#include <cstdio>
using namespace std;
class A {};
class B : public A {};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( ) {
throw B();
}
int main( void ) {
try {
foo();
}
catch( B& e ) { // 对子类类型异常的捕获
cout << "B类型的catch捕获" << endl;
}
catch( A& e ) { // 对基类类型异常的捕获
cout << "A类型的catch捕获" << endl;
}
return 0;
}5 "异常说明"
1）异常说明是函数原型的一部分，旨在说明函数可能抛出的异常类型：
返回类型 函数名 (形参表) throw (异常类型1，异常类型2，...) { 函数体; }
2）异常说明是一种承诺，承诺函数不会抛出 异常说明以外的异常类型：
如果抛出了异常说明以外的异常类型，该异常无法被捕获，(而被编译器捕获)，进程
中止。
3）隐式抛出异常的函数，也可以列出它的异常说明。
cpp
// except.cpp
// 异常说明 - 给 调用者 说明, 函数内部可能会抛出 哪些类型的异常
// - 给 调用者 承诺, 函数内部绝对不会抛出异常说明以外异常类型
#include <iostream>
#include <cstdio>
using namespace std;
void foo() throw(int,double, const char*) { // 显式抛出异常的函数
throw "hello world"; // 3.14; // -1;
}
void bar() throw(int,double, const char*) { // 隐式抛出异常的函数
foo();
// 调用几十个不同函数,而且每个函数都可能抛出异常，并且抛出的异常类型都不相同
}
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
try {
bar();
// foo();
}
catch(int& e) {
cout << "1. 捕获异常信息:" << e << endl;
}
catch(double& e) {
cout << "2. 捕获异常信息:" << e << endl;
}
catch(const char* e) {
cout << "3. 捕获异常信息:" << e << endl;
}
return 0;
}4）异常说明可以没有，也可以为空：
没有，表示可能抛出任何类型的异常 void foo (void) { ... }
为空，表示不会抛出任何类型的异常 void foo (void) throw() { ... }
5）异常说明在函数的声明和定义中必须保持严格一致，否则编译报错。
cpp
// except2.cpp
// 没有异常说明 - 给 调用者 承诺，函数内部可能抛出任何类型的异常
// 异常说明为空 - 给 调用者 承诺，函数内部不抛出任何类型的异常
#include <iostream>
#include <cstdio>
using namespace std;
void foo() {
throw "hello world"; // 3.14; // -1;
}
void bar() throw() {
throw -1;
}
void hum() throw(int,double); // 声明
void hum() throw(int,double) { // 定义
}
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
try {
// bar();
foo();
}
catch(...) { // 捕获异常，但不处理
}
/*
catch(int& e) {
cout << "1. 捕获异常信息:" << e << endl;
}
catch(double& e) {
cout << "2. 捕获异常信息:" << e << endl;
}
catch(const char* e) {
cout << "3. 捕获异常信息:" << e << endl;
}
*/
return 0;
}6 构造函数中的异常
1）构造函数可以抛出异常，某些时候还必须抛出异常
-
构造过程中可能遇到各种错误，比如内存分配失败
-
构造函数没有返回值，无法通过返回值通知调用者
2）构造函数抛出异常，对象将被不完整构造，这个对象的析构函数永不执行。
-
所有对象形式的成员变量，在抛出异常的瞬间，能得到正确地析构(构造函数的回滚机制)
-
所有动态分配的资源，必须在抛出异常之前，自己手动释放，否则形成资源的泄露
cpp
// consExcept.cpp 构造函数中的异常
#include <iostream>
#include <cstdio>
using namespace std;
class A {
public:
A() { cout << "A() is invoked" << endl; }
~A() { cout << "~A() is invoked" << endl; }
};
class C {
public:
C() : m_p(new int) {
//【A m_a;】定义m_a,利用m_a.A()
//【int* m_p=new int;】定义m_p,初值为指向一块堆内存(动态资源)
cout << "C() is invoked" << endl;
FILE* pfile = fopen("./file", "r");
if( !pfile ) {
delete m_p; // 动态资源需要自己手动释放
// 对于m_a,利用 m_a.~A() //回滚机制
// 释放 m_a/m_p 本身所占内存空间 //回滚机制
throw -1;
}
// ... 构造函数后续代码...
}
~C() {
delete m_p;
cout << "~C() is invoked" << endl;
// 对于m_a,利用 m_a.~A()
// 释放 m_a/m_p 本身所占内存空间
}
private:
A m_a;
int* m_p;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
try {
C c; // 定义c,利用c.C()
} // 如果c是完整构造的对象,将利用c.~C() , 但是如果c是残缺对象将不会调用~C()
catch( ... ) {
}
return 0;
}7 析构函数中的异常
1）析构函数中勿主动抛出异常：
在两种情况下，析构函数会被调用
一：正常销毁对象：离开作用域或显式delete
二：在异常传递的堆栈辗转开解(stack-unwinding)过程中
对于第二种情况，异常正处于激活状态，而析构函数也抛出了异常，即同时有两个
异常，这时C++将通过std::terminate()函数，令进程中止。这是不希望发生的~
2）对于可能引发异常的操作(被动抛异常)，尽量在析构函数内部消化：
try {...} catch (...) { ... }
cpp
// desconExcept.cpp 不 在析构函数中 "主动" 抛出异常
#include <iostream>
#include <cstdio>
using namespace std;
void foo() {
throw "foo函数中抛出的异常";
}
void bar() {
throw "bar函数中抛出的异常";
}
class A {
public:
~A() {
try {
bar();
}
catch( const char* e ) {
cout << "析构函数中捕获异常信息: " << e << endl;
}
// throw "析构函数中抛出的异常";
}
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
try {
A a;
foo();
//...后续代码...
} // a.~A() ...
catch( const char* e ) {
cout << "main中捕获异常信息: " << e << endl;
}
return 0;
}8 标准库异常类
建议抛以下类的异常：
cpp
// exceptPractice 捕获异常练习
#include <iostream>
#include <stdexcept> //std::bad_alloc
#include <typeinfo> //std::bad_cast
using namespace std;
/*
int main( void ) {
try {
new int[0xFFFFFFFFF];
}
catch( bad_alloc& e ) {
cout << "new 操作符申请内存失败" << endl;
}
}
*/
class A {
public:
virtual void foo() {}
};
class B : public A {};
class C : public B {};
int main( void ) {
B b;
A& a = b;
try {
dynamic_cast<C&>(a); // 如果成功 C类型的引用 引用了 B类对象 (有风险)
}
catch( bad_cast& e ) {
cout << "动态类型转换失败" << endl;
}
}