void OpenFile(string f)
{
 try
　　{
 　　// 打開文件的操作，可能拋出FileOpenException
　　}
　　catch(FileOpenException& fe)
　　{
 　　// 處理這個(gè)異常，如果這個(gè)異?？梢院芎玫牡靡曰謴?fù)，那么處理完畢后函數(shù)
 　　// 正常返回；否則必須重新拋出這個(gè)異常，以供上層的調(diào)用函數(shù)來能再次處
 　　 // 理這個(gè)異常對象
 　　int result = ReOpenFile(f);
 　　if (result == false) throw;
　　}
}

void ReadFile(File f)
{
　　try
　　{
 　　// 從文件中讀數(shù)據(jù)，可能拋出FileReadException
　　}
　　catch(FileReadException& fe)
　　{
 　　// 處理這個(gè)異常，如果這個(gè)異?？梢院芎玫牡靡曰謴?fù)，那么處理完畢后函數(shù)
 　　// 正常返回；否則必須重新拋出這個(gè)異常，以供上層的調(diào)用函數(shù)來能再次處
 　　// 理這個(gè)異常對象
 　　int result = ReReadFile(f);
 　　if (result == false) throw;
　　}
}

void WriteFile(File f)
{
　　try
　　{
 　　// 往文件中寫數(shù)據(jù)，可能拋出FileWriteException
　　}
　　catch(FileWriteException& fe)
　　{
 　　// 處理這個(gè)異常，如果這個(gè)異常可以很好的得以恢復(fù)，那么處理完畢后函數(shù)
 　　// 正常返回；否則必須重新拋出這個(gè)異常，以供上層的調(diào)用函數(shù)來能再次處理這個(gè)異常對象
　　　　int result = ReWriteFile(f);
 　　if (result == false) throw; 
　　} 
}

void Func()
{
　　try
　　{
 　　// 對文件進(jìn)行操作，可能出現(xiàn)FileWriteException、FileWriteException
 　　// 和FileWriteException異常
 　　OpenFile(…);
 　　ReadFile(…);
 　　WriteFile(…);
　　}
　　// 注意：FileException是FileOpenException、FileReadException和FileWriteException
　　// 的基類，因此這里定義的catch(FileException& fe)能捕獲所有與文件操作失敗的異
　　// 常。
　　catch(FileException& fe)
　　{
　　 ExceptionInfo* ef = fe.GetExceptionInfo();
 　　cout << “操作文件時(shí)出現(xiàn)了不可恢復(fù)的錯(cuò)誤，原因是：”<< fe << endl;
　　}
}

#include <iostream.h>
class ExceptionClass
{
 char* name;
public:
 ExceptionClass(const char* name="default name") 
 {
    cout<<"Construct "<<name<<endl;
    this->name=name;
 }
 ~ExceptionClass()
 {
    cout<<"Destruct "<<name<<endl;
 }
 void mythrow()
 {
   throw ExceptionClass("my throw");
 }
}

void main()
{
  ExceptionClass e("Test");
  try
  {
   e.mythrow();
  } 
  catch(...)
  {
   cout<<”*********”<<endl;
  }
}

class ExceptionClass
{
public:
 ExceptionClass(const char* name="Exception Default Class")
 {
  cout<<"Exception Class Construct String"<<endl;
 }
 ~ExceptionClass()
 {
  cout<<"Exception Class Destruct String"<<endl;
 }
 void ReportError()
 {
  cout<<"Exception Class:: This is Report Error Message"<<endl;
 }
};

class ArguClass
{
 char* name;
public:
 ArguClass(char* name="default name")
 {
  cout<<"Construct String::"<<name<<endl;
  this->name=name;
 }
 ~ArguClass()
 {
  cout<<"Destruct String::"<<name<<endl;
 }
 void mythrow()
 {
  throw ExceptionClass("my throw");
 }  
};

_tmain()
{
 ArguClass e("haha");
 try
 {
  e.mythrow();
 }
 catch(int)
 {
  cout<<"If This is Message display screen, This is a Error!!"<<endl; //這行不會執(zhí)行
 }
 catch(ExceptionClass pTest)
 {
  pTest.ReportError();
 }
 catch(...)
 {
  cout<<"***************"<<endl; 
 }
}

#include <iostream.h>
#include <stdlib.h>

class ExceptionClass1
{
  char* s;
public:
  ExceptionClass1()
  {
    cout<<"ExceptionClass1()"<<endl;
    s=new char[4];
    cout<<"throw a exception"<<endl;
    throw 18;
  }
  ~ExceptionClass1()
  {
    cout<<"~ExceptionClass1()"<<endl;
    delete[] s;
  }
};

void main()
{
  try
  {
    ExceptionClass1 e;
  }
  catch(...)
  {}
}

class exception
{
public:
 exception() throw();
 exception(const exception& rhs) throw();
 exception& operator=(const exception& rhs) throw();
 virtual ~exception() throw();
 virtual const char *what() const throw();
};
 
C++有很多的標(biāo)準(zhǔn)異常類：
namespace std
{
 //exception派生
 class logic_error; //邏輯錯(cuò)誤,在程序運(yùn)行前可以檢測出來
 
 //logic_error派生
 class domain_error; //違反了前置條件
 class invalid_argument; //指出函數(shù)的一個(gè)無效參數(shù)
 class length_error; //指出有一個(gè)超過類型size_t的最大可表現(xiàn)值長度的對象的企圖
 class out_of_range; //參數(shù)越界
 class bad_cast; //在運(yùn)行時(shí)類型識別中有一個(gè)無效的dynamic_cast表達(dá)式
 class bad_typeid; //報(bào)告在表達(dá)試typeid(*p)中有一個(gè)空指針p
 
 //exception派生
 class runtime_error; //運(yùn)行時(shí)錯(cuò)誤,僅在程序運(yùn)行中檢測到
 
 //runtime_error派生
 class range_error; //違反后置條件
 class overflow_error; //報(bào)告一個(gè)算術(shù)溢出
 class bad_alloc; //存儲分配錯(cuò)誤
}

class BadInitializers
{
public:
 BadInitializers() {}
};
class OutOfBounds
{
public:
 OutOfBounds(int i) { cout<<"Size "<<i<<" is illegal!!!"<<endl; }
};
class SizeMismatch
{
public:
 SizeMismatch() {}
};

template <class T>
Array1D<T>::Array1D(int sz)
{
 if(sz<0)
 {
 //throw BadInitializers();
 throw invalid_argument("Size has to be bigger than 0!!!");

 }
 size=sz;
 element=new T[size];
}
template <class T>
T &Array1D<T>::operator[](int i) const
{
 if(i<0||i>=size)
 {
 throw OutOfBounds(i);
 }
 return element[i];
}

try
{
 int i=0;
 Array1D<int> a1(5);
 a1[0]=1;
 a1[1]=3;
 a1[2]=5;
 a1[3]=7;
 a1[4]=8;
 Array1D<int> a2(a1);
 for(i=0;i<a2.Size();i++)
 {
 cout<<a2[i]<<" ";
 }
 cout<<endl;
 Array1D<int> a3(5);
 a3=a1+a2;
 cout<<a3;
}
 catch(BadInitializers)
 {
 cout<<"Error:BadInitializers!!!"<<endl;
 }
 catch(OutOfBounds &e)
 {
 cout<<"Error:OutOfBounds!!!"<<endl;
 }
 catch(SizeMismatch &e)
 {
 cout<<"Error:SizeMismatch!!!"<<endl;
 }
 catch(invalid_argument &e)
 {
 cout<<"Error:"<<e.what()<<endl;
 }
 catch(...)
 {
 cout<<"An unknown error!!!"<<endl;
 }

DWORD Func_SEHTerminateHandle()
{
DWORD dwReturnData = 0;
HANDLE hSem = NULL;
const char* lpSemName = "TermSem";
hSem = CreateSemaphore(NULL, 1, 1, lpSemName);
__try
{
 WaitForSingleObject(hSem,INFINITE);
 dwReturnData = 5;
}
__finally
{
 ReleaseSemaphore(hSem,1,NULL);
 CloseHandle(hSem);
}
dwReturnData += 5;
return dwReturnData;
}

DWORD Func_SEHTerminateHandle()
{
DWORD dwReturnData = 0;
HANDLE hSem = NULL;
const char* lpSemName = "TermSem";
hSem = CreateSemaphore(NULL, 1, 1, lpSemName);
__try
{
 WaitForSingleObject(hSem,INFINITE);
 dwReturnData = 5;
 return dwReturnData;
}
__finally
{
 ReleaseSemaphore(hSem,1,NULL);
 CloseHandle(hSem);
}
dwReturnData += 5;
return dwReturnData;
}

try
{
 .....
}
catch(A a)
{
}
catch(B& b)
{
}
catch(C* c)
{
}

class A;
void func_throw()
{
  A a;
  throw a; //拋出的是a的拷貝，拷貝到一個(gè)臨時(shí)對象里
}
try
{
 func_throw();
}
catch(A a) //臨時(shí)對象的拷貝
{
}

catch (A& w) // 捕獲異常
{
　// 處理異常
　throw; // 重新拋出異常，讓它繼續(xù)傳遞
}
catch (A& w) // 捕獲Widget異常
{
　// 處理異常
　throw w; // 傳遞被捕獲異常的拷貝
}

void func_throw()
{
  CString a;
  throw a; //拋出的是a的拷貝，拷貝到一個(gè)臨時(shí)對象里
}

try
{
func_throw();
}
catch(const char* s)
{
}

class A {
public:
A()
{
cout << "class A creates" << endl;
}
void print()
{
cout << "A" << endl;
}
~A()
{
cout << "class A destruct" << endl;
}
};
class B: public A
{
public:
B()
{
cout << "class B create" << endl;
}
void print()
{
cout << "B" << endl;
}
~B()
{
cout << "class B destruct" << endl;
}
};
void func()
{
 B b;
 throw b;
}
try
{
 func();
}
catch( B& b) //必須將B放前面，如果把A放前面，B放后面，那么B類型的異常會先被截獲。
{
 b.print();
}
catch (A& a)
{
 a.print() ;
}