欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

c++中的异常处理

程序员文章站 2022-06-22 10:02:48
异常的基本处理方式、异常的重解释(在 catch 语句块中将捕获到的异常再次抛出)、自定义/标准库异常类的使用(注意:赋值兼容性原则)、异常的另类写法(try...catch...)、异常函数声明的方式(通过 throw 关键字指定可抛出的具体异常类型) ......

 目录

  1、 异常 与 bug 的区别

  4、c++ 标准库中的异常类

 

1、 异常 与 bug 的区别  

  “异常”是我们在程序开发中必须考虑的一些特殊情况,是程序运行时就可预料的执行分支(注:异常是不可避免的,如程序运行时产生除 0 的情况;打开的外部文件不存在;数组访问的越界等等);

  “bug”是程序的缺陷,是程序运行时不被预期的运行方式(注:bug是人为的、可避免的;如使用野指针;堆数组使用结束后未释放等等);

  无论是“异常”还是“bug”,都是程序正常运行过程中可能出现的意外情况。区别是“异常”可以捕获,并做出合适的处理,“bug"所带来的后果是无法预测的,需要重写相应的代码。

2、c++中的异常处理方式(try ... catch ...)

 (1)基本语法

1 // 异常基本语法
2 try
3 {
4     // 可能产生异常的代码,若发生异常,通过 throw 关键字抛出异常
5 }
6 catch(异常类型) // 异常捕获,注(...)代表捕获所有异常
7 {
8     // 处理异常的代码,该异常由try语句块产生
9 }

 (2)基本规则 

  1)同一个 try 语句可以跟上多个 catch 语句(在工程中,将可能产生异常的代码放在 try 语句块中,然后后面跟上多个 catch 语句);

  2)try 语句中通过 throw 关键字 可以抛出任何类型的异常(int、字符串、对象等等); 

  3)catch 语句可以定义具体处理的异常类型,如 catch( int ) 只捕获 int 类型异常, 但无法进一步获取异常信息;catch( int a ) 只捕获 int 类型异常,可以进一步获取异常信息;

  4)不同类型的异常由不同的 catch 语句负责处理;

  5)catch(...) 用于处理所有类型的异常(只能放在所有 catch语句 的后面);

  6)任何异常都只能被捕获(catch)一次;

  7)只要被 catch 捕获一次,其它的 catch 就没有捕获机会了;

  8)throw 抛出异常的类型 与 catch 捕获异常的类型  必须严格匹配(不能进行类型转换);若匹配成功,则能够捕获该异常;否则捕获失败,程序停止执行。

    c++中的异常处理

  其实,为了更好的理解 异常抛出 和 异常捕获 这两个动作,我们可以将其想象成 函数调用,抛出异常好比是函数中实参,捕获异常好比是函数中形参,只有当实参的类型 与 形参的类型严格匹配时,这次捕获才能成功。为什么说想象成函数调用,而不是正真的函数调用呢?原因就是:函数调用时,用实参初始化形参时可以进行隐式的类型转换;但是在异常捕获时,必须严格匹配异常类型。  

(3)异常抛出(throw exception)的逻辑分析

  情况1:异常代码没有放到  try{ }  语句中,这也意味着没有对应的 catch 语句,其实就是普通函数调用,若此时抛出异常(throw),则程序停止执行;

  情况2:异常代码放到  try{ throw exception... }  语句中,这也意味着有对应的 catch 语句,则抛出异常时就会与 catch语句严格匹配;若匹配成功,则可以捕获该异常,否则不能捕获该异常,程序停止执行。

  throw 抛出异常后,在发生异常的函数中至上而下的严格匹配每一个 catch 语句捕获的异常类型,来判断是否能够捕获该异常;

   1) 若发生异常的函数中  能够捕获该异常,则程序接着往下执行;

   2) 若发生异常的函数中  不能捕获该异常,则未被处理的异常会顺着函数调用栈向上传播,直到该异常被捕获为止,否则程序将停止执行;

  总结:throw 抛出的异常必须被 对应的 catch 捕获,否则程序将停止执行;

    c++中的异常处理

  通过上图来说明异常抛出后的执行顺序:

  1)在 函数 function3 中 抛出异常 throw 1;但是在 function3 中并不能捕获该异常,则异常继续向外层函数 function2 抛出

  2)在 函数 function2 中,异常依旧没有被捕获,则异常继续向外层函数 function1 抛出;

  3)在 函数 function1 中,异常被 catch 捕获和处理,然后程序继续向下执行;

    注:若在 函数 function1 中,异常还是没有被捕获,则异常会一直向外层函数抛出,直到该异常被捕获为止,否在程序停止执行。 

  代码展示:

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 double divide(double a, double b)
 7 {
 8     const double delta = 0.000000001;
 9     double ret = 0;
10 
11     if( !((-delta < b) && (b < delta)) )
12     {
13         ret = a / b;
14     }
15     else
16     {
17         throw "divided by zero..."; 
18     }
19 
20     cout << "divide(double a, double b)" << endl;
21      
22     return ret;
23 }
24 
25 double exceptionfunc()
26 {
27     double d = divide(2, 0);
28     
29     cout << "exceptionfunc()" << endl;
30     
31     return d;
32 }
33 
34 int main(int argc, char *argv[])
35 {      
36     double d = exceptionfunc();
37     
38     cout << "result = " << d << endl;
39 
40     return 0;
41 }
42 
43 /**
44  * 运行结果:
45  * terminate called after throwing an instance of 'char const*'
46  * aborted (core dumped)
47  */
48  
49 /**
50  * 分析:
51  * throw "divided by zero..."; 抛出异常后,divide(double a, double b) 函数不能捕获该异常,则异常继续抛给 exceptionfunc();
52  * 在 exceptionfunc() 中,也不能捕获该异常,则异常继续抛给 main();
53  * 在 main()中,也不能捕获该异常,则程序停止执行。
54  */

  

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 double divide(double a, double b)
 7 {
 8     const double delta = 0.000000001;
 9     double ret = 0;
10     
11     try
12     {
13         if( !((-delta < b) && (b < delta)) )
14         {
15             ret = a / b;
16         }
17         else
18         {
19             throw "divided by zero..."; 
20         }
21     }
22     catch(char const* s)  
23     {
24         cout << s << endl;
25     } 
26         
27     cout << "divide(double a, double b)" << endl;
28  
29     return ret;
30 }
31 
32 double exceptionfunc()
33 {   
34     double d = divide(2, 0);
35     
36     cout << "exceptionfunc()" << endl;
37     
38     return d;
39 }
40 
41 int main(int argc, char *argv[])
42 { 
43     exceptionfunc();
44       
45     cout << "test end!" << endl;
46 
47     return 0;
48 }
49 
50 /**
51  * 运行结果:
52  * divided by zero...
53  * divide(double a, double b)
54  * exceptionfunc()
55  * test end!
56  */
57  
58 /**
59  * 分析:
60  * throw "divided by zero..."; 抛出异常后,在divide(double a, double b) 中,异常被捕获,则程序继续向下执行;
61  *  catch(char const* s)    // throw "divided by zero..."
62  *  {
63  *     cout << s << endl;
64  *  }   
65  *  cout << "divide(double a, double b)" << endl;
66  *
67  *  divide(2, 0); 函数调用结束,返回到 exceptionfunc() 中,
68  *  cout << "exceptionfunc()" << endl;  
69  *   
70  *  exceptionfunc()调用结束,返回 main()中,继续向下执行;
71  *  cout << "test end!" << endl;
72  */

 

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 double divide(double a, double b)
 7 {
 8     const double delta = 0.000000001;
 9     double ret = 0;
10           
11     if( !((-delta < b) && (b < delta)) )
12     {
13         ret = a / b;
14     }
15     else
16     {
17         throw "divided by zero..."; 
18     }
19 
20     cout << "divide(double a, double b)" << endl;
21 
22     return ret;
23 }
24 
25 double exceptionfunc()
26 {
27     double d;
28     
29     try
30     {
31         d = divide(2, 0);
32             
33         cout << "d = " << d << endl;
34     }
35     catch(char const* s)
36     {
37         cout << s << endl;
38     }           
39     
40     cout << "exceptionfunc()" << endl;
41     
42     return d;
43 }
44 
45 int main(int argc, char *argv[])
46 { 
47     exceptionfunc();
48     
49     cout << "test end!" << endl;
50 
51     return 0;
52 }
53 
54 /**
55  * 运行结果:
56  * divided by zero...
57  * exceptionfunc()
58  * test end!
59  */
60  
61 /**
62  * 分析:
63  * throw "divided by zero..."; 抛出异常后,divide(double a, double b) 函数不能捕获该异常,则异常继续抛给 exceptionfunc();
64  * 在 exceptionfunc() 中,异常被捕获,则程序继续向下执行;
65  *  catch(char const* s)    // throw "divided by zero..."
66  *  {
67  *     cout << s << endl;
68  *  }   
69  *  cout << "exceptionfunc()" << endl;     
70  *  exceptionfunc()调用结束,返回 main()中,继续向下执行;
71  *  cout << "test end!" << endl;
72  */

 

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 double divide(double a, double b)
 7 {
 8     const double delta = 0.000000001;
 9     double ret = 0;
10 
11     if( !((-delta < b) && (b < delta)) )
12     {
13         ret = a / b;
14     }
15     else
16     {
17         throw "divided by zero..."; 
18     }
19  
20     cout << "divide(double a, double b)" << endl;
21 
22     return ret;
23 }
24 
25 double exceptionfunc()
26 {
27     double d = divide(2, 0);
28     
29     cout << "exceptionfunc()" << endl;
30     
31     return d;
32 }
33 
34 int main(int argc, char *argv[])
35 { 
36     try
37     {
38         double d = exceptionfunc();
39             
40         cout << "d = " << d << endl;
41     }
42     catch(char const* s)
43     {
44         cout << s << endl;
45     }        
46     
47     cout << "test end!" << endl;
48 
49     return 0;
50 }
51 
52 /**
53  * 运行结果:
54  * divided by zero...
55  * test end!
56  */
57  
58 /**
59  * 分析:
60  * throw "divided by zero..."; 抛出异常后,divide(double a, double b) 函数不能捕获该异常,则异常继续抛给 exceptionfunc();
61  * 在 exceptionfunc() 中,也不能捕获该异常,则异常继续抛给 main();
62  * 在 main()中,异常与被捕获,则程序继续向下执行
63  *  catch(char const* s)    // throw "divided by zero..."
64  *  {
65  *     cout << s << endl;
66  *  }   
67  *  cout << "test end!" << endl;     
68  */

 

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 void demo1()
 7 {
 8     try
 9     {   
10         throw 2.0;
11     }
12     catch(char c)
13     {
14         cout << "catch(char c)" << endl;
15     }
16     catch(short c)
17     {
18         cout << "catch(short c)" << endl;
19     }
20     catch(double c)   // throw 2.0;
21     {
22         cout << "catch(double c)" << endl;
23     }
24     catch(...)   // 表示捕获任意类型的异常
25     {
26         cout << "catch(...)" << endl;
27     }   
28 }
29 
30 void demo2()
31 {
32     throw string("d.t.software"); 
33 }
34 
35 int main(int argc, char *argv[])
36 {    
37     demo1();
38     
39     try
40     {
41         demo2();      
42     }
43     catch(char* s)
44     {
45         cout << "catch(char *s)" << endl;
46     }
47     catch(const char* cs)
48     {
49         cout << "catch(const char *cs)" << endl;
50     }
51     catch(string ss)    // throw string("d.t.software"); 
52     {
53         cout << "catch(string ss)" << endl;
54     }  
55     
56     return 0;
57 }
58 /**
59  * 运行结果:
60  * catch(double c)
61  * catch(string ss)
62  */
63 
64 // 结论:异常类型严格匹配,(...)表示捕获任意类型的异常

   总结:

  情况1:只抛出异常,没有对应地异常捕获;(  没有 try ... catch ... 结构  )

  情况2:在try语句块中抛出异常(直接在try语句块中使用 throw 抛出异常;或者try语句块中放入有异常的函数,间接地在函数中使用 throw 抛出异常),然后通过catch语句捕获同类型的异常并进行异常处理;( 现象: 一个 try ... catch ... 结构 )

  那么现在我们考虑能不能在情况2的基础上,将捕获到异常继续抛出呢?(在 catch 语句块中重新抛出异常?)

  可以在 catch 语句中重新抛出异常,此时需要外层的 try ... catch ...捕获这个异常;

  注:catch 语句中只抛出异常,什么也不做;当捕获任意类型的异常时,直接使用 throw 就行。

  c++中的异常处理

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 void demo()
 7 {
 8     try
 9     {
10         throw 'c';
11     }
12     catch(int i)
13     {
14         cout << "inner: catch(int i)" << endl;
15         throw i;
16     }
17     catch(...)
18     {
19         cout << "inner: catch(...)" << endl;
20         throw;
21     }
22 }
23 
24 int main(int argc, char *argv[])
25 {
26     demo();
27     
28     return 0;
29 }
30 
31 /**
32  * 运行结果:
33  * inner: catch(...)
34  * terminate called after throwing an instance of 'char'
35  * aborted (core dumped)
36  */
37  // 错误原因:异常重解释之后,没有被捕获

 

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 void demo()
 7 {
 8     try
 9     {
10         try
11         {
12             throw 'c';
13         }
14         catch(int i)
15         {
16             cout << "inner: catch(int i)" << endl;
17             throw i;
18         }
19         catch(...)
20         {
21             cout << "inner: catch(...)" << endl;
22             throw;
23         }
24     }
25     catch(...)
26     {
27         cout << "outer: catch(...)" << endl;
28     }
29 }
30 
31 int main(int argc, char *argv[])
32 {
33     demo();
34     
35     return 0;
36 }
37 /**
38  * 运行结果:
39  * inner: catch(...)
40  * outer: catch(...)
41  */

   为什么要在 catch 语句块中重新抛出异常?

  在工程中,利用在 catch 语句块中重新解释异常并抛出这一特性,可以统一异常类型。(很晦涩,看下面解释....)

  c++中的异常处理

  我们通过上图来详细说明这个情况:

  背景介绍:出于开发效率考虑,在工程开发中一般会基于第三方库来开发,但是,第三方库中的某些功能并不完善(可读性差),此时就需要封装第三方库中的这个功能。

  在上图中,由于第三方库中 func()函数的异常类型是 int 类型,可读性很差,不能够直接通过异常结果知道该异常所代表的意思;基于这种情况,我们通过私有库中的 myfunc()函数对第三方库中func()进行了封装,使得 myfunc()函数中的异常类型可以显示更多的异常信息(myfunc() 函数中的异常类型是自定义类型,可以是字符串、类类型等等),增强代码的可读性;为了将 func()中的异常类型 和 myfunc() 中异常类型统一起来,我们可以在私有库中的myfunc() 函数中去捕获第三方库中的 func() 函数抛出的异常,然后根据捕获到的异常重新解释为我们想要的异常,这样我们工程开发中所面对的异常类型就是一致的;接下来我们用代码复现这个场景:

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 /*
 7     假设:当前的函数是第三方库中的函数,因此,我们无法修改源代码
 8     
 9     函数名: void func(int i)
10     抛出异常的类型: int
11                         -1 ==》 参数异常
12                         -2 ==》 运行异常
13                         -3 ==》 超时异常
14 */
15 void func(int i)
16 {
17     if( i < 0 )
18     {
19         throw -1;
20     }
21     
22     if( i > 100 )
23     {
24         throw -2;
25     }
26     
27     if( i == 11 )
28     {
29         throw -3;
30     }
31     
32     cout << "run func..." << endl;
33 }
34 
35 int main(int argc, char *argv[])
36 {
37     try
38     {
39         func(11);
40     }
41     catch(int i)
42     {
43         cout << "exception info: " << i << endl;
44     }
45     
46     return 0;
47 }
48 
49 /**
50  * 运行结果:
51  * exception info: -3
52  */
53  
54 // 异常显示结果太简单,当发生异常时,需要查询技术文档才能知道这儿的-3代表的意思,可读性很差

 

// 异常的重解释,在 catch 语句中重新抛出异常

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 /*
 7     假设: 当前的函数式第三方库中的函数,因此,我们无法修改源代码
 8     
 9     函数名: void func(int i)
10     抛出异常的类型: int
11                         -1 ==》 参数异常
12                         -2 ==》 运行异常
13                         -3 ==》 超时异常
14 */
15 void func(int i)
16 {
17     if( i < 0 )
18     {
19         throw -1;
20     }
21     
22     if( i > 100 )
23     {
24         throw -2;
25     }
26     
27     if( i == 11 )
28     {
29         throw -3;
30     }
31     
32     cout << "run func..." << endl;
33 }
34 
35 /* 不能修改 func() 函数,则我们定义 myfunc() 函数重解释 func() 的异常 */
36 void myfunc(int i)
37 {
38     try
39     {
40         func(i);
41     }
42     catch(int i)
43     {
44         switch(i)
45         {
46             case -1:
47                 throw "invalid parameter";   // 可以抛出更详细的数据,如类对象,后续讲解
48                 break;
49             case -2:
50                 throw "runtime exception";
51                 break;
52             case -3:
53                 throw "timeout exception";
54                 break;
55         }
56     }
57 }
58 
59 int main(int argc, char *argv[])
60 {
61     try
62     {
63         myfunc(11);
64     }
65     catch(const char* cs)
66     {
67         cout << "exception info: " << cs << endl;
68     }
69     
70     return 0;
71 }
72 /**
73  * 运行结果:
74  * exception info: timeout exception
75  */

 

 3、自定义异常类的使用方式

  (1)异常的类型可以是自定义类类型;

  (2)对于类类型异常的匹配依旧是自上而下严格匹配;

  (3)赋值兼容性原则在异常匹配中依然适用;(注:在赋值兼容性中,子类是特殊的父类,父类可以捕获子类的异常;同样满足异常类型严格匹配的原则)

    (4)在赋值兼容性原则中,一般将

    1)匹配子类异常的 catch 放在上部;

    2)匹配父类异常的 catch 放在下部;

  (5)在定义 catch 语句块时,推荐使用 const 引用作为参数,提高程序的运行效率;

  1 #include <iostream>
  2 #include <string>
  3 
  4 using namespace std;
  5 
  6 class base
  7 {
  8 };
  9 
 10 /* 定义异常类 */
 11 class exception : public base
 12 {
 13     int m_id;
 14     string m_desc;
 15 public:
 16     exception(int id, string desc)
 17     {
 18         m_id = id;
 19         m_desc = desc;
 20     }
 21     
 22     int id() const
 23     {
 24         return m_id;
 25     }
 26     
 27     string description() const
 28     {
 29         return m_desc;
 30     }
 31 };
 32 
 33 /*
 34     假设: 当前的函数式第三方库中的函数,因此,我们无法修改源代码
 35     函数名: void func(int i)
 36     抛出异常的类型: int
 37                         -1 ==》 参数异常
 38                         -2 ==》 运行异常
 39                         -3 ==》 超时异常
 40 */
 41 
 42 void func(int i)
 43 {
 44     if( i < 0 )
 45     {
 46         throw -1;
 47     }
 48     
 49     if( i > 100 )
 50     {
 51         throw -2;
 52     }
 53     
 54     if( i == 11 )
 55     {
 56         throw -3;
 57     }
 58     
 59     cout << "run func..." << endl;
 60 }
 61 
 62 /* 使用自定义的类类型来优化 */
 63 void myfunc(int i)
 64 {
 65     try
 66     {
 67         func(i);
 68     }
 69     catch(int i)
 70     {
 71         switch(i)
 72         {
 73             case -1:
 74                 throw exception(-1, "invalid parameter");  // 直接调用构造函数生成异常对象;
 75                 break;
 76             case -2:
 77                 throw exception(-2, "runtime exception");
 78                 break;
 79             case -3:
 80                 throw exception(-3, "timeout exception");
 81                 break;
 82         }
 83     }
 84 }
 85 
 86 int main(int argc, char *argv[])
 87 {
 88     try
 89     {
 90         myfunc(11);
 91     }
 92     catch(const exception& e)  // 1 使用 const 引用类型作为参数  2 赋值兼容性原则(参考第4点)
 93     {
 94         cout << "exception info: " << endl;
 95         cout << "   id: " << e.id() << endl;
 96         cout << "   description: " << e.description() << endl;
 97     }
 98     catch(const base& e) 
 99     {
100         cout << "catch(const base& e)" << endl;
101     }
102     
103     return 0;
104 }
105 /**
106  * 运行结果:
107  * exception info:
108  * id: -3
109  * description: timeout exception
110  */

 

4、c++ 标准库中的异常类

  (1)c++ 标准库中提供了实用异常类族;

  (2)标准库中的异常都是从 exception 类派生的;

  (3)exception 类有两个主要的分支:

    1)logic_error

         2)runtime_error

     (4)标准库中的异常类继承图:

    c++中的异常处理

 1 #include <iostream>
 2 #include <string>
 3 #include <stdexcept> 
 4 #include <sstream>
 5 
 6 using namespace std;
 7 
 8 /*
 9     __file__  __function__  const char[]
10     __line__  int
11 */
12 
13 template
14 <typename t, int n>
15 class array
16 {
17 private:
18     t arr[n];
19 public:
20     array();
21     t& operator[] (int index);
22     void print() const;
23 };
24 
25 template
26 <typename t, int n>
27 array<t, n>::array()
28 {
29     for(int i = 0; i < n; i++)
30     {
31         arr[i] = 0;
32     }
33 }
34 
35 template
36 <typename t, int n>
37 t& array<t, n>::operator[] (int index)
38 {
39     if( (0 <= index) && (index < n) )
40     {
41         return arr[index];
42     }
43     else
44     {
45         ostringstream oss;
46         
47         throw out_of_range(string(__file__) + ":" + static_cast<ostringstream&>(oss << __line__).str() + ":" + __function__\
48 
49                         + "\t >> exception: the index of array is out of range");  
50     }
51 }
52 
53 template
54 <typename t, int n>
55 
56 void array<t, n>::print() const
57 {
58     for(int i = 0; i < n; i++)
59     {
60         cout << arr[i] << " ";
61     }
62     cout << endl;
63 }
64 
65 int main(int argc, char *argv[])
66 {
67     try
68     {
69         array<int, 5> arr;
70 
71         arr.print();
72         arr[-1] = 1;    // 异常测试
73         arr.print();
74     }
75 
76     catch(const out_of_range& e)  // 1 使用 const 引用类型作为参数  2 赋值兼容性原则(参考第4点)
77     {
78         cout << e.what() << endl;
79     }
80 
81     catch(...)
82     {
83         cout << "other exception ... " << endl;
84     }
85 
86     return 0;
87 }
88 
89 /**
90  * 运行结果:
91  * 0 0 0 0 0
92  * test.cpp:47:operator[]     >> exception: the index of array is out of range
93  */

 

  1 // 模板文件 array.hpp 的优化
  2 #ifndef array_h
  3 #define array_h
  4 
  5 #include <stdexcept>  // 标准库中的异常类头文件;
  6 
  7 using namespace std;a
  8 
  9 template
 10 < typename t, int n >
 11 class array
 12 {
 13     t m_array[n];
 14 public:
 15     int length() const;
 16     bool set(int index, t value);
 17     bool get(int index, t& value);
 18     t& operator[] (int index);
 19     t operator[] (int index) const;
 20     virtual ~array();
 21 };
 22 
 23 template
 24 < typename t, int n >
 25 int array<t, n>::length() const
 26 {
 27     return n;
 28 }
 29 
 30 template
 31 < typename t, int n >
 32 bool array<t, n>::set(int index, t value)
 33 {
 34     bool ret = (0 <= index) && (index < n);
 35     
 36     if( ret )
 37     {
 38         m_array[index] = value;
 39     }
 40     
 41     return ret;
 42 }
 43 
 44 template
 45 < typename t, int n >
 46 bool array<t, n>::get(int index, t& value)
 47 {
 48     bool ret = (0 <= index) && (index < n);
 49     
 50     if( ret )
 51     {
 52         value = m_array[index];
 53     }
 54     
 55     return ret;
 56 }
 57 
 58 template
 59 < typename t, int n >
 60 t& array<t, n>::operator[] (int index)
 61 {
 62     if( (0 <= index) && (index < n) )
 63     {
 64         return m_array[index];  // 这里之前没有验证 index 是否合法,因为验证了也没办法处理;
 65     }
 66     else
 67     {
 68         throw out_of_range("t& array<t, n>::operator[] (int index)");
 69     }
 70 }
 71 
 72 template
 73 < typename t, int n >
 74 t array<t, n>::operator[] (int index) const
 75 {
 76     if( (0 <= index) && (index < n) )
 77     {
 78         return m_array[index];  // 这里之前没有验证 index 是否合法,因为验证了也没办法处理;
 79     }
 80     else
 81     {
 82         throw out_of_range("t array<t, n>::operator[] (int index) const");
 83     }
 84 }
 85 
 86 template
 87 < typename t, int n >
 88 array<t, n>::~array()
 89 {
 90 
 91 }
 92 
 93 #endif
 94 
 95 //------------------------------------------------------------------
 96 
 97 // 模板文件 heaparray.hpp 的优化
 98 
 99 #ifndef heaparray_h
100 #define heaparray_h
101 
102 #include <stdexcept>  // 添加标准头文件;
103 
104 using namespace std;
105 
106 template
107 < typename t >
108 class heaparray
109 {
110 private:
111     int m_length;
112     t* m_pointer;
113     
114     heaparray(int len);
115     heaparray(const heaparray<t>& obj);
116     bool construct();
117 public:
118     static heaparray<t>* newinstance(int length); 
119     int length() const;
120     bool get(int index, t& value);
121     bool set(int index ,t value);
122     t& operator [] (int index);
123     t operator [] (int index) const;
124     heaparray<t>& self();
125     const heaparray<t>& self() const;  // 要考虑成员函数有没有必要成为 const 函数,const 函数主要是给 cosnt 对象调用;
126     ~heaparray();
127 };
128 
129 template
130 < typename t >
131 heaparray<t>::heaparray(int len)
132 {
133     m_length = len;
134 }
135 
136 template
137 < typename t >
138 bool heaparray<t>::construct()
139 {   
140     m_pointer = new t[m_length];
141     
142     return m_pointer != null;
143 }
144 
145 template
146 < typename t >
147 heaparray<t>* heaparray<t>::newinstance(int length) 
148 {
149     heaparray<t>* ret = new heaparray<t>(length);
150     
151     if( !(ret && ret->construct()) ) 
152     {
153         delete ret;
154         ret = 0;
155     }
156         
157     return ret;
158 }
159 
160 template
161 < typename t >
162 int heaparray<t>::length() const
163 {
164     return m_length;
165 }
166 
167 template
168 < typename t >
169 bool heaparray<t>::get(int index, t& value)
170 {
171     bool ret = (0 <= index) && (index < length());
172     
173     if( ret )
174     {
175         value = m_pointer[index];
176     }
177     
178     return ret;
179 }
180 
181 template
182 < typename t >
183 bool heaparray<t>::set(int index, t value)
184 {
185     bool ret = (0 <= index) && (index < length());
186     
187     if( ret )
188     {
189         m_pointer[index] = value;
190     }
191     
192     return ret;
193 }
194 
195 template
196 < typename t >
197 t& heaparray<t>::operator [] (int index)
198 {
199     if( (0 <= index) && (index < length()) )
200     {
201         return m_pointer[index];  // 优化这里,越界抛异常;
202     }
203     else
204     {
205         throw out_of_range("t& heaparray<t>::operator [] (int index)");
206     }
207 }
208 
209 template
210 < typename t >
211 t heaparray<t>::operator [] (int index) const
212 {
213     if( (0 <= index) && (index < length()) )
214     {
215         return m_pointer[index];  // 优化这里,越界抛异常;
216     }
217     else
218     {
219         throw out_of_range("t heaparray<t>::operator [] (int index) const");
220     }
221 }
222 
223 template
224 < typename t >
225 heaparray<t>& heaparray<t>::self()
226 {
227     return *this;
228 }
229 
230 template
231 < typename t >
232 const heaparray<t>& heaparray<t>::self() const
233 {
234     return *this;
235 }
236 
237 template
238 < typename t >
239 heaparray<t>::~heaparray()
240 {
241     delete[]m_pointer;
242 }
243 
244 #endif
245 
246 //------------------------------------------------------------------
247 
248 // 测试文件 main.cpp 
249 
250 #include <iostream>
251 #include <string>
252 #include <memory>  //for auto_ptr
253 #include "array.hpp"
254 #include "heaparray.hpp"
255 
256 using namespace std;
257 
258 void testarray()
259 {
260     array<int, 5> a;
261     
262     for(int i=0; i<a.length(); i++)
263     {
264         a[i] = i;   
265     }
266     
267     for (int i=0; i<a.length(); i++)
268     {
269         cout << a[i] << ", ";
270     }
271     cout << endl;
272 }
273 
274 void testheaparray()
275 {
276     //使用智能指针,目的是自动释放堆空间
277     auto_ptr< heaparray<double> > pa(heaparray<double>::newinstance(5));
278     
279     if(pa.get() != null)
280     {
281         heaparray<double>& array = pa->self();
282         
283         for(int i=0; i<array.length(); i++)
284         {
285             array[i] = i;
286         }
287         
288         for (int i=0; i<array.length(); i++)
289         {
290              cout << array[i] << ", ";
291         }
292         cout << endl;         
293     }         
294 }
295 
296 int main(int argc, char *argv[])
297 {
298     try
299     {
300         testarray();
301 
302         cout << endl;     
303 
304         testheaparray();
305     }
306     catch(const out_of_range& e)
307     {
308         cout << "exception: " << e.what() << endl;
309     }
310     catch(...)
311     {
312         cout << "other exception ... " << endl;
313     }   
314 
315     return 0;
316 }
317 
318 /**
319  * 运新结果:
320  * 0, 1, 2, 3, 4, 
321  * ---------------------
322  * 0, 1, 2, 3, 4, 
323  * run end...
324  */
325 
326 /**
327  * 栈空间数组下标越界异常运行结果:
328  * exception: t& array<t, n>::operator[] (int index)
329  * run end...
330  */
331 
332 /**
333  * 堆空间数组下标越界异常运行结果:
334  * 0, 1, 2, 3, 4, 
335  * ---------------------
336  * exception: t& heaparray<t>::operator [] (int index)
337  * run end...
338  */

 

5、try..catch 另类写法 和  函数异常声明/定义 throw()

   try..catch 另类写法(不建议使用)的特点:

  (1)try-catch用于分隔正常功能代码与异常处理代码

  (2)try-catch可以直接将函数实现分隔为2部分

  函数异常声明/定义的特点:

  (1)函数声明和定义时可以直接指定可能抛出的异常类型;

  (2)异常声明成为函数的一部分,可以提高代码可读性;

  (3)函数异常声明是一种与编译器之间的契约;

  (4)函数声明异常后就只能抛出声明的异常;

    a、抛出其它异常将导致程序运行终止;

    b、可以直接通过异常声明定义无异常函数;

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 // int func(int i, int j) throw()  // 无异常函数声明
 7 
 8 int func(int i, int j) throw(int, char)  //异常声明,表示该函数可能抛出int和char两种类型的异常
 9 {
10     if ((0 < j) && (j < 10))
11     {
12         return (i + j);
13     } 
14     else
15     {
16         throw 'c'; // 只能抛出指定的异常类型(int、char),否则程序运行失败
17     }
18 }
19 
20 //以下的写法已经不被推荐  !!!
21 void test(int i) try   //正常代码
22 {
23     cout << "func(i, i) = " << func(i, i) << endl;
24 }
25 catch (int j)   //异常代码
26 {
27     cout << "exception: " << j << endl;
28 }
29 catch (char j)   //异常代码
30 {
31     cout << "exception: " << j << endl;
32 }
33 
34 int main(int argc, char *argv[])
35 {
36     test(5); //正常
37 
38     test(10); //抛异常
39 
40     return 0;
41 }
42 /**
43  * 运行结果:
44  * func(i, i) = 10
45  * exception: c
46  */