C++异常处理从基础到应用全面解析

// 抛出异常
throw exception_object;

// 捕获异常
try {
    // 可能抛出异常的代码
} catch (exception_type1& e) {
    // 处理特定类型异常
} catch (exception_type2& e) {
    // 处理其他类型异常
} catch (...) {
    // 处理所有其他异常
}

double Divide(int a, int b) {
    if (b == 0) {
        // 抛出字符串异常
        throw "Division by zero condition!";
    }
    return static_cast<double>(a) / b;
}

void func1() {
    throw string("异常来自func1");
}

void func2() {
    func1();  // 异常从这里抛出
}

void func3() {
    func2();
}

int main() {
    try {
        func3();  // 调用链: main -> func3 -> func2 -> func1
    } catch (const string& e) {
        cout << "捕获异常: " << e << endl;
    }
    return 0;
}

// 异常基类
class Exception {
public:
    Exception(const string& errmsg, int id) 
        : _errmsg(errmsg), _id(id) {}
    
    virtual string what() const {
        return _errmsg;
    }
    
    int getid() const {
        return _id;
    }

protected:
    string _errmsg;
    int _id;
};

// 具体异常类型
class SqlException : public Exception {
public:
    SqlException(const string& errmsg, int id, const string& sql)
        : Exception(errmsg, id), _sql(sql) {}
    
    virtual string what() const override {
        return "SqlException:" + _errmsg + "->" + _sql;
    }

private:
    const string _sql;
};

class CacheException : public Exception {
public:
    CacheException(const string& errmsg, int id)
        : Exception(errmsg, id) {}
    
    virtual string what() const override {
        return "CacheException:" + _errmsg;
    }
};

void SendMsg(const string& s) {
    // 最多重试3次
    for (size_t i = 0; i < 4; i++) {
        try {
            _SeedMsg(s);  // 尝试发送消息
            break;        // 成功则退出循环
        } catch (const Exception& e) {
            // 网络不稳定错误，尝试重试
            if (e.getid() == 102) {
                if (i == 3) {
                    throw;  // 重试3次后仍失败，重新抛出
                }
                cout << "开始第" << i + 1 << "次重试" << endl;
            } else {
                throw;  // 其他错误直接重新抛出
            }
        }
    }
}

void SafeFunc1() {
    int* array = new int[10];
    
    try {
        SomeOperationThatMightThrow();
    } catch (...) {
        delete[] array;  // 异常时释放资源
        throw;           // 重新抛出异常
    }
    
    delete[] array;      // 正常流程释放资源
}

// 使用智能指针自动管理资源
#include <memory>

void SafeFunc2() {
    std::unique_ptr<int[]> array(new int[10]);
    
    // 即使抛出异常，array也会自动释放
    SomeOperationThatMightThrow();
    
    // 不需要手动delete，unique_ptr会自动处理
}

class ResourceHolder {
public:
    ~ResourceHolder() {
        if (cleanup_failed) {
            throw std::runtime_error("Cleanup failed"); // 危险操作！
        }
    }
};

~ResourceHolder() {
    try {
        // 资源清理代码
    } catch (...) {
        // 记录日志或采取其他恢复措施
        std::cerr << "析构中发生异常" << std::endl;
    }
}

void func() noexcept;  // 保证不抛出异常
void func2() noexcept(true);  // 等价于noexcept
void func3() noexcept(false);  // 可能抛出异常

template <typename T>
void swap(T& a, T& b) noexcept(noexcept(a.swap(b)));

class MyClass {
public:
  MyClass(MyClass&&) noexcept;  // 推荐标记为noexcept
};

class MyProjectException : public std::exception {
    // 项目统一的异常基类
};

class NetworkException : public MyProjectException {
    // 网络相关异常
};

class DatabaseException : public MyProjectException {
    // 数据库相关异常
};

void processRequest() {
    try {
        parseRequest();
        validateData();
        saveToDatabase();
        sendResponse();
    } catch (const DatabaseException& e) {
        // 数据库错误，可能重试或回滚
        handleDatabaseError(e);
    } catch (const NetworkException& e) {
        // 网络错误，可能重试
        handleNetworkError(e);
    } catch (const std::exception& e) {
        // 其他标准异常
        logError(e);
        throw; // 重新抛出
    }
}