C++ Exercises（二十）

1，来看下面这段代码：

 
 #include <iostream>         
      
 using namespace std;         
          
 class BaseClass         
      
 {         
      
 public:         
      
     BaseClass()         
      
     {         
          
     }         
      
 };         
      
 class MyClass : public BaseClass         
      
 {         
      
 private:         
      
     char *ptr;         
      
 public:         
      
     MyClass();         
      
 };         
          
 MyClass::MyClass():BaseClass(), ptr(new char[10])         
      
 {         
          
 }         
          
 int main()         
      
 {         
      
     MyClass c1;         
      
     return 0;         
      
 }        
     
    

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

 
 MyClass::MyClass() : BaseClass()         
      
 {         
      
     try        
      
     {         
      
         ptr = new char[10];         
      
     }         
      
     catch (const bad_alloc& ex)         
      
     {         
      
     }         
      
 }        
     
    

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

 
 #include <iostream>         
      
 using namespace std;         
          
 class BaseClass         
      
 {         
      
 public:         
      
     BaseClass()         
      
     {         
          
     }         
      
 };         
      
 class MyClass : public BaseClass         
      
 {         
      
 private:         
      
     char *ptr;         
      
 public:         
      
     MyClass();         
      
 };         
          
 MyClass::MyClass()         
      
 try : BaseClass(), ptr(new char[10])         
      
 {         
      
     cout << "构造函数中" << endl;         
      
     throw "error";         
      
 }         
      
 catch(const string& ex)         
      
 {         
      
     cout << "异常处理中" << endl;         
      
 }         
          
 int main()         
      
 {         
      
     MyClass c1;         
      
     return 0;         
      
 }        
     
    

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

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

 
 int sum = 0;         
      
 int x;         
      
 while (cin >> x)         
      
 {         
      
     sum += x;         
      
 }        
     
    

 
 int sum = 0;         
      
 for (int x; cin >> x;)         
      
 {         
      
     sum += x;         
      
 }