宝丰网站制作公司,电子商务网站开发遇到的问题,将台地区网站建设,天津网站制作福州1 异常理论
1.1 何为异常#xff1f; 在实际运行环境中发生#xff0c;却在设计、编码、测试阶段无法预料的#xff0c;各种潜在的问题。
1.2 报告异常的2种机制 1#xff09;通过 return 返回值报告异常信息#xff1a; 所有局部对象都能正确地被析构、被释放 定位错…
1 异常理论
1.1 何为异常 在实际运行环境中发生却在设计、编码、测试阶段无法预料的各种潜在的问题。
1.2 报告异常的2种机制 1通过 return 返回值报告异常信息 所有局部对象都能正确地被析构、被释放 定位错误点需要逐层判断流程繁琐 2抛出--捕获异常对象 所有局部对象都能正确地被析构、被释放 定位错误点可一步到位流程简单
// 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的异常处理; } // 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 (...){} //三个点
// 关于 异常处理的 几点建议
#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;
}
// 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隐式抛出异常的函数也可以列出它的异常说明。
// 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异常说明在函数的声明和定义中必须保持严格一致否则编译报错。
// 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构造函数抛出异常对象将被不完整构造这个对象的析构函数永不执行。 - 所有对象形式的成员变量在抛出异常的瞬间能得到正确地析构(构造函数的回滚机制) - 所有动态分配的资源必须在抛出异常之前自己手动释放否则形成资源的泄露
// 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_pnew 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 (...) { ... }
// 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 标准库异常类 建议抛以下类的异常 // 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_castC(a); // 如果成功 C类型的引用 引用了 B类对象 (有风险)}catch( bad_cast e ) {cout 动态类型转换失败 endl;}
}
