当前位置： 首页 > news >正文

cpp_12_异常处理

news 来源：原创 2024/5/14 8:30:27

1  异常理论

1.1  何为异常？

        在实际运行环境中发生，却在设计、编码、测试阶段无法预料的，各种潜在的问题。

1.2  报告异常的2种机制

        1）通过 return 返回值报告异常信息：

                所有局部对象都能正确地被析构、被释放

                定位错误点，需要逐层判断，流程繁琐

        2）抛出--捕获异常对象：

                所有局部对象都能正确地被析构、被释放

                定位错误点，可一步到位，流程简单

// return.cpp  1)通过return报告异常信息
#include <iostream>
#include <cstdio>
using namespace std;class A {
public:A() {   cout << "A() is invoked" << endl;   }~A() {  cout << "~A() is invoked" << endl;  }
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int foo() {cout << "foo出错前的几百行代码" << endl;A a;FILE* pfile = fopen("./cfg", "r");if( !pfile ) return -1; // (1)将数据返回给调用者 (2)跳转至右花括号cout << "foo出错后的几百行代码" << endl;return 0;
} // a.~A()  释放a本身所占内存空间int bar() {cout << "bar出错前的几百行代码" << endl;A b;if( foo()==-1 )return -1;cout << "bar出错后的几百行代码" << endl;return 0;
} // b.~A()  释放b本身所占内存空间int hum( ) {cout << "hum出错前的几百行代码" << endl;A c;if( bar()==-1 )return -1;cout << "hum出错后的几百行代码" << endl;return 0;
} // c.~A()  释放c本身所占内存空间int main( void ) {cout << "main出错前的几百行代码" << endl;A d;if( hum()==-1 )return -1;cout << "main出错后的几百行代码" << endl;return 0;
} // d.~A()  释放d本身所占内存空间

2  抛出异常(throw异常对象)

        1）可以抛出基本类型的对象，如：

                throw  -1;

                throw  "内存分配失败";

        2）可以抛出类类型的对象，如：

                MemoryException  ex;

                throw  ex;  // 栈对象

                throw  MemoryException();  // 匿名堆对象

        3）但不要抛出局部对象的指针，如：

                MemoryException  ex;

                throw  &ex;  // 错误！（同C中，不要返回局部变量的地址）

3  捕获异常(try  catch)

        try { 可能引发异常的语句; }

        catch ( 异常类型1&  ex ) { 针对异常类型1的异常处理; }

        catch ( 异常类型2&  ex ) { 针对异常类型2的异常处理; }

        ...

        catch ( 异常类型n&  ex ) { 针对异常类型n的异常处理; }

   

// throwPre.cpp 利用throw报告异常信息
//              对于能解决的异常，尽早捕获；
//              对于不能解决的异常，远点捕获，使程序尽早结束。
#include <iostream>
#include <cstdio>
using namespace std;class A {
public:A() {   cout << "A() is invoked" << endl;   }~A() {  cout << "~A() is invoked" << endl;  }
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo() {cout << "foo出错前的几百行代码" << endl;A a;FILE* pfile = fopen("./cfg", "r");if( !pfile ) throw -1; cout << "foo出错后的几百行代码" << endl;
} // a.~A()  释放a本身所占内存空间void bar() {cout << "bar出错前的几百行代码" << endl;A b;
//    try {foo();
//    }
//    catch( int e ) {
//        cout << "bar函数中捕获异常信息: " << e << endl;
//    }cout << "bar出错后的几百行代码" << endl;
} // b.~A()  释放b本身所占内存空间void hum( ) {cout << "hum出错前的几百行代码" << endl;A c;
//    try {bar();
//    }
//    catch( int e ) {
//        cout << "hum函数中捕获异常信息: " << e << endl;
//    }cout << "hum出错后的几百行代码" << endl;
} // c.~A()  释放c本身所占内存空间int main( void ) {cout << "main出错前的几百行代码" << endl;A d;try {hum();}catch( int e ) {cout << "main函数中捕获异常信息: " << e << endl;}cout << "main出错后的几百行代码" << endl;return 0;
} // d.~A()  释放d本身所占内存空间

 

4  建议、要求、总结

        1）建议：在catch子句中使用引用接收异常对象，减少一次克隆。

             建议：以匿名临时对象的形式抛出异常，编译器优化会减少一次克隆。

        2）对于能解决的异常，尽早捕获；对于不能解决的异常，远点捕获，使程序尽早结束。

        3）要求：异常对象必须允许被拷贝构造和析构

        4）匹配顺序：根据异常对象的类型，自上至下顺序匹配，而非最优匹配 

              因此对子类类型异常的捕获，要放在对基类类型异常的捕获之前。

        5）可以抛出基本类型、类类型的异常，建议抛类类型的异常，携带更多诊断信息，以便查错

        6）可在catch中继续抛出所捕获的异常，或其他异常

        7）任何未被捕获的异常，默认的处理方式就是中止进程 

        8）忽略异常：捕获异常，但不做处理：  catch (...){}   //三个点

// 关于 异常处理的 几点建议
#include <iostream>
#include <cstdio>
using namespace std;class A {
public:A() {}A( const A& that ) { cout << "A类的拷贝构造函数被调用" << endl; }~A() {}
};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( ) {A a;throw A(); //建议抛出的为 匿名临时对象（编译器将优化，减少1次克隆）
}
int main( void ) {try {foo();}catch( A& e ) { // 建议利用引用 接收异常对象，减少1次克隆// ...}return 0;
}
// throw2.cpp 建议将 子类类型异常捕获 放在 基类类型异常捕获 之前
//                  （顺序匹配，而非最优匹配）
#include <iostream>
#include <cstdio>
using namespace std;class A {};
class B : public A {};// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( ) {throw B();
}
int main( void ) {try {foo();}catch( B& e ) { // 对子类类型异常的捕获cout << "B类型的catch捕获" << endl;}catch( A& e ) { // 对基类类型异常的捕获cout << "A类型的catch捕获" << endl;}return 0;
}

5  "异常说明"

        1）异常说明是函数原型的一部分，旨在说明函数可能抛出的异常类型：

                返回类型  函数名 (形参表) throw (异常类型1，异常类型2，...) { 函数体; }

        2）异常说明是一种承诺，承诺函数不会抛出 异常说明以外的异常类型：

                如果抛出了异常说明以外的异常类型，该异常无法被捕获，(而被编译器捕获)，进程

                中止。

        3）隐式抛出异常的函数，也可以列出它的异常说明。

// except.cpp
// 异常说明 - 给 调用者 说明, 函数内部可能会抛出 哪些类型的异常
//         - 给 调用者 承诺, 函数内部绝对不会抛出异常说明以外异常类型
#include <iostream>
#include <cstdio>
using namespace std;void foo() throw(int,double, const char*) { // 显式抛出异常的函数throw "hello world"; // 3.14; // -1;
}void bar() throw(int,double, const char*) { // 隐式抛出异常的函数foo();// 调用几十个不同函数,而且每个函数都可能抛出异常，并且抛出的异常类型都不相同
}// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {try {bar();
//        foo();    }catch(int& e) {cout << "1. 捕获异常信息:" << e << endl;}catch(double& e) {cout << "2. 捕获异常信息:" << e << endl;}catch(const char* e) {cout << "3. 捕获异常信息:" << e << endl;}return 0;
}

        4）异常说明可以没有，也可以为空：

                没有，表示可能抛出任何类型的异常   void foo (void)             { ... }

                为空，表示不会抛出任何类型的异常   void foo (void) throw() { ... }

        5）异常说明在函数的声明和定义中必须保持严格一致，否则编译报错。

// except2.cpp
// 没有异常说明 - 给 调用者 承诺，函数内部可能抛出任何类型的异常
// 异常说明为空 - 给 调用者 承诺，函数内部不抛出任何类型的异常
#include <iostream>
#include <cstdio>
using namespace std;void foo() {throw "hello world"; // 3.14; // -1;
}void bar() throw() {throw -1;
}void hum() throw(int,double); // 声明void hum() throw(int,double) { // 定义}// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {try {
//        bar();foo();    }catch(...) { // 捕获异常，但不处理}/*catch(int& e) {cout << "1. 捕获异常信息:" << e << endl;}catch(double& e) {cout << "2. 捕获异常信息:" << e << endl;}catch(const char* e) {cout << "3. 捕获异常信息:" << e << endl;}*/return 0;
}

6  构造函数中的异常

        1）构造函数可以抛出异常，某些时候还必须抛出异常

            - 构造过程中可能遇到各种错误，比如内存分配失败

            - 构造函数没有返回值，无法通过返回值通知调用者

        2）构造函数抛出异常，对象将被不完整构造，这个对象的析构函数永不执行。

            - 所有对象形式的成员变量，在抛出异常的瞬间，能得到正确地析构(构造函数的回滚机制)

            - 所有动态分配的资源，必须在抛出异常之前，自己手动释放，否则形成资源的泄露

// consExcept.cpp 构造函数中的异常
#include <iostream>
#include <cstdio>
using namespace std;class A {
public:A() { cout << "A() is invoked" << endl; }~A() { cout << "~A() is invoked" << endl; }
};
class C {
public:C() : m_p(new int) {//【A m_a;】定义m_a,利用m_a.A()//【int* m_p=new int;】定义m_p,初值为指向一块堆内存(动态资源)cout << "C() is invoked" << endl;FILE* pfile = fopen("./file", "r");if( !pfile ) {delete m_p; // 动态资源需要自己手动释放// 对于m_a,利用 m_a.~A()         //回滚机制// 释放 m_a/m_p 本身所占内存空间  //回滚机制throw -1;}// ... 构造函数后续代码...}~C() {delete m_p;cout << "~C() is invoked" << endl;// 对于m_a,利用 m_a.~A()// 释放 m_a/m_p 本身所占内存空间}
private:A m_a;int* m_p;
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {try {C c; // 定义c,利用c.C()} // 如果c是完整构造的对象,将利用c.~C() , 但是如果c是残缺对象将不会调用~C()catch( ... ) {}return 0;
}

7  析构函数中的异常

        1）析构函数中勿主动抛出异常：

              在两种情况下，析构函数会被调用

                        一：正常销毁对象：离开作用域或显式delete

                        二：在异常传递的堆栈辗转开解(stack-unwinding)过程中

              对于第二种情况，异常正处于激活状态，而析构函数也抛出了异常，即同时有两个

              异常，这时C++将通过std::terminate()函数，令进程中止。这是不希望发生的~

        2）对于可能引发异常的操作(被动抛异常)，尽量在析构函数内部消化：

                                                              try {...} catch (...) { ... }

// desconExcept.cpp 不 在析构函数中 "主动" 抛出异常
#include <iostream>
#include <cstdio>
using namespace std;void foo() {throw "foo函数中抛出的异常";
}void bar() {throw "bar函数中抛出的异常";
}class A {
public:~A() { try {bar();}catch( const char* e ) {cout << "析构函数中捕获异常信息: " << e << endl;}
//        throw "析构函数中抛出的异常";}
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {try {A a;foo();//...后续代码...} // a.~A()  ...catch( const char* e ) {cout << "main中捕获异常信息: " << e << endl;}return 0;
}

8  标准库异常类

        建议抛以下类的异常：

        

// exceptPractice 捕获异常练习
#include <iostream>
#include <stdexcept> //std::bad_alloc
#include <typeinfo>  //std::bad_cast
using namespace std;/*
int main( void ) {try {new int[0xFFFFFFFFF];    }catch( bad_alloc& e ) {cout << "new 操作符申请内存失败" << endl;}
}
*/class A {
public:virtual void foo() {}
};
class B : public A {};
class C : public B {};int main( void ) {B b;A& a = b;try {dynamic_cast<C&>(a); // 如果成功 C类型的引用 引用了 B类对象 (有风险)}catch( bad_cast& e ) {cout << "动态类型转换失败" << endl;}
}

相关文章：

  • Self-RAG：通过自我反思学习检索、生成和批判
  • python插件架构介绍
  • Python项目——搞怪小程序（PySide6+Pyinstaller）
  • 【LeetCode每日一题】2788. 按分隔符拆分字符串
  • ubuntu18.04clion无法进入断点
  • C语言总结十一：自定义类型：结构体、枚举、联合(共用体)
  • 用C语言实现简单的三子棋游戏
  • 【docker】之基础篇二
  • 130 删除二叉搜索树中的节点
  • 怎么提升搜狗网站排名
  • ora-12154无法解析指定的连接标识符
  • OCR识别网络CRNN理解与Pytorch实现
  • 堆优化的dijkstra板子
  • 让页面里的字体变清晰，变细用CSS怎么做？
  • 蓝桥杯省赛无忧 第二章 基础算法 课件33 构造
  • 【跃迁之路】【519天】程序员高效学习方法论探索系列（实验阶段276-2018.07.09）...
  • 2018一半小结一波
  • Android交互
  • AngularJS指令开发（1）——参数详解
  • Fundebug计费标准解释：事件数是如何定义的？
  • go语言学习初探（一）
  • happypack两次报错的问题
  • Hexo+码云+git快速搭建免费的静态Blog
  • Invalidate和postInvalidate的区别
  • JavaScript学习总结——原型
  • Lucene解析 - 基本概念
  • spring + angular 实现导出excel
  • unity如何实现一个固定宽度的orthagraphic相机
  • 动手做个聊天室，前端工程师百无聊赖的人生
  • 目录与文件属性：编写ls
  • 那些被忽略的 JavaScript 数组方法细节
  • 前端之React实战：创建跨平台的项目架构
  • 设计模式走一遍---观察者模式
  • 通过来模仿稀土掘金个人页面的布局来学习使用CoordinatorLayout
  • 我感觉这是史上最牛的防sql注入方法类
  • 无服务器化是企业 IT 架构的未来吗？
  • 小程序 setData 学问多
  • 一文看透浏览器架构
  • Mac 上flink的安装与启动
  • Prometheus VS InfluxDB
  • $Django python中使用redis, django中使用(封装了),redis开启事务(管道)
  • （1）虚拟机的安装与使用,linux系统安装
  • （PHP）设置修改 Apache 文件根目录 (Document Root)（转帖）
  • (zt)最盛行的警世狂言（爆笑）
  • （附源码）spring boot建达集团公司平台 毕业设计 141538
  • （附源码）springboot车辆管理系统 毕业设计 031034
  • （离散数学）逻辑连接词
  • (一)基于IDEA的JAVA基础10
  • （转）Android学习笔记 --- android任务栈和启动模式
  • （转）PlayerPrefs在Windows下存到哪里去了？
  • (转)关于pipe()的详细解析
  • (转)用.Net的File控件上传文件的解决方案
  • .aanva
  • .bat批处理（八）：各种形式的变量%0、%i、%%i、var、%var%、!var!的含义和区别
  • .Net 6.0 处理跨域的方式