C++的异常

1. C语言处理错误的方式

• 终止程序，如assert，无法接受，别的服务也需要跑。
• 错误码，需要自己查文档，并且错误码是层层给的，很麻烦。

2. 异常的概念

• 概念

  当一个函数出现自己无法处理的错误时，让别的代码去处理错误。

• 三个关键字

  throw：用来抛出异常（内置类型、自定义类型都可以）。

  catch：处理异常的代码。

  try：里面放可能抛出异常的代码，后面会跟着好几个catch。

3. 异常的用法注意点

• 异常抛出一个对象后，这个对象的类型决定了是哪一个catch处理它（必须是类型一致并且离得最近的那个catch）。
• throw对象（可以直接匿名对象很方便）之后，会生成一个它的拷贝对象，它在catch处理完之后销毁。
• catch(...)可以接受任何类型的异常。
• throw派生类对象可以用基类对象接受，这是语法天然支持的；如果接受的有子类有父类，那就看距离。

4. 异常处理原则

   按照函数栈来，一层一层往回找，一直到main()都无法捕获就直接终止程序。或者被捕获了，会继续执行catch之后的代码。

double Division(int a, int b)
{  
    if (b == 0)// 当b == 0时抛出异常
        throw "Division by zero condition!";
     else
         return ((double)a / (double)b);
}
void Func()
{
    int a,b;
     cin >> a >> b;
     cout << Division(a,b) << endl;
}

int main()
{
    try 
    {
         Func();
     }
    //一般都是最外部的函数处理
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
     }
    //放在最后，防止程序终止
    catch(...)
    {
           cout<<"unkown exception"<<endl;           
    }
    //如果没有异常需要处理直接忽视catch
    return 0;
}

5.异常的重新抛出

• 含义：内部的catch处理好自己的事物后，一些统一的处理不直接自己写（比如日志、打印错误等），而是把这个异常再次抛出，给其他的catch处理。

double Division(int a, int b)
{  
    if (b == 0)// 当b == 0时抛出异常
        throw "Division by zero condition!";
     else
         return ((double)a / (double)b);
}
void Func()
{
 // 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
 // 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去。
    int* array = new int[10];
    try 
    {
         int len, time;
         cin >> len >> time;
         cout << Division(len, time) << endl;
     }
     catch (...)//接受任何错误，都需要释放内存空间，不可能每个类型写一个
     {
         cout << "delete []" << array << endl;
         delete[] array;
         throw;//抛出捕获到的错误
     }
}
int main()
{
    try
     {
         Func();
     }
    //在外部完成统一的事物
     catch (const char* errmsg)
     {
         cout << errmsg << endl;
     }
     return 0;

6.异常引发的安全问题

• 不要在构造函数里面抛异常，可能会使得对象初始化不完整。
• 不要在析构函数里面抛异常，可能会使内存泄漏。
• 在new/delete、malloc/free、lock/unlock之间不要抛异常，可能会导致内存泄漏、死锁等问题。（RAII思想可以解决这个问题，包括内存和锁）。

7. 异常的规范

• C++98

  void func() throw()：表示不会抛异常。
  void*operate new(size_t size) throw(std::bad_alloc)：表示会抛出bad_alloc异常。

• C++11

  一个函数明确不抛异常就在后面加noexcept。
  可能抛异常就什么也不加。

8. 异常的继承体系

   单独一种异常类型无法满足多种需求，所以有各种不同的异常继承了原本的异常类型来完成不同的需求。

//基类的异常，必须有错误码和错误描述两个功能
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();
}
int main()
{
    while (1)
    {
        this_thread::sleep_for(chrono::seconds(1));
        try 
        {
            HttpServer();
        }
        catch (const Exception& e)//这里捕获父类对象就可以
        {
            //多态，它会执行自己虚函数表里面的函数
            cout << e.what() << endl;
        }
        catch (...)
        {
            cout << "Unkown Exception" << endl;
        }
    }
    return 0;

9.异常的优缺点

（1）优点：

• 清晰展示错误信息
• 不会需要像错误码一样层层递交
• 很多第三方库都使用了异常

（2）缺点：

• 代码运行混乱
• 容易造成内存泄露和死锁等安全问题