[c++] Exceptions

异常处理

一、相关资料

[ 之后，针对本章节、根据链接再进行一次系统的学习 ]

基本结构

try {
    throw logic_error{"blah"};

} catch (exception) {
    // caught here!

} catch (logic_error) {
    // not here!
}

百家讲坛 - "必要性"

[1]

为什么需要异常机制：https://blog.csdn.net/K346K346/java/article/details/50087193

C++之父Bjarne Stroustrup在《The C++ Programming Language》中讲到：

(a) 一个库的作者可以检测出发生了运行时错误，但一般不知道怎样去处理它们（因为和用户具体的应用有关）；

(b) 另一方面，库的用户知道怎样处理这些错误，但却无法检查它们何时发生（如果能检测，就可以在用户的代码里处理了，不用留给库去发现）。

Bjarne Stroustrup说：提供异常的基本目的就是为了处理上面的问题。基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或者间接）调用者能够处理这个问题。

[2]

C++ 引入异常的原因之一是：为了能让构造函数报错（析构函数不能抛异常这是大家都知道的常识），毕竟构造函数没有返回值，没有异常的话调用方如何得知对象构造是否成功呢？

[3]

对使用 C++ 异常处理应具有怎样的态度？

到了异常，一般就直接让本次操作失效，保存状态好了．

定义异常

一、内置 Error类型

下表是对上面层次结构中出现的每个异常的说明：

异常	描述
std::exception	该异常是所有标准 C++ 异常的父类。
std::bad_alloc	该异常可以通过 new 抛出。
std::bad_cast	该异常可以通过 dynamic_cast 抛出。
std::bad_exception	这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid	该异常可以通过 typeid 抛出。
std::logic_error	理论上可以通过读取代码来检测到的异常。
- std::domain_error	当使用了一个无效的数学域时，会抛出该异常。
- std::invalid_argument	当使用了无效的参数时，会抛出该异常。
- std::length_error	当创建了太长的 std::string 时，会抛出该异常。
- std::out_of_range	该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator[]()。
std::runtime_error	理论上不可以通过读取代码来检测到的异常。
- std::overflow_error	当发生数学上溢时，会抛出该异常。
- std::range_error	当尝试存储超出范围的值时，会抛出该异常。
- std::underflow_error	当发生数学下溢时，会抛出该异常。

二、自定义异常类型

通过继承和重载 exception 类来定义新的异常。

#include <iostream>
#include <exception>

using namespace std;
 
// 竟然是个struct
struct MyException : public exception
{
    const char* what () const throw
    {
        return "C++ Exception";
    }
};

// -------------------------------------------------

int main()
{
  try
  {
      throw MyException();
  }
  catch(MyException& e)
  {
      std::cout << "MyException caught" << std::endl;
      std::cout << e.what() << std::endl;
  }
  catch(std::exception& e)
  {
      // 其他的错误
  }
}

类可以继承，结构体也可以继承．

#include <iostream>  
using namespace std;

// 
class MyException : public exception 
{  
    public:  
        const char* what() const throw () 　　// <----
        {  
            std::cout << "my exception" << std::endl;  
            return NULL;
        }  
};  

void f1(bool flag = true) 
{  
    if (flag) throw MyException();  
}

void f2(bool flag = true) throw ()
{  
    if (flag) throw MyException();  
} 

-----------------------------------------------------

int main(void) 
{  
    try 
    {  
        f1();  
    } 
    catch (...)
    {  
        ;
    }  

    std::cout << "f1()异常将被捕获,不会 abort,将继续执行" << std::endl;  

    try 
    {  
        f2();  
    } 
    catch (...) 
    {  
        ;
    }  

    std::cout << "f2()异常不会被捕获,程序将会 abort,将不会执行该条语句" << std::endl;  

    return 0;  
}

使用异常

Catch-by-reference is BETTER

Problems with Catch-by-value:

- inefficient due to object copying
- causes the slicing problem, and
- cannot exploit polymorphism and dynamic binding

Catch-by-reference avoids all these problems.

catch的参数是引用，自然就不需要拷贝了。

Catch-by-Value

#include <iostream>

using namespace std;

class X {

public:
    X() {
        std::cout << "X constructed" << std::endl;
    }

    X(const X &x) {
        std::cout << "X copy-constructed" << std::endl;
    }

    ~X() {
        std::cout << "X destructed" << std::endl;
    }
};


void g() {
    throw X{};
}

void f() {
    try {
        g();
    } catch (X x) {　　// 改为catch(X &x), 其他同理
        std::cout << "caught in f; rethrow" << std::endl;
        throw;
    }
}


int main()
{
    cout << "Hello World!" << endl;

    try {
        f();
    } catch (X x) {　　// 这里又是一次 浪费时间的 copy
        std::cout << "caught in main" << std::endl;
    }

    return 0;
}