C++异常处理的编程方法

现代程序设计语言拥有的一个重要的特性就是能较好地支持异常的处理（Exception Handling）。她就像一位美丽而优雅的公主，帮助程序员写出来的代码总是那样的整齐美观、层次清晰；同时它好像还是一位贤惠能干的贤内助...

目录
C 异常处理的编程方法 22
主人公介绍 22
第1集 初次与异常处理编程相邂逅 25
第2集 C 中异常处理的游戏规则 28
第3集 C 中catch(…)如何使用 37
第4集 C 的异常处理和面向对象的紧密关系 46
第5集 C 的异常rethrow 51
第6集 对象的成员函数中抛出的异常 58
对象的成员函数抛出的异常时概括性总结 62
第7集 构造函数中抛出的异常 62
第8集 析构函数中抛出的异常 71
第9集 C 的异常对象如何被传递 79
第10集 C 的异常对象按传值的方式被复制和传递 82
异常对象标示符的有效作用域 91
第11集 C 的异常对象按引用方式被传递 95
第12集 C 的异常对象按指针方式被传递 104
第13集 C 异常对象三种方式传递的综合比较 108
第14集 再探C 中异常的rethrow 109
异常对象再次原封不动地被重新抛出 109
void main() 121
catch(MyException& e) 122
// 异常对象重新被抛出 122
catch(MyException& e) 122
void main() 123
catch(MyException& e) 123
// 异常对象重新被抛出 123
catch(MyException e) 124
另一种特殊的形式的异常被重新抛出 124
void main() 124
catch(MyException& e) 125
catch(MyException& ex) 125
catch(MyException& e) 126
第15集 C语言中的异常处理机制 126
goto语句，实现异常处理编程，最初也最原始的支持手段 127
// 函数调用成功，我们正常的处理 127
while(condition) 127
//do other job 127
// 如果错误直接跳转 127
//do other job 128
// 如果错误直接跳转 128
// 如果错误直接跳转 128
为什么不建议使用goto语句来实现异常处理编程 128
第16集 C语言中一种更优雅的异常处理机制 129
void main( void ) 132
if( jmpret == 0 ) 132
// 如果从终端输入的第2个变量是0值的话 133
// 注意，下面这条语句的作用是，恢复先前setjmp所保存的程序状态 134
void fpcheck( void ) 134
switch( fperr ) 134
1 / 2 = 0.5 135
Error 131: Divide by zero 136
分析setjmp和longjmp 136
第17集 全面了解setjmp与longjmp的使用 137
void main( void ) 138
if( jmpret == 0 ) 138
else 139
switch (jmpret) 139
setjmp与longjmp相结合，实现程序的非本地的跳转 140
void Func1() 141
void Func2() 141
void Func3() 141
void main( void ) 141
if( jmpret == 0 ) 142
// 下面的这些函数执行过程中，有可能出现异常 142
else 142
switch (jmpret) 142
setjmp和longjmp使用时，需要特别注意的事情 143
class Test 143
//注意，上面声明了一个全局变量obj 143
void main( void ) 143
// 注意，这里将会导致程序崩溃，无条件退出 144
if( jmpret == 0 ) 144
// 下面的这些函数执行过程中，有可能出现异常 144
else 144
switch (jmpret) 144
Press any key to continue 145
int Sub_Func() 145
if( jmpret == 0 ) 146
else 146
switch (jmpret) 146
void main( void ) 147
int Sub_Func() 147
// 注意，这里改动了一点 147
if( jmpret == 0 ) 147
else 148
switch (jmpret) 148
void main( void ) 149
第18集 玩转setjmp与longjmp 149
* author: 王胜祥 * 150
* email: <mantx@21cn.com> * 150
* date: 2005-03-07 * 150
* version: * 150
* filename: ceh.h * 150
如果您想在多线程的程序中使用它，您可以自己试着来继续完善这个 151
c表示err_msg 152
#define rethrow thrower(ceh_ex_info) 153
/* 定义catch block（异常错误的处理模块） 153
catch表示捕获所有类型的异常 154
/* 定义catch block（异常错误的处理模块） 154
catch_part表示捕获一定范围内的异常 155
/* 定义catch block（异常错误的处理模块） 155
catch_one表示只捕获一种类型的异常 155
* author: 王胜祥 * 156
* email: <mantx@21cn.com> * 156
* date: 2005-03-07 * 156
* version: * 156
* filename: ceh.c * 156
如果您想在多线程的程序中使用它，您可以自己试着来继续完善这个 156
#include "ceh.h" 157
void CEH_push(CEH_ELEMENT* ceh_element) 157
CEH_ELEMENT* CEH_pop() 157
CEH_ELEMENT* CEH_top() 157
int CEH_isEmpty() 158
switch( num ) 159
void CEH_init() 160
#include "ceh.h" 160
int main(void) 160
//定义try block块 160
try 160
// 其中第一个参数，表示异常类型；第二个参数表示错误代码 161
// 第三个参数表示错误信息 161
//定义catch block块 161
catch 161
// 这里稍有不同，需要定义一个表示当前的try block结束语句 161
// 它主要是清除相应的资源 161
end_try 161
catch块，被执行到 161
#include "ceh.h" 162
void test1() 162
void test() 162
int main(void) 162
try 162
catch 163
end_try 163
#include "ceh.h" 163
int main(void) 163
try 163
try 163
catch 164
end_try 164
catch 164
end_try 164
#include "ceh.h" 165
int main(void) 165
try 165
// 这里表示捕获异常类型从4到6的异常 165
catch_part(4, 6) 165
// 这里表示捕获异常类型从9到10的异常 165
catch_part(9, 10) 165
// 这里表示只捕获异常类型为1的异常 166
catch_one(1) 166
// 这里表示捕获所有类型的异常 166
catch 166
end_try 166
catch_part(9, 10)块，被执行到 166
#include "ceh.h" 167
int main(void) 167
catch_part(4, 6) 167
catch_part(2, 3) 167
// 找到了对应的catch block 168
catch_one(1) 168
catch 168
end_try 168
#include "ceh.h" 168
void test() 169
int main(void) 169
catch 169
end_try 169
catch 169
catch 170
catch 170
end_try 170
end_try 170
#include "ceh.h" 171
void test() 171
int main(void) 171
// 这里表示程序中将捕获浮点数计算异常 171
// 这里出现浮点数计算异常 172
end_try 172
catch_part(4, 6) 172
catch_part(2, 3) 172
catch 173
// 这里再次把上面的异常重新抛出 173
end_try 173
catch_part(7, 9) 173
catch 173
// 但是这个异常没有对应的catch block处理，所以系统中处理了 174
end_try 174
第19集 setjmp与longjmp机制，很难与C 和睦相处 175
C 语言中使用setjmp与longjmp 175
class MyTest 176
MyTest () 176
virtual ~ MyTest () 176
void test1() 176
void test() 176
void main( void ) 176
// 设置好异常出现时，程序的回溯点 177
if( jmpret == 0 ) 177
else 177
构造一个MyTest类型的对象 177
析构销毁一个MyTest类型的对象 177
class MyTest 178
MyTest () 178
virtual ~ MyTest () 178
void test1() 178
// 注意，这里在上面程序的基础上，进行了一点小小的改动 178
void test() 178
void main( void ) 179
if( jmpret == 0 ) 179
else 179
构造一个MyTest类型的对象 179
class MyTest 180
MyTest () 180
virtual ~ MyTest () 180
void test1() 180
void test() 180
/ // 注意，现在又把它挪到了这里 181
void main( void ) 181
if( jmpret == 0 ) 181
else 181
构造一个MyTest类型的对象 181
析构销毁一个MyTest类型的对象 181
class MyTest 182
MyTest () 182
virtual ~ MyTest () 182
void main( void ) 182
if( jmpret == 0 ) 182
else 183
第20集 C 中如何兼容并支持C语言中提供的异常处理机制 183
C 语言中如何处理goto语句 183
class MyTest 184
MyTest () 184
virtual ~ MyTest () 184
void main( void ) 184
构造一个MyTest类型的对象 185
构造一个MyTest类型的对象 185
构造一个MyTest类型的对象 185
构造一个MyTest类型的对象 185
析构销毁一个MyTest类型的对象 185
析构销毁一个MyTest类型的对象 185
析构销毁一个MyTest类型的对象 185
析构销毁一个MyTest类型的对象 185
class MyTest 187
MyTest () 187
virtual ~ MyTest () 187
void main( void ) 187
第21集 Windows系列操作系统平台中所提供的异常处理机制 189
SEH设计的主要动机 189
void test1() 191
if (!p2) 191
// 但是程序员很容易忘记，也容易出错 191
if (!p3) 191
// 但是程序员很容易忘记，也容易出错 191
if (!p4) 192
// 但是程序员很容易忘记，也容易出错 192
// do other job 192
void test() 192
// do other job 192
// do other job 192
// 这里的资源可能得不到释放 192
void main( void ) 193
if( jmpret == 0 ) 193
// do other job 193
// do other job 193
// 这里的资源可能得不到释放 193
__try 195
__finally 195
第22集 更进一步认识SHE 196
通过一个简单例子，来理解SEH机制 198
EXCEPTION_DISPOSITION myHandler( 198
void * DispatcherContext) 199
int main() 199
// 建立异常结构帧（EXCEPTION_REGISTRATION） 199
// 把异常结构帧插入到链表中 199
mov fs:[0], eax 200
// 下面的语句被执行，将导致一个异常 200
来一个稍微复杂一点例子，来更深入理解SEH机制 203
void printfErrorMsg(int ex_code) 205
switch (ex_code) 205
void * DispatcherContext) 206
// 恢复上一个异常帧 206
mov eax, EstablisherFrame 207
mov fs:[0], eax 207
void * DispatcherContext) 207
// 恢复上一个异常帧 208
mov eax, EstablisherFrame 208
mov fs:[0], eax 208
// 下面的语句被执行，将导致一个异常 209
void test2() 209
// 下面的语句被执行，将导致一个异常 209
void test3() 210
// 下面的语句被执行，将导致一个异常 210
int main() 210
在main()函数中，调用test1()函数之前 211
被0除异常，错误代码为：0xc0000094 211
在main()函数中，调用test1()函数之后 211
在main()函数中，调用test2()函数之前 211
在test2()函数中，调用test1()函数之前 211
被0除异常，错误代码为：0xc0000094 211
在test2()函数中，调用test1()函数之后 211
在main()函数中，调用test2()函数之后 211
在main()函数中，调用test3()函数之前 211
在main()函数中，调用test3()函数之后 211
Press any key to continue 212
第23集 SEH的强大功能之一 212
//seh-test.c 212
void main() 212
// 定义受监控的代码模块 213
__try 213
//定义异常处理模块 213
__except(1) 213
try-except进阶 213
// 例程1 213
void main() 214
__try 214
__except(1) 214
// 又一个try-except语句 214
__try 214
__except(1) 214
// 例程2 214
void main() 215
__try 215
// 又一个try-except语句 215
__try 215
__except(1) 215
__except(1) 215
// 例程3 216
// 分层的嵌套在__except模块中 216
void main() 216
__try 216
__except(1) 216
// 又一个try-except语句 216
__try 216
__except(1) 216
try-except异常处理规则 217
// seh-test.c 218
// 异常处理模块的查找过程演示 218
int seh_filer() 218
void test() 218
__try 218
// 下面将导致一个异常 219
// 注意，__except关键字后面的表达式是一个函数表达式 219
// 而且这个函数将返回0，所以控制流进入到上一层 219
// 的try-except语句中继续查找 219
__except(seh_filer()) 219
void main() 219
__try 219
// 注意，这个函数的调用过程中，有可能出现一些异常 219
// 注意，这个表达式是一个逗号表达式 220
// 它前部分打印出一条message，后部分是 220
// 一个常量，所以这个值也即为整个表达式 220
// 的值，因此系统找到了__except定义的异 220
// 常处理模块，控制流进入到__except模块里面 220
__except(puts("in filter"), 1) 220
main()函数的try块中 220
test()函数的try块中 220
main()函数的except块中 220
world 220
Press any key to continue 220
void main() 222
__try 222
// 下面将导致一个异常 222
// 注意，异常出现后，程序控制流又恢复到了这里 222
// 当控制流恢复到原来异常点时，避免了异常的再次发生 222
hello 223
world 223
Press any key to continue 223
void main() 223
__try 223
// 下面将导致一个异常 223
// 当控制流恢复到原来异常点时，异常将不会再次发生 224
__except(puts("in filter"), p = &a, -1) 224
try-except深入 225
void main() 227
__try 227
__try 227
// 下面将导致一个异常 227
// 注意，__except模块捕获一个存储保护异常 227
// 注意，__except模块捕获一个被0除异常 228
hello 228
存储保护异常 228
内层的except块中 228
world 228
Press any key to continue 228
VOID RaiseException( 228
DWORD dwExceptionCode, // exception code 228
int seh_filer(int code) 229
switch(code) 229
if(code & (1<<29)) 231
void main() 231
__try 231
// 注意，主动抛出一个软异常 231
__except(seh_filer(GetExceptionCode())) 231
hello 232
try块中 232
用户自定义的软件异常，错误代码：e0000001 232
except块中 232
world 232
Press any key to continue 232
C 0 0 0 0 0 0 5 （十六进制） 232
第24集 SEH的强大功能之二 234
try-finally的作用 234
try-finally的语法规则 234
//seh-test.c 234
void main() 235
__try 235
// 注意，这里不是__except块，而是__finally取代 235
__finally 235
hello 235
__finally块中 235
world 235
Press any key to continue 235
void main() 236
__try 236
// 注意，下面return语句直接让函数返回了 236
__finally 236
hello 236
__finally块中 237
Press any key to continue 237
void main() 237
__try 237
// 跳转指令 237
__finally 237
hello 238
__finally块中 238
world 238
Press any key to continue 238
况下，一旦执行流在离开当前的作用域时，finally块区域内的代码必将会被执行” 238
try-finally块中的异常 238
void test() 238
__try 238
// 下面抛出一个异常 238
__finally 239
void main() 239
__try 239
__except(1) 239
hello 239
__finally块中 240
__except块中 240
Press any key to continue 240
__leave关键字的作用 240
void test() 240
__try 240
// 直接跳出当前的__try作用域 241
__finally 241
// 这里会被执行吗？当然 241
void main() 241
__try 241
__except(1) 241
hello 242
__finally块中 242
world 242
Press any key to continue 242
try-finally深入 242
void test1() 242
__try 242
// do other job 243
// 期间可能抛出异常 243
__finally 243
// 这里保证所有资源被及时释放 243
void test() 243
__try 243
// do other job 244
// 期间可能抛出异常 244
// do other job 244
__finally 244
// 这里保证资源被释放 244
void main( void ) 244
__try 244
__try 244
// do other job 244
// 期间可能抛出异常 244
// do other job 244
__finally 245
// 这里保证资源被释放 245
__except(1) 245
总结 245
第25集 SEH的综合 246
try-except和try-finally组合使用 246
// 例程1，try-except语句与try-finally语句平行关系 246
void main() 246
__try 246
// 下面抛出一个异常 246
__except(1) 246
__try 247
__finally 247
// 例程2，try-except语句中嵌套try-finally 247
void main() 247
__try 247
__try 247
// 下面抛出一个异常 247
__finally 248
__except(1) 248
// 例程3，try-finally语句中嵌套try-except 248
void main() 248
__try 248
__try 249
// 下面抛出一个异常 249
__except(1) 249
__finally 249
try-except和try-finally组合使用时，需注意的事情 249
// 例程1，一个__try块，两个__except块 250
void main() 250
__try 250
// 下面抛出一个异常 250
__except(1) 250
// 这里有语法错误 250
__except(1) 250
// 例程2，一个__try块，两个__finally块 251
void main() 251
__try 251
__finally 251
// 这里有语法错误 251
__finally 251
void main() 252
__try 252
// 下面抛出一个异常 252
__finally 252
// 这里有语法错误 252
__except(1) 252
温过而知新 253
#include "stdio.h" 253
void test() 253
int* p = 0x00000000; // pointer to NULL 253
__try 253
__try 253
// 导致一个存储异常 253
// 呵呵，注意这条语句 253
__finally 253
// 呵呵，注意这条语句 254
__except(puts("in filter 1"), 0) 254
void main() 254
__try 254
__except(puts("in filter 2"), 1) 254
hello 254
in try 255
in try 255
in filter 1 255
in filter 2 255
in finally 255
in except 2 255
world 255
Press any key to continue 255
总结 256
第 26 集 SEH 可以在 C 程序中使用 257
先来一个简单的例子 257
#include "stdio.h" 257
void test() 258
int* p = 0x00000000; // pointer to NULL 258
__try 258
__try 258
// 导致一个存储异常 258
__finally 258
puts(" 这里也不会被执行到 "); 258
__except(puts("in filter 1"), 0) 258
void main() 259
__try 259
__except(puts("in filter 2"), 1) 259
hello 259
in try 259
in try 259
in filter 1 259
in filter 2 259
in finally 259
in except 2 259
world 259
Press any key to continue 259
来一个真正意义上的 C 程序，且使用 SEH 机制 260
#include "stdio.h" 260
class A 260
void test1() 260
A a2,a3; 260
void test() 260
int* p = 0x00000000; // pointer to NULL 260
__try 260
// 这里调用 test1 函数，它函数内部会创造 object 261
// 应该属于 100% 的 C 程序了吧！ 261
__try 261
// 导致一个存储异常 261
__finally 261
puts(" 这里也不会被执行到 "); 261
__except(puts("in filter 1"), 0) 261
void main() 261
__try 262
__except(puts("in filter 2"), 1) 262
总结 262
第 27 集 SEH 与 C 异常模型的混合使用 262
朋友们，准备好了心情吗？这可是有点复杂呦！ 262
如何混合使用呢？ 262
#include "stdio.h" 263
class A 263
// 抛出 C 异常 263
// 这个函数中使用了 try-catch 处理异常，也即 C 异常处理 263
void test1() 263
A a2,a3; 263
catch(int errorcode) 263
void test() 264
int* p = 0x00000000; // pointer to NULL 264
__try 264
// 这里调用 test1 函数 264
__try 264
// 导致一个存储异常 264
__finally 264
puts(" 这里也不会被执行到 "); 264
__except(puts("in filter 1"), 0) 265
void main() 265
__try 265
__except(puts("in filter 2"), 1) 265
hello 265
catch exception,error code:888 265
in try 265
in try 265
in filter 1 266
in filter 2 266
in finally 266
in except 2 266
world 266
Press any key to continue 266
继续深入刚才的例子 266
#include "stdio.h" 266
class MyException 266
class A 266
// 注意，这里抛出了一个 MyException 类型的异常对象 267
void f2() {MyException e; throw e;} 267
// 这个函数中使用了 try-catch 处理异常，也即 C 异常处理 267
void test1() 267
A a2,a3; 267
// 这里虽然有 catch 块，但是它捕获不到上面抛出的 C 异常对象 267
catch(int errorcode) 267
void test() 267
int* p = 0x00000000; // pointer to NULL 268
__try 268
// 这里调用 test1 函数 268
// 注意， test1 函数中会抛出一个 C 异常对象 268
__try 268
__finally 268
puts(" 这里也不会被执行到 "); 268
__except(puts("in filter 1"), 0) 268
void main() 269
__try 269
// 这里能捕获到 C 异常对象吗？拭目以待吧！ 269
__except(puts("in filter 2"), 1) 269
hello 269
构造一个 A 对象 269
构造一个 A 对象 269
构造一个 A 对象 269
构造一个 MyException 对象 269
复制一个 MyException 对象 269
in filter 1 269
in filter 2 270
析构一个 MyException 对象 270
析构一个 A 对象 270
析构一个 A 对象 270
析构一个 A 对象 270
in except 2 270
world 270
Press any key to continue 270
C 异常处理模型能捕获 SEH 异常吗？ 271
class MyException 271
class A 271
// 抛出 C 异常 272
void f2() {MyException e; throw e;} 272
void test() 272
int* p = 0x00000000; // pointer to NULL 272
__try 272
__try 272
// 导致一个存储异常 272
// 呵呵，注意这条语句 272
__finally 272
// 呵呵，注意这条语句 273
puts(" 这里也不会被执行到 "); 273
__except(puts("in filter 1"), 0) 273
void test1() 273
A a2,a3; 273
// 这里会产生一个 SEH 类型的系统异常 273
catch(...) 273
printf("catch unknown exception\n"); 274
void main() 274
__try 274
__except(puts("in filter 2"), 0) 274
SEH 与 C 异常模型在混合使用时的“禁区” 274
#include "stdio.h" 274
void main() 275
int* p = 0x00000000; // pointer to NULL 275
// 这里是 SEH 的异常处理语法 275
__try 275
// 这里是 C 的异常处理语法 275
// 导致一个存储异常 275
// 呵呵，注意这条语句 275
catch(...) 275
// 呵呵，注意这条语句 275
puts(" 这里也不会被执行到 "); 275
__except(puts("in filter 1"), 1) 276
class A 276
void main() 276
__try 276
__except(puts("in filter 1"), 1) 277
puts("in except 1"); 277
Compiling... 277
seh-test.cpp 277
Error executing cl.exe. 277
总结 278
第28集 如何把SEH类型的系统异常转化为C 类型的异常？ 278
为什么要 把 SEH 类型的系统异常转化为 C 类型的异常？ 278
如何实现 把 SEH 类型的系统异常转化为 C 类型的异常？ 279
// FILENAME:SEH-test.cpp 280
#include <windows.h> 280
#include <cstdio> 280
using namespace std; 280
m_ContextRecord(*pExp->ContextRecord), 280
~seh_exception_base() throw(){} ; 280
return m_what.c_str(); 280
return m_ExceptionRecord.ExceptionCode; 281
return m_ExceptionRecord; 281
return m_ContextRecord; 281
// 初始化函数 281
_set_se_translator( trans_func ); 281
// 系统异常出现时的回调函数 281
protected: 281
std::string m_what; 281
EXCEPTION_RECORD m_ExceptionRecord; 281
CONTEXT m_ContextRecord; 281
// 下面是系统异常被转换后的 C 类型的异常 281
// 篇幅有限，因此只简单设计了对几种常见的系统异常的转换 282
: seh_exception_base(pExp, what) {}; 282
: seh_exception_base(pExp, what) {}; 282
: seh_exception_base(pExp, what) {}; 283
// 系统异常出现时的回调函数 283
case EXCEPTION_ACCESS_VIOLATION : 283
case EXCEPTION_INT_DIVIDE_BY_ZERO : 283
case EXCEPTION_INVALID_HANDLE : 283
// 来测试吧！ 284
void main( void ) 284
// 被 0 除 284
int x, y=0; 284
// 存储保护 284
// 其它系统异常，例如中断异常 284
//other processing 284
//other processing 284
catch( seh_exception_base& e ) 285
总结 285
第29集 Java语言中的异常处理模型 285
借鉴并引进了 SEH 异常模型中的 try-finally 语法 285
public class Trans 286
public static void main(String[] args) 286
BufferedReader rd=null; 286
Writer wr=null; 286
File srcFile = new File((args[0])); 286
File dstFile = new File((args[1])); 287
while(true) 287
String sLine = rd.readLine(); 287
if(sLine == null) break; 287
wr.write(sLine); 287
wr.write("\r\n"); 287
finally 287
// 这里能保证在何种情况下，文件流的句柄都得以被正确关闭 287
// 该方法主要用于清理非内存性质的资源（垃圾回收机制无法 287
wr.close(); 287
rd.close(); 287
catch(Exception ex) 287
所有的异常都必须从 Throwable 继承而来 288
public class Trans 288
public static void main(String[] args) 288
BufferedReader rd=null; 288
Writer wr=null; 288
File srcFile = new File((args[0])); 289
File dstFile = new File((args[1])); 289
// 编译时，这里将被报错 289
while(true) 289
String sLine = rd.readLine(); 289
if(sLine == null) break; 289
wr.write(sLine); 289
wr.write("\r\n"); 289
finally 289
wr.close(); 289
rd.close(); 289
catch(Exception ex) 289
E:\work\\Trans.java:20: incompatible types 290
found : java.lang.String 290
1 error 290
对异常处理的管理更严格，也更严谨！ 290
public class Trans 291
public static void main(String[] args) 291
BufferedReader rd=null; 291
Writer wr=null; 291
File srcFile = new File((args[0])); 291
File dstFile = new File((args[1])); 291
while(true) 291
String sLine = rd.readLine(); 291
if(sLine == null) break; 291
wr.write(sLine); 291
wr.write("\r\n"); 291
finally 292
wr.close(); 292
rd.close(); 292
catch(IOException ex) 292
1 error 292
throw( CFileException ); 293
// 示例程序 1 ，这种写法能够编译通过 293
public class Trans 293
public static void main(String[] args) 293
test(); 293
catch(Exception ex) 294
static void test() 294
throw new Exception("test"); 294
catch(Exception ex) 294
// 示例程序 2 ，这种写法就不能够编译通过 294
public class Trans 294
public static void main(String[] args) 294
test(); 295
// 虽然这里能够捕获到 Exception 类型的异常 295
catch(Exception ex) 295
static void test() 295
throw new Exception("test"); 295
// 示例程序 3 ，这种写法又能够被编译通过 295
public class Trans 295
public static void main(String[] args) 295
test(); 295
catch(Exception ex) 296
// 由于函数声明了可能抛出 Exception 类型的异常 296
static void test() throws Exception 296
throw new Exception("test"); 296
// 示例程序 4 ，它又不能够被编译通过了 296
public class Trans 296
public static void main(String[] args) 296
// 但是由于它函数声明时，表示它可能抛出一个 Exception 类型的异常 296
// 呵呵！体会到了 Java 异常处理模型的严谨吧！ 296
test(); 296
catch(IOException ex) 297
static void test() throws Exception 297
public class Trans 297
public static void main(String[] args) 297
test(); 297
catch(Exception ex) 297
static void test() throws Error 298
throw new Error(" 故意抛出一个 Error"); 298
特别关注一下 RuntimeException 298
// 示例程序 1 298
// 它不能编译通过，我们可以理解 298
public class Trans 298
public static void main(String[] args) 299
test(); 299
static void test() 299
// 注意这条语句 299
// 示例程序 2 299
public class Trans 299
public static void main(String[] args) 299
test(); 299
static void test() 299
// 注意这条语句 299
Exception in thread "main" 300
public class Trans 300
public static void main(String[] args) 301
test(); 301
static void test() 301
int i = 4; 301
// 运行时，这里将触发了一个 ArithmeticException 301
System.out.println("i / j = " i / j); 301
Exception in thread "main" 301
public class Trans 301
public static void main(String[] args) 301
test(); 302
static void test() 302
String str = null; 302
// 运行时，这里将触发了一个 NullPointerException 302
public class Trans 302
public static void main(String[] args) 302
test(); 302
// 在上层的调用函数中，最好捕获所有的 Exception 异常！ 303
catch(Exception e) 303
System.out.println("go here!"); 303
String str = null; 303
// 运行时，这里将触发了一个 NullPointerException 303
总结 303
第 30 集 Java 异常处理模型之细节分析 304
finally 区域内的代码块在 return 之前被执行 304
public class Trans 305
public static void main(String[] args) 305
// 你认为 test 函数返回的值是多少呢？ 305
public static int test() 305
System.out.println("in try block"); 305
catch(Exception e) 305
System.out.println("in catch block"); 305
finally 306
// 注意，这里重新改变了 ret 的值。 306
return 0; 306
in try block 306
in finally block! 306
test 的返回值为： 1 306
#include "stdio.h" 306
int test() 306
__try 306
printf("in try block\n"); 306
__finally 307
printf("in finally block!\n"); 307
return 0; 307
void main() 307
printf("test 的返回值为： %d\n", test()); 307
强烈建议不要在 finally 内部使用 return 语句 308
// 示例程序 1 ， Java 程序 308
public class Trans 308
public static void main(String[] args) 308
public static int test() 308
System.out.println("in try block"); 308
catch(Exception e) 308
System.out.println("in catch block"); 309
finally 309
// 这里添加了一条 return 语句 309
// 示例程序 2 ， C 程序 309
#include "stdio.h" 309
int test() 309
__try 309
printf("in try block\n"); 309
__finally 309
printf("in finally block!\n"); 310
printf(" 多余的 \n"); 310
return 0; 310
void main() 310
printf("test 的返回值为： %d\n", test()); 310
in try block 310
in finally block! 310
test 的返回值为： 2 310
public class Trans 311
public static void main(String[] args) 311
catch(Exception e) 311
System.out.println("in try block"); 311
catch(RuntimeException e) 311
System.out.println("in catch block"); 311
throw e; 312
finally 312
// 把 return 语句放在最后，这最为妥当 312
另一种更糟糕的情况 312
public class Trans 312
public static void main(String[] args) 312
catch(Exception e) 313
System.out.println("in try block"); 313
// 这里会导致出现一个运行态异常 313
catch(RuntimeException e) 313
System.out.println("in catch block"); 313
// 异常被重新抛出，上层函数可以进一步处理此异常 313
throw e; 313
finally 313
// 注意，这里有一个 return 语句 314
in try block 314
in catch block 314
in finally block! 314
test 的返回值为： 0 314
总结 315
•  finally 区域内的代码总在 return 之前被执行； 315

【实例截图】

【核心代码】

.
└── 好例子网_C 异常处理的编程方法.doc

0 directories, 1 file