C++进阶STL-异常处理

异常抛出是跨函数的

• 返回值：只是返回给调用的这一层函数
• 异常：最里面的函数func1如果抛出异常给 调用的func2 , 如果func2没有处理， 再抛出给调用func2 的 func3, 如果在最上层的还没处理，则程序终止。

栈解旋

• 当函数抛出异常的时候，此函数体内定义的局部变量自动析构、释放。

异常的接口申明

(1)可以抛出 int char float类型的异常,不可以抛其他类型的异常
			Void fun1() throw(int, char, float)
			{

			}

(2)不可以抛出任何异常
			Void fun2() throw()
			{

			}

(3)可以抛出任何异常 
			Void fun2() 
			{

			}
--------------------------------------------------------------------------------------------
(4)异常捕获
			try
			{
				func();
			}
			catch(...)//三个点表示捕获所有异常
			{
				
			}

自定义异常类

   class MyException
   { 
   
           public:
  
                  MyException(const char* err)
                  {
                          error=new char [strlen(err+1)];
                          strcpy(error,err);
  
                  }
                  ~MyException()
                  {
                          if(error!=NULL)
                                  delete [] error;
  
                  }
                  void what()
                  {
                          cout << error <<  endl;
                  }
          private:
                  char* error;
  };
  
  
  int func1(int a,int b )throw(MyException)
  {
         if(b==0)
                  throw MyException("divider is zero") ;
          return a/b;
  }
  
  int main(void)
  {
          try
          {
                  func1(10,0);
  
          }
          catch(MyException& e)
          {
                  e.what();
          }
  
   return 0;
  }

异常类对象的生命周期

1. 抛出是对象，接收也是对象: 所有对象在catch语句处理完析构
2. 抛出对象，用引用接收: 引用直接指向抛出的对象，不用再调用拷贝构造，只有一个对象，它也在catch语句处理完析构
3. 抛出是临时对象地址，接收用指针: 在catch语句之前就析构了，那么在catch语句中就不能调用异常类的方法了。这时候需要在抛出的时候进行 new;在catch 语句处理完再释放。

继承C++标准异常库

1. 重载what 函数
   Virtual Const char * what() const throw()
   {
   }
2. 重载虚析构函数
   virtual ~MyException() throw()
   {
   }