C++ 异常处理机制详解：错误码对比、抛出捕获与安全原则

二、C++ 中的异常处理机制

C++ 引入了异常处理机制，使得程序在遇到错误时不需要直接终止或通过返回值处理，可以通过抛出异常的方式将问题传递到合适的地方进行处理。

1. 基本概念

• throw：用于在错误发生时抛出异常。异常可以是任何类型的对象，程序员可以抛出字符串、整型或自定义对象来传递错误信息。
• try：包含可能抛出异常的代码块。如果 try 块中的代码抛出了异常，程序会跳转到相应的 catch 块处理异常。
• catch：用于捕获异常。catch 块可以捕获特定类型的异常，并根据异常类型进行处理。

示例代码：

double Division(int a, int b) {
    if (b == 0) throw "Division by zero condition!"; // 抛出异常
    return (double)a / (double)b;
}

int main() {
    try {
        cout << Division(10, 0) << endl; // 可能抛出异常
    } catch (const char* errmsg) {
        cout << errmsg << endl; // 捕获并处理异常
    }
    return 0;
}

2. 异常的抛出与捕获

C++ 的异常处理机制基于类型匹配。在抛出异常时，程序会根据异常的类型查找最接近的 catch 块。如果没有匹配的 catch，程序将继续沿调用链向外查找，最终未被捕获的异常会导致程序终止。

• 类型匹配：抛出的异常必须与 catch 块的类型匹配，否则将无法捕获。
• 继承与多态：可以抛出派生类对象，并使用基类捕获。这在复杂项目中非常实用，因为可以通过捕获基类来处理一类相关的错误。

catch (...) {
    // 捕获所有类型的异常，防止程序崩溃
    cout << "Unknown exception occurred!" << endl;
}

• 抛异常可以抛任意类型对象
• 捕获时，要求类型匹配

3. 异常的重新抛出

有时，捕获到异常后，当前函数无法处理该异常，而需要将其传递给更高层的函数来处理。这时，可以通过 throw 关键字重新抛出异常。

catch (...) {
    // 做一些处理，例如释放资源
    throw; // 重新抛出异常
}

三、C++ 中的异常安全

异常处理虽然强大，但在 C++ 中引入了新的风险，特别是资源泄漏问题。异常抛出后，如果没有正确释放资源（如内存、文件句柄等），可能导致程序资源泄漏。

1. 构造函数与析构函数的异常

• 构造函数：如果构造函数抛出异常，可能导致对象没有被完全构造，进而出现内存泄漏等问题。
• 析构函数：最好不要在析构函数中抛出异常，析构函数的主要职责是清理资源，如果抛出异常，可能导致资源无法被正确释放。

2. RAII（资源获取即初始化）

C++ 使用 RAII 技术来确保资源在异常发生时也能被正确释放。通过智能指针等工具，程序员可以确保资源在超出作用域时自动被释放，避免了内存泄漏问题。

std::unique_ptr<int[]> array(new int[10]);

四、C++ 异常体系的优缺点

优点：

1. 清晰的错误信息：通过异常对象，程序员可以详细描述错误信息，便于调试。
2. 简化代码逻辑：相比返回错误码的方式，异常处理可以自动沿调用链传播错误，减少显式的错误处理逻辑。
3. 支持多态：通过抛出派生类异常，捕获基类异常，实现统一的异常处理。

缺点：

1. 程序执行流混乱：异常使得程序的执行流不再线性，导致调试困难。
2. 性能开销：尽管现代硬件的处理速度很快，但异常的捕获与栈展开仍有一定的性能影响。
3. 容易导致资源泄漏：没有正确处理异常时，资源（如内存、文件句柄）可能无法被释放，导致泄漏。

五、实际应用

1. 自定义异常体系

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了。所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。

下面代码展示了一个服务器开发中常用的异常继承体系，并模拟了数据库、缓存、HTTP 服务器中的错误处理方式。通过继承 Exception 类，定义了不同类型的异常类，模拟了抛出和捕获异常的过程。

Exception 基类

class Exception {
public:
    Exception(const string &errmsg, int id) : _errmsg(errmsg), _id(id) {}
    virtual string what() const {
        return _errmsg;
    }
protected:
    string _errmsg; // 错误信息
    int _id; // 错误编号
};

• Exception 是一个基类，代表通用的异常。它有两个成员变量：
  • _errmsg：表示错误信息。
  • _id：表示错误的编号（可以用作错误分类或错误码）。
• what() 函数是一个虚函数，用于返回错误信息。子类可以重写这个方法，提供更多的上下文信息。

SqlException 子类

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; // SQL 查询语句
};

• SqlException 是 Exception 的派生类，专门用于处理数据库相关的异常。
• 它有一个额外的成员变量 _sql，用于存储触发异常的 SQL 查询语句。
• 它重写了 what() 方法，提供了更详细的错误信息，包含了 SQL 查询语句，用于调试和定位问题。

CacheException 子类

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;
    }
};

• CacheException 也是从 Exception 继承而来，表示缓存相关的异常。
• 它没有额外的成员变量，只重写了 what() 方法，返回了缓存错误的标识 CacheException: 和相应的错误信息。

HttpServerException 子类

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; // HTTP 请求类型 (如 "GET", "POST")
};

• HttpServerException 是另一个从 Exception 派生的类，处理 HTTP 服务器相关的异常。
• 它多了一个 _type 成员变量，表示 HTTP 请求的类型（如 GET 或 POST）。
• 它同样重写了 what() 方法，返回更具体的 HTTP 相关错误信息。

模拟抛出异常的函数

SQLMgr()

void SQLMgr() {
    srand(time(0));
    if (rand() % 7 == 0) {
        throw SqlException("权限不足", 100, "select * from name = '张三'");
    }
}

• SQLMgr 模拟了数据库操作，在某些情况下会抛出 SqlException，表示数据库权限不足的异常，并附带了 SQL 查询语句。

CacheMgr()

void CacheMgr() {
    srand(time(0));
    if (rand() % 5 == 0) {
        throw CacheException("权限不足", 100);
    } else if (rand() % 6 == 0) {
        throw CacheException("数据不存在", 101);
    }
    SQLMgr();
}

• CacheMgr 模拟了缓存管理操作，它可能会抛出两种不同的 CacheException：权限不足或数据不存在。
• 如果缓存没有抛出异常，它还会调用 SQLMgr，这可能会进一步抛出 SqlException。

HttpServer()

void HttpServer() {
    srand(time(0));
    if (rand() % 3 == 0) {
        throw HttpServerException("请求资源不存在", 100, "get");
    } else if (rand() % 4 == 0) {
        throw HttpServerException("权限不足", 101, "post");
    }
    CacheMgr();
}

• HttpServer 模拟了 HTTP 请求处理，可能抛出 HttpServerException，表示请求资源不存在或权限不足。
• 如果没有发生 HTTP 异常，它会调用 CacheMgr，因此可能抛出缓存或数据库相关的异常。

异常处理的主函数 main()

int main() {
    while (1) {
        try {
            HttpServer(); // 可能抛出多种异常
        } catch (const Exception& e) {
            // 捕获基类的异常
            cout << e.what() << endl; // 多态调用，输出具体的异常信息
        } catch (...) {
            cout << "Unkown Exception" << endl; // 捕获所有未明确处理的异常
        }
    }
    return 0;
}

• 在 main() 函数中，程序通过 try-catch 块捕获所有从 HttpServer() 抛出的异常。
• 使用基类 Exception 的引用捕获所有派生类异常，并通过多态机制调用派生类的 what() 方法输出具体的错误信息。
• catch(...) 捕获所有没有明确类型的异常，确保即使抛出了未知类型的异常，程序也不会崩溃。

程序行为

在每次循环中，程序随机抛出不同的异常，如：

• SQL 权限不足 (SqlException)
• 缓存数据不存在 (CacheException)
• HTTP 请求资源不存在 (HttpServerException)

这些异常会被捕获，并根据异常类型输出相应的错误信息。程序不会因为异常而崩溃，因为有全面的异常捕获机制。

会随机捕获异常~

总结

• 继承与多态：派生类如 SqlException、CacheException、HttpServerException 通过继承 Exception 基类实现了多态。即在捕获基类异常时，能够正确识别并调用派生类的 what() 方法。
• 异常处理结构化：通过不同的异常类型，开发者可以根据问题的类别和严重程度灵活处理不同模块的错误，比如数据库、缓存和 HTTP 服务器。
• 防御性编程：通过 catch(...) 捕获未识别的异常，确保程序不会因未捕获的异常导致崩溃，从而提高了程序的稳定性。

这是一个常见的异常处理体系，在服务器开发和大型系统中尤为重要。

2. C++ 标准库的异常体系

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

说明：

• 实际中我们可以去继承 exception 类实现自己的异常类。
• 但是实际中很多公司像上面一样自己定义一套异常继承体系。因为 C++ 标准库设计的不够好用。

六、总结

无论是 C 语言的返回错误码还是 C++ 的异常机制，错误处理都是程序开发中的重要组成部分。C 语言适合处理简单错误，而 C++ 的异常处理则为复杂项目提供了更多的灵活性。合理使用这两种语言的错误处理方式，可以提高程序的健壮性和可维护性。

1. C 语言中，优先使用返回错误码：对于简单的错误，C 语言通过返回值来处理是合理的。需要注意检查每个函数调用的返回值，确保及时处理错误。
2. C++ 中，建议使用异常处理：对于复杂的应用，C++ 的异常机制更为合适，尤其是在处理构造函数等无法返回错误码的场景下。
3. 遵循异常安全原则：在异常可能引发的资源管理问题上，使用 RAII（如智能指针）来确保资源的正确释放。
4. 自定义异常体系：在大型项目中，建议自定义异常类，并通过继承实现不同模块的异常管理。捕获基类异常可以简化代码，并提高异常处理的灵活性。