cpp_12_异常处理

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量1.2k 收藏 21
点赞数 16
分类专栏： Cpp 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33331020/article/details/135609313
版权
本文讲解C++异常处理，涉及异常定义、返回值、抛出机制、捕获技巧及标准库异常类
摘要由CSDN通过智能技术生成

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;
    }
}

wwwwood
关注
  • 16
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Cpp_异常处理
Jerry的专栏
02-29 2300
一、为什么需要异常？1.程序不可能不出错2.传统的错误处理机制存在缺陷 1)通过返回值表示错误 缺点：错误处理流程比较复杂，逐层判断，代码臃肿。 优点：函数调用路径中所有的局部对象(栈对象)都能被右花括号正确地析构，不会内存泄漏。 2)通过远程跳转处理错误优点：不需要逐层判断，一步到位处理错误，代码精炼。 缺点：函数调用路径中的局部对象失去被析构机会，形成内存泄漏。3.C++的异常结合两种
【Cpp】第十三章-异常
qq_41669298的博客
09-24 880
异常 传统C中处理错误的方式   以往我们在写C语言程序时，当用户的错误输入或者非期望结果发生时我们的程序有可能就会开始不正确的走向，此时我们为了程序的可靠性和健壮性往往需要对结果进行判断，并且防止一些非预期行为的发生。在C语言中我们程序在发生错误时我们往往会通过以下几种方式来阻止程序继续向错误方向执行，并且向外返回错误。 返回错误码   返回错误码就是我们常说的返回值，每个函数都有一个返回值，我...
CPP_异常处理
weixin_34166847的博客
09-09 584
错误处理：C分散的就近处理；C++集中处理。 C++错误处理机制：函数实现中若出现错误想处理，用throw抛出异常。应用程序中，用try...catch...捕获异常处理。 异常按类型捕获：int, double; 事例：应用程序中： try{ c[10] = 3; cout &lt;&lt;"work done."&lt;&lt;endl; throw 1; } cat...
Cpp(六) 异常处理Exception
Auto
10-09 1322
文章目录C++ 异常处理#1 环境#2 开始#2.1 格式#2.2 异常类型#2.3 自定义异常 C++ 异常处理 #1 环境 C++14 CMake 3.17 macOS 10.15.5 Clion #2 开始 #2.1 格式 格式: try{ // 抛异常 throw ExceptionType("xxx"); }catch( ExceptionType1 e1 ){ // ExceptionType1异常 // 异常处理 }catch( ExceptionType2 e2
HoloLens 2 部署问题（Unity.IL2CPP.Building.BuilderFailedException: Lump_libil2cpp_vm.cpp）
九本才的博客
05-17 529
Visual Studio 2022 17.4更新在他们的标准c++头文件中引入了一个突破性的变化，如果你升级到这个版本的Visual Studio，会导致部分IL2CPP运行时无法编译.发现怎么打包部署都不行因为国内论坛根本没有这个问题的解决方法，还是得考老外解答;在打包生成的项目中找到 sparseconfig 这个文件。
探秘高效C++ Redis客户端：cpp_redis
gitblog_00013的博客
04-13 532
探秘高效C++ Redis客户端：cpp_redis 项目地址:https://gitcode.com/cpp-redis/cpp_redis 在开发高并发、实时性的网络应用时，Redis作为一个高性能的键值存储系统，通常被广泛采用。然而，选择一个合适且高效的客户端库至关重要。今天，我们要介绍的是cpp_redis，一个专为C++设计的轻量级、异步、多线程的Redis客户端。 项目简介 cpp_r...
【4】cpp_redis hello world
C++ 爱好者 make_it_simple888
04-14 2088
【1】cpp_redis (Windows C++ Redis客户端)（C++11实现）官方最新源码编译正文如下下面的代码展示的一个完整的cpp_redis发送字符串并取回字符串的完整过程。包括如下几个步骤：1 启动Windowst通信库WSA2 连接redis服务端3 发送数据给redis4接收数据给redis5 停止Windows通讯库WSA6 cpp_redis通过异常来做错误处理：所以一个...
Qt中的异常处理
热门推荐
Mr.Sugarcane
06-27 1万+
1、看看Qt源码中如何定义QT_TRY和QT_CATCH的： inline void qt_noop(void) {} /* These wrap try/catch so we can switch off exceptions later. Beware - do not use more than one QT_CATCH per QT_TRY, and do not use the exception instance in the catch block. If you.
C++异常处理
weixin_43229348的博客
05-07 1452
1.概述 异常是在程序执行过程中出现的问题。C++ 异常是对程序运行时出现的异常情况的响应，例如尝试除以零。 异常提供了一种将控制从程序的一个部分转移到另一个部分的方法。C++ 异常处理建立在三个关键字之上：try、catch和throw。 throw - 当出现问题时，程序会抛出异常。这是使用throw关键字完成的。 catch - 程序在您要处理问题的程序中使用异常处理程序捕获异常。catch关键字表示捕获异常。 try - try块标识将激活特定异常的代码块。它后面跟着一个或多个 catc
_set_invalid_parameter_handler异常处理函数
weixin_43587848的博客
07-16 1145
_set_invalid_parameter_handler异常处理函数 VS2005之后的版本，微软增加了一些新的异常机制，新机制在出现错误时默认不通知应用程序，这时程序就崩溃了。 所以这种情况下，必须调用_set_invalid_parameter_handler、_set_purecall_handler设置自己的异常处理函数。 以下示例代码： // test.cpp // compile with: /Zi /MTd // C++ Exceptions : /EHa #include <st
CPP.rar_cpp异常
09-24
"CPP.rar_cpp异常"这个压缩包显然包含了关于C++异常处理的详细资料，其中的C++.doc文档可能涵盖了这一主题的多个方面。 异常处理是C++中一种处理错误的方式，通过使用try、catch和throw关键字来实现。当程序执行...
cpp_redis修改源码之后的版本vs2015，解决不能在xp环境上面运行
07-05
6. **异常安全**：XP的C++运行时可能不支持某些异常处理特性，因此修改可能包括确保代码在没有异常的情况下也能正确工作。 为了理解并应用这些修改，你需要仔细研究cpp_redis和tacopie的源代码，特别是涉及到网络...
CPP.rar_C++ hello.cpp_world
09-19
9. **异常处理**：C++支持异常处理机制，通过`try-catch`块来捕获和处理程序运行时可能出现的错误。 在学习C++的过程中，初学者通常会从简单的"Hello, World!"程序开始，逐渐深入到更复杂的概念和技术。通过不断的...
CPP_Wrappers:包装C ++中的函数
03-29
综上所述，"CPP_Wrappers:包装C ++中的函数"这个主题涵盖了C++编程中的许多重要概念和技术，包括面向对象特性、模板、异常处理、资源管理以及与C库的交互。通过熟练掌握这些技巧，开发者可以构建更强大、更健壮的...
Google_Cpp_Style_guide_CN.rar_goole c++_style
09-23
- 优先使用异常处理，而不是错误码。 - 在可能出错的地方使用`CHECK`宏进行断言。 5. **内存管理**： - 使用智能指针（如`unique_ptr`, `shared_ptr`）管理动态分配的对象，减少手动调用`new`和`delete`。 - ...
C++笔记5•内存管理•
qq_64446190的博客
08-12 1075
内存管理
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 138
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 198
C++ | Leetcode C++题解之第337题打家劫舍III
ubuntu22.04 安装 ros1
qq_35547879的博客
08-14 172
原先只知道ros1 noetic 只支持到ubuntu20.04。现在系统必须升级到ubuntu22.04。
C++异常处理与智能指针auto_ptr解析
异常处理的基本思想是在函数内部遇到错误时抛掷异常，然后在调用栈的上层捕获并处理这些异常。当异常被抛掷时，程序会暂停当前执行路径，尝试在调用堆栈中寻找合适的`catch`块来捕获异常。如果没有找到匹配的处理器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值