---

• 📝 个人主页 ：超人不会飞)
• 📑 本文收录专栏：《C++的修行之路》
• 💭 如果本文对您有帮助，不妨点赞、收藏、关注支持博主，我们一起进步，共同成长！

1. C语言中传统的处理错误方法

传统的错误处理方法以及它们对应的缺陷如下：

1. 终止程序，如assert

   破坏程序的健壮性，局部错误可能会导致全局退出，用户体验差。

2. 返回错误码

   需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到C的errno中，表示错误。

🔎关于assert的补充知识

assert实际上是一个宏函数，定义了在debug版本下才会发挥作用，而在release版本中是无效的，因此使用了assert的release版本代码可能会有一些潜在的问题，如：assert(use(val))，val没有被使用。assert的定义源代码如下：

#ifdef NDEBUG //NDEBUG在release版本下会被定义，在debug版本下则不会#define assert(expression) ((void)0)#else_ACRTIMP void __cdecl _wassert(_In_z_ wchar_t const* _Message,_In_z_ wchar_t const* _File,_In_   unsigned       _Line);#define assert(expression) (void)(                                                       \(!!(expression)) ||                                                              \(_wassert(_CRT_WIDE(#expression), _CRT_WIDE(__FILE__), (unsigned)(__LINE__)), 0) \)#endif

---

2. C++中的异常

C++中的异常是一种错误处理机制，当一个函数发现自己无法处理的错误时，可以通过抛出异常，让函数的调用者或间接调用者接收并处理这个错误。

关于异常的三个关键字：

• throw: 抛出异常。当问题出现时，函数通过throw抛出异常。
• catch: 捕获异常。catch用于捕获throw抛出的异常，捕获后执行catch的处理错误逻辑。
• try: try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。

💭下面是异常处理的一段demo代码。try块中放置可能抛出异常的代码，try中的代码被称为保护代码。

int main()
{try{//保护代码//...throw e;//抛出异常//...}catch (Exception1){}catch (Exception2){}catch (Exception3){}return 0;
}

---

3. 异常的使用

3.1 异常的抛出和捕获

🔎异常是由抛出对象引起的，该对象的类型决定了会被哪一个catch块捕获。异常的抛出与捕获的匹配原则是 —— 距离最近的类型匹配，这里的距离最近指的是函数调用链顺序，类型匹配则是抛出对象类型与catch接收类型的匹配。

• 函数调用链：

  异常对象被throw抛出后，会先在当前函数作用域寻找是否有类型匹配的catch块，若没有，则返回调用该函数的上一层函数寻找。如此循环往复，找到了就进入对应的catch块处理，若直到main函数中依然没有合适的catch，则程序终止并报错。

  💭为了防止程序崩溃，可以在catch列表的最后加上catch(...)用以捕获任意类型的异常。当有异常未被显式指明类型的catch捕获时，会被该catch捕获。

• 类型匹配：

  抛出对象类型与catch接收类型必须严格匹配。不同于函数传参和变量赋值，此处的类型匹配不存在构造函数转换和隐式类型转换，类型必须严格相同。总之，捕获异常的类型检查比常规变量赋值所允许的隐式转换更加严格和明确，如下：const char*类型的异常对象无法被string和char*类型catch接收，只能被const char*接收。

  void func()
  {int a = 0, b = 0;cin >> a >> b;if (b == 0)throw "error: Division by zero!!!";elsecout << a / b << endl;
  }int main()
  {try{func();}//catch接收异常，类型必须严格匹配！不存在构造函数转换和隐式转换//catch (string errmsg) err//catch (char* errmsg)  err,权限放大catch (const char* errmsg){cout << errmsg << endl;}catch (...){cout << "unkown err..." << endl;}return 0;
  }
  

找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

⭕补充：

抛出异常对象后，会生成一个异常对象的拷贝，这个拷贝的临时对象会在被catch以后销毁。 如下，catch引用的实际上就是拷贝对象，否则errmsg出了作用域就销毁了，无法被引用。

void func()
{int a = 0, b = 0;cin >> a >> b;if (b == 0){string errmsg("error: Division by zero!!!");throw errmsg;}elsecout << a / b << endl;
}int main()
{try{func();}catch (const string& e){cout << e << endl;}catch (...){cout << "unkown err..." << endl;}return 0;
}

通过反汇编可以看到，在throw之后，构造了一个string类型的拷贝对象

3.2 异常的重新抛出

🔎如下面的func函数，由于中途throw抛出异常，函数退出，导致new申请的空间没有delete释放，造成内存泄露。

void divisionByZero()
{throw "error: Division by zero!!!";
}void func()
{int a = 0, b = 0;cin >> a >> b;int* p = new int[10];if (b == 0){divisionByZero();}else{cout << a / b << endl;}delete[] p;p = nullptr;
}int main()
{try{func();}catch (const char* errmsg){cout << errmsg << endl;}catch (...){cout << "unkown err..." << endl;}return 0;
}

所以，我们可以在进行一些校正处理后，再将异常交给更外层的调用链函数处理（一般异常处理都在最外层main函数）。catch可以通过将异常重新抛出给更上一层函数。因此可以将func函数改造如下：

void func()
{int a = 0, b = 0;cin >> a >> b;int* p = new int[10];try{if (b == 0){divisionByZero();}else{cout << a / b << endl;}}//catch的逻辑是：先释放申请的空间，再将异常重新抛出catch (const char* errmsg){delete[] p;p = nullptr;throw errmsg;}//特殊写法。通常在这里我们不需要知道异常对象的类型，因此可以用catch(...)，throw代表抛出捕获的对象，即使我们并不知道其类型catch (...){delete[] p;p = nullptr;throw;}delete[] p;p = nullptr;
}

3.3 异常安全

• 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
• 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)
• C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，而非异常重新抛出（代码复杂）。

3.4 异常规范

异常规范说明是为了让函数使用者知道该函数可能抛出哪些异常。声明格式如下：

//func1可能抛出ABCD四种类型的异常
void func1() throw(A,B,C,D);
//func2不会抛出异常
void func2() throw();//throw是C++98的标准，没有严格的规范，上面的func1就算抛其它类型异常或者不抛都不会出错//C++11新增了noexcept关键字，表示函数不会抛出异常。若函数运行时抛出了异常，程序报错
void func3() noexcept;

---

4. 自定义异常体系

💭事实上，很多公司都有自己的一套自定义异常体系，进行规范的异常管理。因为在一个项目中，如果每个模块的设计者对于异常的抛出类型没有规范，随意抛出，那么对于外层的调用者来说，是一件十分头疼的事，因为要根据不同的异常类型作不同的异常处理。所以，实际上会定义一套继承的异常规范体系，定义一个基类，每个模块抛出的异常都是这个基类的派生类，这样外层用基类接收即可，再者可以通过多态的机制处理不同派生类。

⭕模拟项目

class Exception
{
public:Exception(int errid, const string& errmsg) :_errid(errid), _errmsg(errmsg){}virtual string what() const{return _errmsg;}protected:int _errid;string _errmsg;
};class sqlException :public Exception
{
public:sqlException(int errid, const string& errmsg, const string& sql):Exception(errid, errmsg), _sql(sql){}virtual string what() const{string errstr = "sql error: ";errstr += _errmsg;errstr += " sql: " + _sql;return errstr;}private:string _sql;
};class webNetException :public Exception
{
public:webNetException(int errid, const string& errmsg) :Exception(errid,errmsg){}virtual string what() const{string errstr = "webnet error: ";errstr += _errmsg;return errstr;}
};class fileException :public Exception
{
public:fileException(int errid, const string& errmsg, const string& fileName):Exception(errid, errmsg),_fileName(fileName){}virtual string what() const{string errstr = "file error: ";errstr += _errmsg;errstr += " filename: " + _fileName;return errstr;}private:string _fileName;
};void fileTest()
{srand(time(0));int tmp = rand();if (tmp % 6 == 0){throw fileException(6, "文件不存在", "test.exe");}else if (tmp % 7 == 0){throw fileException(7, "文件无法写入", "tips.txt");}
}void webNetTest()
{srand(time(0));int tmp = rand();if (tmp % 5 == 0){throw webNetException(5, "网络异常");}fileTest();
}void sqlTest()
{srand(time(0));int tmp = rand();if (tmp % 3 == 0){throw sqlException(3, "SQL语句错误", "select *from name = '张三'");}else if (tmp % 4 == 0){throw sqlException(4, "SQL权限不足", "insert into books (title, author)");}webNetTest();
}int main()
{while (1){this_thread::sleep_for(std::chrono::seconds(1));try{sqlTest();}catch (const Exception& e){cout << e.what() << endl;}catch (...){cout << "unkown error" << endl;}}return 0;
}

---

5. 异常的优缺点

C++异常的优点：

1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。

2. . 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。

3. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。

4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

C++异常的缺点：

1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。

2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。

3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。

4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。

5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用 func（） throw()的方式规范化。

总结：异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外面向对象的语言基本都是用异常处理错误，这也可以看出这是大势所趋。

---

ENDING…