try
{
  // 保护的标识代码
}
catch (ExceptionName e1)
{
  // catch 块
}
catch (ExceptionName e2)
{
  // catch 块
}
catch (ExceptionName eN)
{
  // catch 块
}

double Division(int a, int b)
{
  // 当b == 0时抛出异常
  if (b == 0)
    throw "Division by zero condition!";
  else
    return ((double)a / (double)b);
}
void Func1()
{
  try
  {
    int len, time;
    cin >> len >> time;
    cout << Division(len, time) << endl;
  }
  catch (int errid)//类型为int
  {
    cout << errid << endl;
  }
}
void Func2()
{
  int len, time;
  cin >> len >> time;
  if (time != 0)
  {
    throw 1; //抛异常，抛出的类型为int
  }
  else
  {
    cout << len << " " << time << endl;
  }
}
int main()
{
  try 
  {
    Func1();
    Func2();
  }
  catch (const char* errmsg) //类型为const char*
  {
    cout << errmsg << endl;
  }
  catch (int errid)  //类型为int
  {
    cout << errid << endl;
  }
  catch (...)  //捕获任何类型
  {
    cout << "unkown exception" << endl;
  }
  return 0;
}

//异常的重新抛出
double Division(int a, int b)
{
  // 当b == 0时抛出异常
  if (b == 0)
  {
    throw "Division by zero condition!";
  }
  return (double)a / (double)b;
}
void Func()
{
  // 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
  // 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
  // 重新抛出去。
  int* array = new int[10];
  int len, time;
  cin >> len >> time;
  try
  {
    cout << Division(len, time) << endl;
  }
  catch (...)  // 拦截异常，不是要处理异常，而是要正常释放资源
  {
    cout << "delete []" << array << endl;
    delete[] array;
    throw;  // 捕获到什么对象就重新抛出什么对象
  }
  cout << "delete []" << array << endl;
  delete[] array;
}
int main()
{
  try
  {
    Func();
  }
  catch (const char* errmsg)
  {
    cout << errmsg << endl;
    // 记录日志
  }
  return 0;
}

//异常的规范
// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();
// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread(thread&& x) noexcept;

// 服务器开发中通常使用的异常继承体系
//先写一个基类
class Exception
{
public:
  Exception(const string& errmsg, int id)
    :_errmsg(errmsg)
    , _id(id)
  {}
  virtual string what() const  //通过多态，来提示异常的出处
  {
    return _errmsg;
  }
protected:
  string _errmsg;
  int _id;
};
class SqlException : public Exception
{
public:
  SqlException(const string& errmsg, int id, const string& sql)
    :Exception(errmsg, id)
    , _sql(sql)
  {}
  virtual string what() const  //通过多态，来提示异常的出处
  {
    string str = "SqlException:";
    str += _errmsg;
    str += "->";
    str += _sql;
    return str;
  }
private:
  const string _sql;
};
class CacheException : public Exception
{
public:
  CacheException(const string& errmsg, int id)
    :Exception(errmsg, id)
  {}
  virtual string what() const  //通过多态，来提示异常的出处
  {
    string str = "CacheException:";
    str += _errmsg;
    return str;
  }
};
class HttpServerException : public Exception
{
public:
  HttpServerException(const string& errmsg, int id, const string& type)
    :Exception(errmsg, id)
    , _type(type)
  {}
  virtual string what() const  //通过多态，来提示异常的出处
  {
    string str = "HttpServerException:";
    str += _type;
    str += ":";
    str += _errmsg;
    return str;
  }
private:
  const string _type;
};
void SQLMgr()
{
  //使用随机值来测试
  srand(time(0));
  if (rand() % 7 == 0)
  {
    throw SqlException("权限不足", 100, "select * from name = '张三'");
  }
}
void CacheMgr()
{
  //使用随机值来测试
  srand(time(0));
  if (rand() % 5 == 0)
  {
    throw CacheException("权限不足", 100);
  }
  else if (rand() % 6 == 0)
  {
    throw CacheException("数据不存在", 101);
  }
  SQLMgr();
}
void HttpServer()
{
  //使用随机值来测试
  srand(time(0));
  if (rand() % 3 == 0)
  {
    throw HttpServerException("请求资源不存在", 100, "get");
  }
  else if (rand() % 4 == 0)
  {
    throw HttpServerException("权限不足", 101, "post");
  }
  CacheMgr();
}
void ServerStart()
{
  while (1)
  {
    this_thread::sleep_for(chrono::seconds(1));
    try {
      HttpServer();
    }
    catch (const Exception& e) // 这里捕获父类对象就可以
    {
      // 多态
      cout << e.what() << endl;
    }
    catch (...)
    {
      cout << "Unkown Exception" << endl;
    }
  }
}
int main()
{
  ServerStart();
  return 0;
}

// 1.下面这段伪代码我们可以看到ConnnectSql中出错了，先返回给ServerStart，
//ServerStart再返回给main函数，main函数再针对问题处理具体的错误。
// 2.如果是异常体系，不管是ConnnectSql还是ServerStart及调用函数出错，都不用检查，因
//为抛出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。
int ConnnectSql()
{
  // 用户名密码错误
  if (...)
    return 1;
  // 权限不足
  if (...)
    return 2;
}
int ServerStart() {
  if (int ret = ConnnectSql() < 0)
    return ret;
  int fd = socket()
    if（fd < 0）
    return errno;
}
int main()
{
  if (ServerStart() < 0)
    ...
    return 0;
}