C++----异常

double Division(int a, int b)
{
     // 当b == 0时抛出异常
     if (b == 0)
     {
     throw "Division by zero condition!";
     }
     return (double)a / (double)b;
}
void Func()
{
     // 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
     // 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
     // 重新抛出去。
     int* array = new int[10];
     try {
         int len, time;
         cin >> len >> time;
         cout << Division(len, time) << endl;
     }
     catch (...)
     {
         cout << "delete []" << array << endl;
         delete[] array;
         throw;
     }
     // ...
     cout << "delete []" << array << endl;
     delete[] array;
}

int main()
{
     try
     {
         Func();
     }
     catch (const char* errmsg)
     {
         cout << errmsg << endl;
     }
 return 0;
}

五、异常安全规范

1. 关键原则

• 构造函数：避免抛出异常（可能导致对象不完整）

• 析构函数：禁止抛出异常（防止资源泄漏）

• RAII机制：通过智能指针等实现资源自动管理

2.异常规范

• 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的 后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
• 函数的后面接throw()，表示函数不抛异常。
• 若无异常接口声明，则此函数可以抛掷任何类型的异常。

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);

// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);

// 这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();

// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;

六、自定义异常体系设计

1. 服务器开发典型继承体系

在服务器开发中，为了更好地管理和处理不同类型的异常，通常会设计一个异常继承体系。以下是一个示例代码：

// 异常基类（抽象错误类型）
// Exception 类：作为基类异常，包含异常信息 _errmsg 和异常编号 _id，
// 并定义了虚函数 what() 用于返回异常信息，支持多态。
class Exception {
public:
    Exception(const string& errmsg, int id)
        : _errmsg(errmsg), _id(id) {}

    virtual string what() const {
        return "[" + to_string(_id) + "] " + _errmsg;
    }

    virtual ~Exception() = default;  // 虚析构保证正确释放

protected:
    string _errmsg;  // 错误描述
    int _id;         // 错误编号
};

// SQL操作异常（具体错误类型）
// SqlException 类：继承自 Exception 类，添加了 _sql 成员变量，重写了
// what() 函数，返回更详细的 SQL 异常信息。
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 Exception::what() 
            + "\n[SQL] " + _sql;
    }

private:
    string _sql;  // 错误关联的SQL语句
};

// 缓存异常类，继承自 Exception
// CacheException 类：继承自 Exception 类，重写了 what() 函数，返回缓存异常信息
class CacheException : public Exception {
public:
    CacheException(const std::string& errmsg, int id)
        : Exception(errmsg, id)
    {}

    // 重写 what 函数，返回缓存异常信息
    virtual std::string what() const {
        std::string str = "CacheException:";
        str += _errmsg;
        return str;
    }
};

// HTTP服务异常（具体错误类型）
// HttpServerException 类：继承自 Exception 类，添加了 _type 成员变量，
// 重写了 what() 函数，返回 HTTP 服务器异常信息。
class HttpServerException : public Exception {
public:
    HttpServerException(const string& errmsg, int id, const string& type)
        : Exception(errmsg, id), _type(type) {}

    virtual string what() const override {
        return "[HTTP " + _type + " Error] " 
            + Exception::what();
    }

private:
    string _type;  // 请求类型（GET/POST等）
};

• what() 函数的作用：what() 函数是一个虚函数，在基类中定义，派生类可以重写该函数。通过基类指针或引用调用 what() 函数时，会根据实际对象的类型调用相应派生类的 what() 函数，实现多态。这样可以方便地根据不同的异常类型输出不同的异常信息。

2. 异常体系使用示例

// 模拟 SQL 管理函数，可能抛出 SqlException
void SQLMgr() {
    srand(time(0));
    if (rand() % 7 == 0) {
        throw SqlException("权限不足", 100, "select * from name = '张三'");
    }
    std::cout << "执行成功" << std::endl;
}

// 模拟缓存管理函数，可能抛出 CacheException 或调用 SQLMgr 抛出 SqlException
void CacheMgr() {
    srand(time(0));
    if (rand() % 5 == 0) {
        throw CacheException("权限不足", 100);
    } else if (rand() % 6 == 0) {
        throw CacheException("数据不存在", 101);
    }
    SQLMgr();
}

// 模拟 HTTP 服务器函数，可能抛出 HttpServerException 或调用 CacheMgr 抛出其他异常
void HttpServer() {
    srand(time(0));
    if (rand() % 3 == 0) {
        throw HttpServerException("请求资源不存在", 100, "get");
    } else if (rand() % 4 == 0) {
        throw HttpServerException("权限不足", 101, "post");
    }
    CacheMgr();
}

// 主函数，捕获异常并处理
int main() {
    while (1) {
        Sleep(500);
        try {
            HttpServer();
        } catch (const Exception& e) { // 捕获基类异常对象，利用多态处理不同派生类异常
            std::cout << e.what() << std::endl;
        } catch (...) {
            std::cout << "Unkown Exception" << std::endl;
        }
    }
    return 0;
}

3. 常用异常编号

七、常用标准库异常

• bad_alloc：当使用 new 运算符进行动态内存分配失败时，会抛出 bad_alloc 异常。
• out_of_range：当使用容器（如 std::vector、std::string 等）的成员函数访问越界元素时，会抛出 out_of_range 异常。
• invalid_argument：当函数接收到无效的参数时，会抛出 invalid_argument 异常。

八、异常的优缺点

1. 优点

• 清晰准确的错误信息：异常对象可以定义丰富的信息，相比错误码方式，能更清晰准确地展示错误信息，甚至可以包含堆栈调用信息，有助于更好地定位程序的 bug。
• 简化错误处理流程：在函数调用链中，使用返回错误码的传统方式需要层层返回错误，最外层才能拿到错误信息并处理。而异常体系中，不管是深层函数还是中间层函数出错，抛出的异常会直接跳到合适的 catch 块中，由调用者直接处理错误。

  //示例代码（错误码方式）
  #include <iostream>
  #include <errno.h>
  
  int ConnectSql() {
      // 用户名密码错误
      if (...) {
          return 1;
      }
      // 权限不足
      if (...) {
          return 2;
      }
      return 0;
  }
  
  int ServerStart() {
      if (int ret = ConnectSql() < 0) {
          return ret;
      }
      int fd = socket();
      if (fd < 0) {
          return errno;
      }
      return 0;
  }
  
  int main() {
      if (ServerStart() < 0) {
          // 处理错误
      }
      return 0;
  }

  //示例代码（异常方式）
  #include <iostream>
  #include <stdexcept>
  
  void ConnectSql() {
      // 用户名密码错误
      if (...) {
          throw std::runtime_error("用户名密码错误");
      }
      // 权限不足
      if (...) {
          throw std::runtime_error("权限不足");
      }
  }
  
  void ServerStart() {
      ConnectSql();
      int fd = socket();
      if (fd < 0) {
          throw std::system_error(errno, std::system_category(), "socket 错误");
      }
  }
  
  int main() {
      try {
          ServerStart();
      } catch (const std::exception& e) {
          std::cout << "捕获到异常: " << e.what() << std::endl;
      }
      return 0;
  }