1,来看下面这段代码:

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. class BaseClass  
  5. {  
  6. public:  
  7.     BaseClass()  
  8.     {  
  9.  
  10.     }  
  11. };  
  12. class MyClass : public BaseClass  
  13. {  
  14. private:  
  15.     char *ptr;  
  16. public:  
  17.     MyClass();  
  18. };  
  19.  
  20. MyClass::MyClass():BaseClass(), ptr(new char[10])  
  21. {  
  22.  
  23. }  
  24.  
  25. int main()  
  26. {  
  27.     MyClass c1;  
  28.     return 0;  

   假设在MyClass的构造函数中需要处理内存分配错误,也就是new char[10]出错,它会抛出std::bad_alloc异常,那么应该怎么捕获它呢?想必也只能将其移到构造函数体内:

  1. MyClass::MyClass() : BaseClass()  
  2. {  
  3.     try 
  4.     {  
  5.         ptr = new char[10];  
  6.     }  
  7.     catch (const bad_alloc& ex)  
  8.     {  
  9.     }  

    如果BaseClass的构造函数也抛出异常的话,这样还是有问题的。这就是引入function-try-block的原因,通过它我们可以将try/catch的处理代码放在构造函数中初始化列表的周围,也就能够捕获由基类或成员变量构造函数抛出的任何异常了。

 

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. class BaseClass  
  5. {  
  6. public:  
  7.     BaseClass()  
  8.     {  
  9.  
  10.     }  
  11. };  
  12. class MyClass : public BaseClass  
  13. {  
  14. private:  
  15.     char *ptr;  
  16. public:  
  17.     MyClass();  
  18. };  
  19.  
  20. MyClass::MyClass()  
  21. try : BaseClass(), ptr(new char[10])  
  22. {  
  23.     cout << "构造函数中" << endl;  
  24.     throw "error";  
  25. }  
  26. catch(const string& ex)  
  27. {  
  28.     cout << "异常处理中" << endl;  
  29. }  
  30.  
  31. int main()  
  32. {  
  33.     MyClass c1;  
  34.     return 0;  

   C++标准规定在构造函数和析构函数中,如果执行到达处理程序的末尾,在function-try-block的处理程序中捕获的异常必须重新抛出。也就意味着上述代码在运行时,会由于有未处理的异常而终止。

      为什么说标准这样规定是必要的呢?因为在捕获一个异常时,对象可能处于无效状态,因此不能允许构造函数成功地完成,否则构造出的对象是不能确保其有效性的。

2,数的累加求和这段代码我们一直都这样写:

  1. int sum = 0;  
  2. int x;  
  3. while (cin >> x)  
  4. {  
  5.     sum += x;  

而可曾想过下面这样的写法更为优雅呢?

  1. int sum = 0;  
  2. for (int x; cin >> x;)  
  3. {  
  4.     sum += x;