junyi's blog

hahahahaha

0%

C++中的错误处理

Posted on Edited on In

摘要

  • C++中的错误处理
    • 返回错误码
    • 异常处理
    • 断言
    • 日志记录
    • 资源管理

设计模式中关于错误处理的设计

在设计模式中，与错误处理相关的模式主要包括以下几种，它们可以帮助提高系统的健壮性、可维护性和可扩展性：

1. 异常对象模式（Exception Object Pattern）

概念：
将错误信息封装到异常对象中，并使用对象传递错误，而不是通过返回码或标志位。

适用场景：

  • 需要详细描述错误信息，如错误码、错误消息、发生时间等。
  • 需要在不同层级的代码中传递错误，而不丢失上下文信息。

示例（C++）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <stdexcept>

class CustomException : public std::exception {
private:
    std::string message;
public:
    explicit CustomException(const std::string& msg) : message(msg) {}

    const char* what() const noexcept override {
        return message.c_str();
    }
};

void processFile(const std::string& filename) {
    if (filename.empty()) {
        throw CustomException("文件名不能为空");
    }
    // 文件处理逻辑
}

int main() {
    try {
        processFile("");
    } catch (const CustomException& e) {
        std::cerr << "发生错误：" << e.what() << std::endl;
    }
    return 0;
}

优点：

  • 通过继承 std::exception 结构化错误信息。
  • 提供更详细的错误信息，提高可读性。

2. 责任链模式（Chain of Responsibility Pattern）

概念：
将多个错误处理对象串联在一起，错误发生时，依次尝试不同的处理者，直到某个处理者能够处理该错误。

适用场景：

  • 需要多个对象协作处理错误，并且希望动态调整处理流程。
  • 不希望在调用方硬编码所有可能的错误处理逻辑。

示例（C++）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream>
#include <memory>

// 抽象错误处理者
class ErrorHandler {
public:
    virtual void handleError(int errorCode) = 0;
    void setNext(std::shared_ptr<ErrorHandler> nextHandler) {
        next = nextHandler;
    }
protected:
    std::shared_ptr<ErrorHandler> next;
};

// 具体错误处理者
class FileErrorHandler : public ErrorHandler {
public:
    void handleError(int errorCode) override {
        if (errorCode == 1) {
            std::cout << "文件错误处理" << std::endl;
        } else if (next) {
            next->handleError(errorCode);
        }
    }
};

class NetworkErrorHandler : public ErrorHandler {
public:
    void handleError(int errorCode) override {
        if (errorCode == 2) {
            std::cout << "网络错误处理" << std::endl;
        } else if (next) {
            next->handleError(errorCode);
        }
    }
};

int main() {
    auto fileHandler = std::make_shared<FileErrorHandler>();
    auto networkHandler = std::make_shared<NetworkErrorHandler>();

    fileHandler->setNext(networkHandler);

    fileHandler->handleError(2);  // 触发网络错误处理
    return 0;
}

优点：

  • 使代码更加模块化，每个错误类型有独立的处理逻辑。
  • 处理流程可以动态调整，便于扩展。

3. 状态模式（State Pattern）

概念：
系统在不同状态下可能需要不同的错误处理方式，使用状态模式可以在运行时动态改变错误处理策略。

适用场景：

  • 需要根据程序当前状态采用不同的错误处理方式。
  • 需要减少 if-else 逻辑，提升代码可读性。

示例（C++）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>
#include <memory>

// 抽象错误处理状态
class ErrorState {
public:
    virtual void handleError() = 0;
};

// 具体状态类
class NormalState : public ErrorState {
public:
    void handleError() override {
        std::cout << "普通错误处理" << std::endl;
    }
};

class CriticalState : public ErrorState {
public:
    void handleError() override {
        std::cout << "严重错误处理" << std::endl;
    }
};

// 状态管理类
class ErrorContext {
private:
    std::shared_ptr<ErrorState> state;
public:
    void setState(std::shared_ptr<ErrorState> newState) {
        state = newState;
    }

    void processError() {
        if (state) {
            state->handleError();
        }
    }
};

int main() {
    ErrorContext context;
    context.setState(std::make_shared<NormalState>());
    context.processError();  // 输出：普通错误处理

    context.setState(std::make_shared<CriticalState>());
    context.processError();  // 输出：严重错误处理

    return 0;
}

优点：

  • 使错误处理逻辑更加灵活，能够在运行时动态切换错误处理策略。
  • 降低耦合，使不同状态的错误处理逻辑更加清晰。

4. 观察者模式（Observer Pattern）

概念：
当错误发生时，多个监听者（观察者）会被通知，并可以采取相应的处理措施。

适用场景：

  • 需要在错误发生时通知多个组件（如日志系统、告警系统、UI 界面等）。
  • 需要解耦错误发生方和错误处理方。

示例（C++）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <iostream>
#include <vector>
#include <memory>

// 观察者接口
class ErrorObserver {
public:
    virtual void onError(const std::string& message) = 0;
};

// 具体观察者
class Logger : public ErrorObserver {
public:
    void onError(const std::string& message) override {
        std::cout << "日志记录错误: " << message << std::endl;
    }
};

class AlertSystem : public ErrorObserver {
public:
    void onError(const std::string& message) override {
        std::cout << "发送警报: " << message << std::endl;
    }
};

// 被观察者（错误管理器）
class ErrorManager {
private:
    std::vector<std::shared_ptr<ErrorObserver>> observers;
public:
    void addObserver(std::shared_ptr<ErrorObserver> observer) {
        observers.push_back(observer);
    }

    void notifyError(const std::string& message) {
        for (auto& observer : observers) {
            observer->onError(message);
        }
    }
};

int main() {
    auto manager = std::make_shared<ErrorManager>();
    manager->addObserver(std::make_shared<Logger>());
    manager->addObserver(std::make_shared<AlertSystem>());

    manager->notifyError("数据库连接失败");
    return 0;
}

优点：

  • 使错误处理逻辑更加灵活，可以动态添加新的错误处理方式。
  • 促进模块解耦，提高代码复用性。

结论：

设计模式 适用场景 优势
异常对象模式 需要结构化管理异常信息 提供详细错误信息，便于追踪
责任链模式 需要多个错误处理对象协作 处理流程清晰，易扩展
状态模式 错误处理方式依赖于程序状态 代码清晰，可动态改变处理逻辑
观察者模式 需要通知多个组件错误发生 解耦错误触发和错误处理

选择合适的设计模式，可以帮助你构建健壮、灵活、易维护的错误处理系统。

C++ 错误处理一般设计思路

C++ 错误处理一般设计思路

在 C++ 代码中，错误处理是提高程序健壮性和可靠性的关键部分。通常可以采用以下方法进行设计：

1. 错误处理策略

C++ 的错误处理主要分为以下几种方式：

  1. 返回错误码（Return Codes） - 适用于简单程序或低级 API。
  2. 异常处理（Exceptions） - 适用于复杂系统，提供更清晰的错误传播。
  3. 断言（Assertions） - 适用于调试阶段，检查不应发生的错误。
  4. 日志记录（Logging） - 记录错误信息，便于调试和分析。
  5. 资源管理（RAII） - 避免资源泄露，提高代码健壮性。

2. 错误码（Return Codes）

适用场景：

  • 适用于嵌入式系统、驱动程序或 C 风格的库（如 POSIX API）。
  • 可以通过 enum 定义错误类型，提高可读性。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>

enum ErrorCode {
    SUCCESS = 0,
    FILE_NOT_FOUND = 1,
    PERMISSION_DENIED = 2,
    UNKNOWN_ERROR = -1
};

ErrorCode readFile(const std::string& filename) {
    if (filename.empty()) return FILE_NOT_FOUND;
    // 其他逻辑
    return SUCCESS;
}

int main() {
    ErrorCode result = readFile("config.txt");
    if (result != SUCCESS) {
        std::cerr << "Error: " << result << std::endl;
    }
    return 0;
}

优缺点：
✔ 优点：

  • 低开销，易于理解。
  • 在高性能应用（如游戏引擎、嵌入式系统）中表现良好。

❌ 缺点：

  • 需要手动检查返回值，容易遗漏错误处理。
  • 可读性较差，错误传播不方便。

3. 异常处理（Exceptions）

适用场景：

  • 适用于 C++ 标准库、面向对象程序设计（OOP）。
  • 适用于复杂流程控制，如文件 I/O、数据库访问、网络通信等。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <stdexcept>

void readFile(const std::string& filename) {
    if (filename.empty()) {
        throw std::runtime_error("文件名不能为空");
    }
    // 其他逻辑
}

int main() {
    try {
        readFile("");
    } catch (const std::runtime_error& e) {
        std::cerr << "捕获异常: " << e.what() << std::endl;
    }
    return 0;
}

优缺点：
✔ 优点：

  • 代码可读性强，错误可以自动传播。
  • 可以捕获不同类型的错误（std::exception）。

❌ 缺点：

  • 可能影响性能（如栈回溯）。
  • 滥用异常可能导致代码结构复杂。

设计原则：

  • 只在异常情况下使用异常（如无法恢复的错误）。
  • 不要用异常做流程控制。
  • 异常要尽可能提供详细的错误信息（如错误码、文件名、行号）。

4. 断言（Assertions）

适用场景：

  • 主要用于开发阶段，检查不应发生的错误。
  • 可用于防止非法参数传递。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <cassert>

void process(int value) {
    assert(value >= 0 && "value 不能是负数");
    std::cout << "处理值: " << value << std::endl;
}

int main() {
    process(-1);  // 运行时会触发断言失败
    return 0;
}

优缺点：
✔ 优点：

  • 性能影响小，错误检测简单。
  • 可在 Debug 模式启用，在 Release 模式关闭（NDEBUG）。

❌ 缺点：

  • 仅适用于开发阶段，不能用于错误恢复。

5. 日志记录（Logging）

适用场景：

  • 适用于长期运行的系统，如服务器、嵌入式设备。
  • 用于调试和故障分析。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <fstream>

void logError(const std::string& message) {
    std::ofstream logFile("error.log", std::ios::app);
    logFile << message << std::endl;
}

int main() {
    logError("发生错误: 文件未找到");
    return 0;
}

优缺点：
✔ 优点：

  • 方便调试，适用于生产环境。
  • 可以存储详细的错误信息。

❌ 缺点：

  • 需要额外的 I/O 资源（可异步写入日志）。

6. RAII（资源管理）

适用场景：

  • 防止资源泄露（文件、内存、锁）。
  • 适用于 C++ 智能指针（std::unique_ptr, std::shared_ptr）。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
#include <fstream>
#include <memory>

class FileHandler {
private:
    std::ifstream file;
public:
    FileHandler(const std::string& filename) {
        file.open(filename);
        if (!file) {
            throw std::runtime_error("无法打开文件: " + filename);
        }
    }
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            std::cout << "文件已关闭" << std::endl;
        }
    }
};

int main() {
    try {
        FileHandler fh("test.txt");
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }
    return 0;
}

优缺点：
✔ 优点：

  • 资源自动释放，减少内存泄露风险。
  • 结合 std::unique_ptr 进行智能内存管理。

❌ 缺点：

  • 需要正确设计类的生命周期，避免循环引用（可用 std::weak_ptr）。

7. 结合使用

在大型 C++ 项目中，通常会结合多种错误处理策略：

  • 返回值 + 日志（适用于库函数）。
  • 异常 + RAII（适用于复杂对象管理）。
  • 断言（仅用于调试）。
  • 断路器 + 重试（用于网络通信）。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <memory>

// RAII 处理文件资源
class FileHandler {
private:
    std::ifstream file;
public:
    FileHandler(const std::string& filename) {
        file.open(filename);
        if (!file) {
            throw std::runtime_error("无法打开文件: " + filename);
        }
    }
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            std::cout << "文件已关闭" << std::endl;
        }
    }
};

void processFile(const std::string& filename) {
    try {
        FileHandler fh(filename);
        // 文件处理逻辑...
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }
}

int main() {
    processFile("data.txt");
    return 0;
}

总结

方法 适用场景 优点 缺点
返回值 简单函数、嵌入式 低开销 易忽略错误
异常 复杂系统、OOP 代码清晰 性能开销
断言 开发阶段 低成本 不能用于恢复
日志 生产环境 可追溯 需额外存储
RAII 资源管理 避免泄露 需良好设计

你希望针对哪种情况做更详细的优化呢？

感谢老板支持！敬礼(^^ゞ