class Widget { ... };                 //一个类，具体是什么类
                                 // 在这里并不重要
void f1(Widget w);                    // 一些函数，其参数分别为
void f2(Widget& w);                   // Widget, Widget&,或
void f3(const Widget& w);             // Widget* 类型
void f4(Widget *pw); 
void f5(const Widget *pw);
catch (Widget w) ...                  //一些catch 子句，用来
catch (Widget& w)   ...               //捕获异常，异常的类型为
catch (const Widget& w) ...           // Widget, Widget&, 或
catch (Widget *pw) ...                // Widget*
catch (const Widget *pw) ... 

// 一个函数，从流中读值到Widget中
istream operator>>(istream& s, Widget& w);
void passAndThrowWidget()
{
  Widget localWidget;
  cin >> localWidget;          //传递localWidget到 operator>>
  throw localWidget;           // 抛出localWidget异常
}

void passAndThrowWidget()
{
  static Widget localWidget;        // 现在是静态变量（static）;
                                    //一直存在至程序结束
  cin >> localWidget;               // 象以前那样运行
  throw localWidget;                // 仍将对localWidget进行拷贝操作
}          

class Widget { ... };
class SpecialWidget: public Widget { ... };
void passAndThrowWidget()
{
  SpecialWidget localSpecialWidget;
  ...
  Widget& rw = localSpecialWidget;      // rw 引用SpecialWidget
  throw rw;                             //它抛出一个类型为Widget
                                        // 的异常
}

catch (Widget& w)                 // 捕获Widget异常
{
  ...                             // 处理异常
  throw;                          // 重新抛出异常，让它
}                                 // 继续传递
catch (Widget& w)                 // 捕获Widget异常
{
  ...                             // 处理异常
  throw w;                        // 传递被捕获异常的拷贝
}                    

catch (Widget w) ...                // 通过传值捕获异常
catch (Widget& w) ...               // 通过传递引用捕获
                                // 异常
catch (const Widget& w) ...         //通过传递指向const的引用
                               //捕获异常

catch (Widget w) ... // 通过传值捕获

catch (Widget& w) ...               // 通过引用捕获
catch (const Widget& w) ...         //也通过引用捕获

double sqrt(double);                 // from <cmath> or <math.h>

int i; 
double sqrtOfi = sqrt(i);

void f(int value)
{
  try {
    if (someFunction()) {      // 如果 someFunction()返回
      throw value;             //真，抛出一个整形值
    ...
    }
  }
  catch (double d) {           // 只处理double类型的异常
    ...  
  }
  ...
}

catch (runtime_error) ...               // can catch errors of type
catch (runtime_error&) ...              // runtime_error,
catch (const runtime_error&) ...        // range_error, or
                                 // overflow_error
catch (runtime_error*) ...              // can catch errors of type
catch (const runtime_error*) ...        // runtime_error*,
                                        // range_error*, or
                                        // overflow_error*

catch (const void*) ... //捕获任何指针类型异常 

try {
  ...
}
catch (logic_error& ex) {              // 这个catch块 将捕获
  ...                                  // 所有的logic_error
}                                      // 异常, 包括它的派生类
 
catch (invalid_argument& ex) {         // 这个块永远不会被执行
  ...                                  //因为所有的
}                                      // invalid_argument
                                       // 异常 都被上面的
                                       // catch子句捕获。

try {
  ...
}
catch (invalid_argument& ex) {          // 处理 invalid_argument
  ...                                   //异常
}
catch (logic_error& ex) {               // 处理所有其它的
  ...                                   // logic_errors异常
}