C++异常处理机制详解：从错误码到异常 #

引言 #

在C++程序开发中，合理的错误处理机制对于提高程序的健壮性和可维护性至关重要。本文将深入探讨从传统错误码到现代异常处理的演进，帮助开发者掌握C++异常处理的精髓。

关于C++的异常处理，网上有很多的争议，本文会介绍C++的异常处理的使用，以及我们应该使用异常处理吗，以及使用异常处理需要注意的地方。

什么是异常处理？ #

异常处理当然指的是对异常的处理，异常是指程序在执行期间产生的问题，没有按正确设想的流程走下去，比如除以零的操作，异常处理提供了一种转移程序控制权的方式，这里涉及到三个关键字：

throw：当问题出现时，程序会通过throw来抛出一个异常
catch：在可能有throw想要处理问题的地方，通过catch关键字来捕获异常
try：try块中的代码标识将被激活的特定异常，它后面通常跟着一个或多个catch块

直接看示例代码：

void func() {
    throw exception; // 抛出异常
}

int main() {
    try {
        func();
    } catch (exception1& e) {
        // code
    } catch (exception2& e) {
        // code
    } catch (...) {
        // code
    }
    return 0;
}

C++标准都有什么异常？

C++ 提供了一系列标准的异常，定义在中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：

图片来自菜鸟教程

具体异常应该不需要特别介绍了吧，看英文名字就可以知道大概意思。

自定义异常 #

可以通过继承和重载exception类来自定义异常，见代码：

#include <stdexcept>

class MyException : public std::runtime_error {
public:
    MyException() : std::runtime_error("MyException") { }
};

void f() {
    throw MyException();
}

int main() {
    try {
        f();
    } catch (MyException& e) {
        // ...
    } catch (...) {
        // ...
    }
    return 0;
}

我们应该使用异常吗？

在C++中关于是否使用异常一直都有争议，典型的就是知乎上陈硕大神说的不应该使用异常，还有就是google和美国国防部等都明确定义编码规范来禁止在C++中使用异常，这里我找了很多中英文资料，在文末参考链接列举了一些。

关于是否使用异常的讨论帖子在这，https://www.zhihu.com/question/22889420

陈硕大神说的什么我就不贴出来了，他水平之高无需置疑，但他说的一些东西还是很有争议的，关于异常处理，引用吴咏炜老师的一句话：“陈硕当然是个技术大牛。不过，在编程语言这件事上，我更愿意信任 Bjarne Stroustrup、Herb Sutter、Scott Meyers 和 Andrei Alexandrescu。这些大神们都认为异常是比返回错误码更好的错误处理方式。”

而google明确禁用异常其实是有历史包袱的，他们也认同异常处理是比错误码更好的处理方式，但他们别无选择，因为以前的编译器对异常处理的不好，他们项目里面已经有了大量的非异常安全的代码，如果全改成异常处理的代码是有很大的工作量的，具体可以看上面的链接和我文末引用的一些链接。

美国国防部禁用异常是出于实时性能考虑，工具链不能保证程序抛出异常时的实时性能，但国防部禁用了很多C++特性，例如内存分配，我们真的追求飞机一样的高性能吗？

通过上面的介绍大家应该能猜到我的结论了吧，当然这不是我的结论，而是大佬们的结论：推荐使用异常处理。

异常处理有一些潜在的缺点：

会有限的影响程序的性能，但正常工作流中不抛出异常的时候速度和普通函数一样快，甚至更快
会导致程序体积变大10%-20%，但我们真的那么在乎程序的体积吗（除了移动端）

异常处理相对于使用错误码的好处：

如果不使用trycatch那就需要使用返回错误码的方式，那就必然增加ifelse语句，每次函数返回后都会增加判断的开销，如果可以消除trycatch，代码可能会更健壮，举例如下：

void f1() {
    try {
        f2();
    } catch (some_exception& e) {
        // ...code that handles the error...
    }
}

void f2() { ...; f3(); ...; }
void f3() { ...; f4(); ...; }
void f4() { ...; f5(); ...; }
void f5() { ...; f6(); ...; }
void f6() { ...; f7(); ...; }
void f7() { ...; f8(); ...; }
void f8() { ...; f9(); ...; }
void f9() { ...; f10(); ...; }
void f10() {
    if (...some error condition...)
        throw some_exception();
}

而使用错误码方式：

int f1() {
    int rc = f2();
    if (rc == 0) {
        // ...
    } else {
        // ...code that handles the error...
    }
}

int f2() {
    int rc = f3();
    if (rc != 0)
        return rc;
    return 0;
}

int f3() {
    int rc = f4();
    if (rc != 0)
        return rc;
    return 0;
}

int f4() {
    int rc = f5();
    if (rc != 0)
        return rc;
    return 0;
}

int f5() {
    int rc = f6();
    if (rc != 0)
        return rc;
    return 0;
}

int f6() {
    int rc = f7();
    if (rc != 0)
        return rc;
    return 0;
}

int f7() {
    int rc = f8();
    if (rc != 0)
        return rc;
    return 0;
}

int f8() {
    int rc = f9();
    if (rc != 0)
        return rc;
    return 0;
}

int f9() {
    int rc = f10();
    if (rc != 0)
        return rc;
    return 0;
}

int f10() {
    if (...some error condition...)
        return some_nonzero_error_code;
    return 0;
}

错误码方式对于问题的反向传递很麻烦，导致代码肿胀，假如中间有一个环节忘记处理或处理有误就会导致bug的产生，异常处理对于错误的处理更简洁，可以更方便的把错误信息反馈给调用者，同时不需要调用者使用额外的ifelse分支来处理成功或者不成功的情况。

拿数值运算代码举例：

class Number {
public:
    friend Number operator+ (const Number& x, const Number& y);
    friend Number operator- (const Number& x, const Number& y);
    friend Number operator* (const Number& x, const Number& y);
    friend Number operator/ (const Number& x, const Number& y);
    // ...
};

最简单的可以这样调用:

void f(Number x, Number y) {
    Number sum  = x + y;
    Number diff = x - y;
    Number prod = x * y;
    Number quot = x / y;
}

但是如果需要处理错误，例如除0或者数值溢出等，函数得到的就是错误的结果，调用者需要做处理。

先看使用错误码的方式：

class Number {
public:
    enum ReturnCode {
        Success,
        Overflow,
        Underflow,
        DivideByZero
    };
    Number add(const Number& y, ReturnCode& rc) const;
    Number sub(const Number& y, ReturnCode& rc) const;
    Number mul(const Number& y, ReturnCode& rc) const;
    Number div(const Number& y, ReturnCode& rc) const;
    // ...
};

int f(Number x, Number y) {
    Number::ReturnCode rc;
    Number sum = x.add(y, rc);
    if (rc == Number::Overflow) {
        // ...code that handles overflow...
        return -1;
    } else if (rc == Number::Underflow) {
        // ...code that handles underflow...
        return -1;
    } else if (rc == Number::DivideByZero) {
        // ...code that handles divide-by-zero...
        return -1;
    }
    Number diff = x.sub(y, rc);
    if (rc == Number::Overflow) {
        // ...code that handles overflow...
        return -1;
    } else if (rc == Number::Underflow) {
        // ...code that handles underflow...
        return -1;
    } else if (rc == Number::DivideByZero) {
        // ...code that handles divide-by-zero...
        return -1;
    }
    Number prod = x.mul(y, rc);
    if (rc == Number::Overflow) {
        // ...code that handles overflow...
        return -1;
    } else if (rc == Number::Underflow) {
        // ...code that handles underflow...
        return -1;
    } else if (rc == Number::DivideByZero) {
        // ...code that handles divide-by-zero...
        return -1;
    }
    Number quot = x.div(y, rc);
    if (rc == Number::Overflow) {
        // ...code that handles overflow...
        return -1;
    } else if (rc == Number::Underflow) {
        // ...code that handles underflow...
        return -1;
    } else if (rc == Number::DivideByZero) {
        // ...code that handles divide-by-zero...
        return -1;
    }
}

再看使用异常处理的方式：

void f(Number x, Number y) {
    try {
        Number sum  = x + y;
        Number diff = x - y;
        Number prod = x * y;
        Number quot = x / y;
    } catch (Number::Overflow& exception) {
        // ...code that handles overflow...
    } catch (Number::Underflow& exception) {
        // ...code that handles underflow...
    } catch (Number::DivideByZero& exception) {
        // ...code that handles divide-by-zero...
    }
}

如果有更多的运算，或者有更多的错误码，异常处理的优势会更明显。

使用异常可以使得代码逻辑更清晰，将代码按正确的逻辑列出来，逻辑更紧密代码更容易读懂，而错误处理可以单独放到最后做处理。
异常可以选择自己处理或者传递给上层处理

异常处理的关键点 #

int main() {
    try {
        try {
            throw 20;
        } catch (int n) {
            cout << "Handle Partially ";
            throw; // Re-throwing an exception
        }
    } catch (int n) {
        cout << "Handle remaining ";
    }
    return 0;
}

小测验 #

你真的理解异常处理了吗，我们可以做几道测验题：

看这几段代码会输出什么：

测试代码1：

#include <iostream>
using namespace std;

int main() {
    int x = -1;
    cout << "Before try \n";
    try {
        cout << "Inside try \n";
        if (x < 0) {
            throw x;
            cout << "After throw (Never executed) \n";
        }
    } catch (int x ) {
        cout << "Exception Caught \n";
    }
    cout << "After catch (Will be executed) \n";
    return 0;
}

输出：

Before try
Inside try
Exception Caught
After catch (Will be executed)

throw后面的代码不会被执行

测试代码2：

#include <iostream>
using namespace std;

int main() {
    try {
        throw 10;
    } catch (char *excp) {
        cout << "Caught " << excp;
    } catch (...) {
        cout << "Default Exception\n";
    }
    return 0;
}

输出：

Default Exception

throw出来的10首先没有匹配char*，而catch(…)可以捕获所有异常。

测试代码3：

#include <iostream>
using namespace std;

int main() {
    try {
        throw 'a';
    } catch (int x) {
        cout << "Caught " << x;
    } catch (...) {
        cout << "Default Exception\n";
    }
    return 0;
}

输出：

Default Exception

‘a’是字符，不能隐式转换为int型，所以还是匹配到了…中。

测试代码4：

#include <iostream>
using namespace std;

int main() {
    try {
        throw 'a';
    } catch (int x) {
        cout << "Caught ";
    }
    return 0;
}

程序崩溃，因为抛出的异常直到main函数也没有被捕获，std::terminate()就会被调用来终止程序。

测试代码5：

#include <iostream>
using namespace std;

int main() {
    try {
        try {
            throw 20;
        } catch (int n) {
            cout << "Handle Partially ";
            throw; // Re-throwing an exception
        }
    } catch (int n) {
        cout << "Handle remaining ";
    }
    return 0;
}

输出：

Handle Partially Handle remaining

catch中的throw会重新抛出异常。

测试代码6：

#include <iostream>
using namespace std;

class Test {
public:
    Test() { cout << "Constructor of Test " << endl; }
    ~Test() { cout << "Destructor of Test "  << endl; }
};

int main() {
    try {
        Test t1;
        throw 10;
    } catch(int i) {
        cout << "Caught " << i << endl;
    }
}

输出：

Constructor of Test
Destructor of Test
Caught 10

在抛出异常被捕获之前，try和throw中的局部变量会被析构。

小总结 #

异常处理对于错误的处理更简洁，可以更方便的把错误信息反馈给调用者，同时不需要调用者使用额外的ifelse分支来处理成功或者不成功的情况。如果不是特别特别注重实时性能或者特别在乎程序的体积我们完全可以使用异常处理替代我们平时使用的C语言中的那种错误码处理方式。

参考资料 #

https://www.zhihu.com/question/22889420 https://isocpp.org/wiki/faq/ https://docs.microsoft.com/en-us/cpp/cpp/errors-and-exception-handling-modern-cpp?view=vs-2019 https://blog.csdn.net/zhangyifei216/article/details/50410314 https://www.runoob.com/cplusplus/cpp-exceptions-handling.html https://www.geeksforgeeks.org/exception-handling-c/