1
// 方式一：返回错误码
2
int divide(int a, int b, int& result) {
3
    if (b == 0) return -1;  // 错误码
4
    result = a / b;
5
    return 0;               // 成功
6
}
7
// 问题：错误码和正常返回值混在一起，调用方可以忽略返回值
8

9
// 方式二：全局 errno
10
FILE* f = fopen("data.bin", "rb");
11
if (!f) {
12
    printf("error: %s\n", strerror(errno));  // 非线程安全！
13
}
14

15
// 方式三：assert / abort
16
assert(ptr != nullptr);  // 问题：Release 下失效，不能优雅恢复

1
// 验证栈展开的代码
2
struct Tracer {
3
    std::string name;
4
    Tracer(const std::string& n) : name(n) {
5
        std::cout << "构造: " << name << std::endl;
6
    }
7
    ~Tracer() {
8
        std::cout << "析构: " << name << std::endl;
9
    }
10
};
11

12
void funcC() {
13
    Tracer t("C");
14
    throw std::runtime_error("oops");  // t 会被自动析构
15
}
16

17
void funcB() {
18
    Tracer t("B");
19
    funcC();  // 异常穿透 funcB，t 自动析构
20
}
21

22
void funcA() {
23
    Tracer t("A");
24
    funcB();
25
}
26

27
int main() {
28
    try {
29
        funcA();
30
    } catch (const std::exception& e) {
31
        std::cout << "捕获: " << e.what() << std::endl;
32
    }
33
}
34
// 输出：
35
// 构造: A
36
// 构造: B
37
// 构造: C
38
// 析构: C
39
// 析构: B
40
// 析构: A
41
// 捕获: oops

1
// 基本语法
2
try {
3
    // 可能抛出异常的代码
4
    throw std::runtime_error("something went wrong");
5
} catch (const std::runtime_error& e) {
6
    // 按类型匹配，从上到下，第一个匹配的 catch 生效
7
    std::cerr << "Runtime error: " << e.what() << std::endl;
8
} catch (const std::logic_error& e) {
9
    std::cerr << "Logic error: " << e.what() << std::endl;
10
} catch (const std::exception& e) {
11
    // 基类 catch 放最后！否则派生类异常永远匹配不到它
12
    std::cerr << "Generic: " << e.what() << std::endl;
13
} catch (...) {
14
    // 捕获所有异常（包括非 std::exception 派生的）
15
    // 缺点：无法获取异常对象的具体信息
16
    std::cerr << "Unknown exception" << std::endl;
17
    throw;  // 可选：重新抛出
18
}

1
// throw 会拷贝！不是传递引用
2
struct MyEx : std::exception {
3
    std::string msg;
4
    MyEx(const std::string& m) : msg(m) {
5
        std::cout << "构造: " << msg << std::endl;
6
    }
7
    MyEx(const MyEx& other) : msg(other.msg) {
8
        std::cout << "拷贝: " << msg << std::endl;
9
    }
10
    const char* what() const noexcept override { return msg.c_str(); }
11
};
12

13
try {
14
    MyEx ex("original");
15
    throw ex;  // 拷贝！即使 ex 是局部变量
16
} catch (const MyEx& e) {  // 用引用捕获（避免再次拷贝）
17
    // e 引用的是 throw 拷贝出来的那个副本
18
}
19
// 输出：
20
// 构造: original
21
// 拷贝: original
22
// (ex 析构)
23
// (throw 的副析构)
24

25
// ✅ 最佳实践：直接 throw + 临时对象，编译器可能做移动甚至省略
26
try {
27
    throw MyEx("temporary");  // 可能直接构造到异常槽，省掉拷贝
28
} catch (const MyEx& e) {
29
    // ...
30
}

1
// === 不变量（Invariant）==
2

3
// 什么是"对象不变量"？
4
// 一个类内部有一条它自己保证的规则，无论发生什么都不能破。
5
class NonNegative {
6
    int _value = 0;
7
public:
8
    // 不变量：_value 永远 >= 0
9
    void set(int v) {
10
        if (v < 0)
11
            throw std::invalid_argument("negative");
12
        _value = v;  // ← 只有前面没抛异常，才到这里
13
    }
14
    // 如果 _value = v 本身会抛异常（显然这里不会，但复杂类型可能），
15
    // 那这个写法只提供了 basic guarantee——对象可能处于不一致状态。
16
};

1
// === 强保证的实现：Copy-and-Swap ===
2

3
class String {
4
    char* _data = nullptr;
5
    size_t _size = 0;
6

7
public:
8
    String(const char* s = "") : _size(strlen(s)) {
9
        _data = new char[_size + 1];
10
        strcpy(_data, s);
11
    }
12

13
    ~String() { delete[] _data; }
14

15
    // 拷贝构造（可能抛异常：new 失败）
16
    String(const String& other) : _size(other._size) {
17
        _data = new char[_size + 1];  // 可能抛 bad_alloc
18
        strcpy(_data, other._data);
19
    }
20

21
    // 移动构造（不抛异常）
22
    String(String&& other) noexcept
23
        : _data(other._data), _size(other._size) {
24
        other._data = nullptr;
25
        other._size = 0;
26
    }
27

28
    // swap（不抛异常）
29
    void swap(String& other) noexcept {
30
        std::swap(_data, other._data);
31
        std::swap(_size, other._size);
32
    }
33

34
    // 拷贝赋值 —— 强异常安全保证！
35
    String& operator=(const String& other) {
36
        // 关键：先拷贝到一个临时对象，成功了再 swap
37
        String temp(other);   // 可能抛异常，但 this 还没被修改
38
        swap(temp);           // 不抛异常
39
        return *this;
40
    }  // temp 在此析构（释放旧资源）
41

42
    // ❌ 错误写法 —— 只提供 basic guarantee
43
    String& operator=(const String& other) {
44
        if (this != &other) {
45
            delete[] _data;           // 先删了旧数据
46
            _size = other._size;
47
            _data = new char[_size + 1];  // 如果这里抛异常？
48
            strcpy(_data, other._data);
49
            // 对象处于: _data 指向已释放内存，_size 已被修改
50
            // → 不变量被破坏！
51
        }
52
        return *this;
53
    }
54
};

1
// 重温：vector 的 move_if_noexcept
2
// 如果 T 的移动构造是 noexcept → 移动元素（O(1) per element）
3
// 如果 T 的移动构造不是 noexcept → 拷贝元素（O(n) per element）
4
// 原因：移动中途如果抛异常，已经移走的数据回不来了。
5
//       拷贝中途抛异常，源数据还在，回滚安全。
6

7
struct MoveSafe {
8
    MoveSafe(MoveSafe&&) noexcept = default;     // ✅ vector 扩容时移动
9
};
10

11
struct MoveUnsafe {
12
    MoveUnsafe(MoveUnsafe&&) /* 没有 noexcept */; // ⚠️ vector 扩容时拷贝！
13
};
14

15
// 所以：只要你的移动构造/移动赋值不抛异常，务必标记 noexcept

1
class ResourceHolder {
2
    Resource* _a;
3
    Resource* _b;
4
public:
5
    ResourceHolder() : _a(nullptr), _b(nullptr) {
6
        _a = new Resource("a");   // 假设成功
7
        _b = new Resource("b");   // 假设这里抛异常！
8
    }
9
    ~ResourceHolder() {
10
        delete _a;  // ⚠️ 如果构造函数抛异常，析构函数不会被调用！
11
        delete _b;
12
    }
13
};
14
// 泄漏：_a 永远不会被 delete
15

16
// ✅ 解决方案一：用 RAII 包装每个资源
17
class SafeHolder {
18
    std::unique_ptr<Resource> _a;
19
    std::unique_ptr<Resource> _b;
20
public:
21
    SafeHolder()
22
        : _a(std::make_unique<Resource>("a"))
23
        , _b(std::make_unique<Resource>("b"))  // 如果抛异常
24
    {
25
        // _a 是已完整构造的子对象，其析构函数会被自动调用！
26
        // 这就是"已构造成员的析构函数会被调用"的保证
27
    }
28
};
29

30
// ✅ 解决方案二：try-catch in constructor
31
class ManualHolder {
32
    Resource* _a = nullptr;
33
    Resource* _b = nullptr;
34
public:
35
    ManualHolder() {
36
        _a = new Resource("a");
37
        try {
38
            _b = new Resource("b");
39
        } catch (...) {
40
            delete _a;  // 手动清理
41
            throw;       // 重新抛出
42
        }
43
    }
44
};

1
// ❌ 绝对不要在析构函数中抛异常！
2
struct Bad {
3
    ~Bad() {
4
        throw std::runtime_error("bad");  // 这是灾难
5
    }
6
};
7

8
// 为什么？看这个场景：
9
void disaster() {
10
    Bad b1;
11
    Bad b2;
12
    throw std::runtime_error("first error");
13
    // 栈展开 → 析构 b2 → 抛异常
14
    //         → 析构 b1 → 也抛异常？
15
    // 两个异常同时存在 → std::terminate()
16
}
17

18
// ✅ 正确做法：析构函数吞掉所有异常
19
struct Safe {
20
    ~Safe() noexcept {  // 析构函数默认就是 noexcept 的！
21
        try {
22
            cleanup_that_might_throw();
23
        } catch (...) {
24
            // 记录日志，但不要重新抛出
25
            std::cerr << "cleanup failed, swallowing" << std::endl;
26
        }
27
    }
28
};

1
// throw; — 重新抛出当前捕获的异常（保留原始类型）
2
try {
3
    throw std::runtime_error("original");
4
} catch (const std::exception& e) {
5
    std::cout << "日志: " << e.what() << std::endl;
6
    throw;  // 重新抛出 std::runtime_error，不是 std::exception！
7
}
8

9
// throw e; — 抛出的是被 catch 声明类型切片后的副本
10
try {
11
    throw std::runtime_error("original");
12
} catch (const std::exception& e) {
13
    std::cout << "日志: " << e.what() << std::endl;
14
    throw e;  // ❌ 抛的是 std::exception，不是 std::runtime_error！
15
              // 因为 e 的静态类型是 std::exception
16
}

1
// std::exception_ptr — 把异常存起来，稍后再抛
2
// 典型应用：线程间传递异常
3
#include <exception>
4
#include <future>
5

6
std::exception_ptr g_stored_exception;  // 全局异常存储
7

8
void worker() {
9
    try {
10
        throw std::runtime_error("worker failed");
11
    } catch (...) {
12
        g_stored_exception = std::current_exception();  // 捕获并存储
13
    }
14
}
15

16
void later() {
17
    if (g_stored_exception) {
18
        try {
19
            std::rethrow_exception(g_stored_exception);  // 重新抛出
20
        } catch (const std::runtime_error& e) {
21
            std::cout << "延迟处理: " << e.what() << std::endl;
22
        }
23
    }
24
}
25

26
// std::future 内部就是用 exception_ptr 传递异常的
27
std::future<void> f = std::async([]() {
28
    throw std::runtime_error("async error");
29
});
30
try {
31
    f.get();  // 异常在这里重新抛出
32
} catch (const std::exception& e) {
33
    std::cout << "捕获异步异常: " << e.what() << std::endl;
34
}

1
// C++ 标准异常层次结构
2
//
3
// std::exception              ← 所有标准异常的基类
4
// ├── std::logic_error        ← 程序逻辑错误（可提前检查避免）
5
// │   ├── std::invalid_argument
6
// │   ├── std::domain_error
7
// │   ├── std::length_error
8
// │   └── std::out_of_range
9
// ├── std::runtime_error      ← 运行时错误（不可提前预知）
10
// │   ├── std::range_error
11
// │   ├── std::overflow_error
12
// │   └── std::underflow_error
13
// └── std::bad_alloc          ← new 失败
14
//     std::bad_cast           ← dynamic_cast 引用版失败
15
//     std::bad_function_call  ← 调用空的 std::function
16
//     std::bad_optional_access (C++17)
17
//     std::bad_variant_access   (C++17)

1
// 自定义异常的最佳实践
2
// ✅ 继承自 std::runtime_error（或 logic_error），不要直接继承 std::exception
3
class ConfigParseError : public std::runtime_error {
4
public:
5
    // 把 what() 的信息传进基类构造函数
6
    explicit ConfigParseError(const std::string& msg)
7
        : std::runtime_error(msg) {}
8
};
9

10
// 如果需要附加信息
11
class AssetLoadError : public std::runtime_error {
12
    std::string _path;
13
public:
14
    AssetLoadError(const std::string& path, const std::string& reason)
15
        : std::runtime_error("Failed to load: " + path + " — " + reason)
16
        , _path(path) {}
17

18
    const std::string& path() const noexcept { return _path; }
19
};

1
// ❌ 不安全的写法
2
class Level {
3
    Mesh* _terrain = nullptr;
4
    Mesh* _building = nullptr;
5
    Texture* _skybox = nullptr;
6
public:
7
    void load(const std::string& path) {
8
        _terrain  = loadMesh(path + "/terrain.mesh");   // 成功
9
        _building = loadMesh(path + "/building.mesh");   // 抛异常 → _terrain 泄漏
10
        _skybox   = loadTexture(path + "/skybox.tex");   // 不会执行到
11
    }
12
};
13

14
// ✅ 用智能指针的 RAII 保证
15
class SafeLevel {
16
    std::unique_ptr<Mesh> _terrain;
17
    std::unique_ptr<Mesh> _building;
18
    std::unique_ptr<Texture> _skybox;
19
public:
20
    void load(const std::string& path) {
21
        auto terrain  = std::unique_ptr<Mesh>(loadMesh(path + "/terrain.mesh"));
22
        auto building = std::unique_ptr<Mesh>(loadMesh(path + "/building.mesh"));
23
        auto skybox   = std::unique_ptr<Texture>(loadTexture(path + "/skybox.tex"));
24

25
        // 三者都成功，一次性转移所有权
26
        _terrain  = std::move(terrain);
27
        _building = std::move(building);
28
        _skybox   = std::move(skybox);
29
    }
30
};

1
class GameConfig {
2
public:
3
    int windowWidth = 1920;
4
    int windowHeight = 1080;
5
    std::string title = "Game";
6

7
    static GameConfig load(const std::string& path) {
8
        std::ifstream file(path);
9
        if (!file) {
10
            throw ConfigParseError("Cannot open config file: " + path);
11
        }
12

13
        GameConfig config;
14
        // 逐行解析（可能抛 std::invalid_argument、std::out_of_range）
15
        std::string line;
16
        int lineNum = 0;
17
        while (std::getline(file, line)) {
18
            ++lineNum;
19
            try {
20
                config.parseLine(line);
21
            } catch (const std::exception& e) {
22
                // 包装一下，加上行号信息
23
                throw ConfigParseError(
24
                    "Error at line " + std::to_string(lineNum) + ": " + e.what()
25
                );
26
            }
27
        }
28
        return config;
29
    }
30

31
private:
32
    void parseLine(const std::string& line) {
33
        auto [key, value] = split(line, '=');
34
        if (key == "width")  windowWidth  = std::stoi(value);
35
        if (key == "height") windowHeight = std::stoi(value);
36
        if (key == "title")  title = std::trim(value);
37
    }
38
};
39

40
// 使用侧：加载失败 → 用默认值 + 日志告警
41
GameConfig config;
42
try {
43
    config = GameConfig::load("settings.cfg");
44
} catch (const ConfigParseError& e) {
45
    std::cerr << "[WARN] " << e.what() << " — 使用默认配置" << std::endl;
46
    // config 保持默认值
47
}

1
class ScriptEngine {
2
    std::vector<std::unique_ptr<ScriptModule>> _modules;
3

4
public:
5
    // 尝试加载一个脚本模块，失败不影响已加载的模块
6
    bool tryLoadModule(const std::string& path) noexcept {
7
        try {
8
            auto mod = std::make_unique<ScriptModule>(path);
9
            _modules.push_back(std::move(mod));
10
            return true;
11
        } catch (const std::exception& e) {
12
            std::cerr << "[ScriptEngine] 加载失败: " << path
13
                      << " — " << e.what() << std::endl;
14
            return false;
15
        }
16
        // noexcept 保证这个函数不会把异常传给调用方
17
    }
18

19
    // 热重载一个已存在的模块
20
    void hotReload(size_t index) {
21
        if (index >= _modules.size())
22
            throw std::out_of_range("Module index out of range");
23

24
        auto newMod = std::make_unique<ScriptModule>(_modules[index]->path());
25
        // 如果上面抛异常，旧模块还在，状态不变 → Strong guarantee
26
        _modules[index] = std::move(newMod);
27
    }
28
};

1
// 游戏主循环：一个系统的错误不应该整帧崩掉
2
void GameLoop::tick() {
3
    for (auto& system : _systems) {
4
        try {
5
            system->update(deltaTime);
6
        } catch (const std::exception& e) {
7
            // 记录错误，继续执行其他系统
8
            Logger::error("System [{}] crashed this frame: {}",
9
                          system->name(), e.what());
10
            // 可选：标记该系统为 disabled，下帧跳过
11
            system->disable();
12
        }
13
    }
14
}
15
// ⚠️ 注意：这个方法有争议。有些团队认为不应该吞异常，
16
// 而是该让它崩到顶层然后 dump 整个状态用于事后分析。
17
// 选择取决于你的容错哲学。