在构建可复用的基础库时，通过面向对象方式设计异常体系，有助于将错误处理与主逻辑分离。以下是五种常见异常类型的精简实现：

1. 算术运算异常

class ArithmeticError : public Exception {
public:
    explicit ArithmeticError(const char* msg = nullptr) : Exception(msg) {}
    ArithmeticError(const char* msg, const char* src, int ln) : Exception(msg, src, ln) {}
    ArithmeticError(const ArithmeticError& other) : Exception(other) {}
    
    ArithmeticError& operator=(const ArithmeticError& rhs) {
        if (this != &rhs) Exception::operator=(rhs);
        return *this;
    }
};

2. 空指针访问异常

class NullPointerError : public Exception {
public:
    explicit NullPointerError(const char* msg = nullptr) : Exception(msg) {}
    NullPointerError(const char* msg, const char* src, int ln) : Exception(msg, src, ln) {}
    NullPointerError(const NullPointerError& other) : Exception(other) {}
    
    NullPointerError& operator=(const NullPointerError& rhs) {
        if (this != &rhs) Exception::operator=(rhs);
        return *this;
    }
};

3. 数组越界异常

class BoundsError : public Exception {
public:
    explicit BoundsError(const char* msg = nullptr) : Exception(msg) {}
    BoundsError(const char* msg, const char* src, int ln) : Exception(msg, src, ln) {}
    BoundsError(const BoundsError& other) : Exception(other) {}
    
    BoundsError& operator=(const BoundsError& rhs) {
        if (this != &rhs) Exception::operator=(rhs);
        return *this;
    }
};

4. 内存不足异常

class MemoryExhaustedError : public Exception {
public:
    explicit MemoryExhaustedError(const char* msg = nullptr) : Exception(msg) {}
    MemoryExhaustedError(const char* msg, const char* src, int ln) : Exception(msg, src, ln) {}
    MemoryExhaustedError(const MemoryExhaustedError& other) : Exception(other) {}
    
    MemoryExhaustedError& operator=(const MemoryExhaustedError& rhs) {
        if (this != &rhs) Exception::operator=(rhs);
        return *this;
    }
};

5. 参数非法异常

class ArgumentError : public Exception {
public:
    explicit ArgumentError(const char* msg = nullptr) : Exception(msg) {}
    ArgumentError(const char* msg, const char* src, int ln) : Exception(msg, src, ln) {}
    ArgumentError(const ArgumentError& other) : Exception(other) {}
    
    ArgumentError& operator=(const ArgumentError& rhs) {
        if (this != &rhs) Exception::operator=(rhs);
        return *this;
    }
};

测试用例

#include <iostream>
#include "Exception.h"

int main() {
    try {
        THROW_EXCEPTION(ArithmeticError, "除零错误示例");
    } catch (const ArithmeticError& e) {
        std::cout << "[捕获算术异常]\n消息: " << e.message() 
                  << "\n位置: " << e.location() << std::endl;
    } catch (const Exception& e) {
        std::cout << "[通用异常捕获]\n消息: " << e.message() 
                  << "\n位置: " << e.location() << std::endl;
    }
    return 0;
}