C++异常

最新推荐文章于 2024-07-28 21:35:11 发布
最新推荐文章于 2024-07-28 21:35:11 发布
阅读量658 收藏 1
点赞数 5
分类专栏： c++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61567378/article/details/126391875
版权

文章目录

C语言的处理错误方式

  1. 错误码： 比如在很多C语言系统调用的时候，调用错误都会返回其对应的错误码，这个就很不好找，还要去查询这个错误码对应的意思
  2. 终止程序: assert,但是内存错误，除0，之后直接就终止程序了

C++异常概念

  • throw:出现错误的时候，可以去抛出一个异常，抛出一个对象，（字符串，有更多的信息，整形，浮点型，自定义类型，这些对象都是可以的）
  • catch：处理错误的地方，可以去捕获
  • try：和catch进行搭配
#include<iostream>
using namespace std;

double Division(int a,int b)
{
    if(b==0)
    {
        throw"division by zero condition";//b是0的话，就出现错误，不让程序终止掉
        //抛一个字符串出来
    }
    else
    return ((double)a/(double)b);//直接除，如果发生除0错误，就直接终止掉，我们不想
}

void func()
{
    int len,time;
    cin>>len>>time;
    cout<<Division(len,time)<<endl;
}

void demo1()
{
    try{
        func();
        //如果正常执行的话，下面的catch就不会执行
        //如果有异常的话，就直接就跳到了catch的地方了
    }
    catch(const char* errmsg)//捕获一下,和抛出的类型是要匹配的
    {
        cout<<errmsg<<endl;
    }
    catch(...)
    {
        cout<<"unknown exception"<<endl;
    }
}
int main()
{
    demo1();
    return 0;
}

异常的使用

异常的抛出和捕获

异常的抛出和匹配的原则

  1. 异常是通过throw抛出对象而引发的，而该对象的类型决定了应该会激活哪一个catch处理代码
double Division(int a,int b)
{
    if(b==0)
    {
        throw"division by zero condition";//b是0的话，就出现错误，不让程序终止掉
        //抛一个字符串出来
    }
    else
    return ((double)a/(double)b);//直接除，如果发生除0错误，就直接终止掉，我们不想
}

void func1()
{
    int len,time;
    cin>>len>>time;
    cout<<Division(len,time)<<endl;
}

void func2()
{
    int len,time;
    cin>>len>>time;
    if(time!=0)
    throw 1;//抛出一个int类型变量
    else
    cout<<len<<" "<<time<<endl;
}

void demo1()
{
    try{
        func1();
        //如果正常执行的话，下面的catch就不会执行
        
        //如果有异常的话，就直接就跳到了catch的地方了,
        func2();
    }
    catch(const char* errmsg)//捕获一下,和抛出的类型是要匹配的,抛出异常之后程序就终止了
    {
        cout<<errmsg<<endl;
    }
    catch(int errid)//catch是可以有很多个
    {
        cout<<errid<<endl;
    }
    catch(...)
    {
        cout<<"unknown exception"<<endl;
    }
}
  1. 被选择的处理代码是调用链里面和该对象类型匹配且抛出异常位置最近的那个
    如果离它近，不匹配也不会去调用
    在这里插入图片描述
double Division(int a,int b)
{
    if(b==0)
    {
        throw"division by zero condition";//b是0的话，就出现错误，不让程序终止掉
        //抛一个字符串出来
    }
    else
    return ((double)a/(double)b);//直接除，如果发生除0错误，就直接终止掉，我们不想
}

void func1()
{
    try{
    int len,time;
    cin>>len>>time;
    cout<<Division(len,time)<<endl;
    }
    catch(const char* errmsg)//这个地方近，就到这里，不到下面的catch
    {
        cout<<errmsg<<endl;
    }
}

void demo1()
{
    try{
        func1();
        //如果正常执行的话，下面的catch就不会执行
        
        //如果有异常的话，就直接就跳到了catch的地方了,
        func2();
    }
    catch(const char* errmsg)//捕获一下,和抛出的类型是要匹配的,抛出异常之后程序就终止了
    {
        cout<<errmsg<<endl;
    }
    catch(int errid)//catch是可以有很多个
    {
        cout<<errid<<endl;
    }
    catch(...)
    {
        cout<<"unknown exception"<<endl;
    }
}
  1. 抛出异常对象之后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象（生命周期在catch之后就销毁了）

double Division(int a,int b)
{
    if(b==0)
    {
        string errmsg("/0");
        throw errmsg;//抛出这个errmsg,这个errmsg是一个临时对象，
    }
    else
    return ((double)a/(double)b);//直接除，如果发生除0错误，就直接终止掉，我们不想
}

void func1()
{
    try{
    int len,time;
    cin>>len>>time;
    cout<<Division(len,time)<<endl;
    }
    catch(const char* errmsg)//这个地方近，就到这里，不到下面的catch
    {
        cout<<errmsg<<endl;
    }
}

void demo1()
{
    try{
        func1();
        //如果正常执行的话，下面的catch就不会执行
    }

    catch(const string& errmsg)//捕获一下,和抛出的类型是要匹配的,抛出异常之后程序就终止了
    {
        //有点像实际参数传给形参
        //把对象进行拷贝捕获
        cout<<errmsg<<endl;
    }
   
}
  1. catch(…)可以捕获任意类型的异常，但是不知道异常的错误是什么
	catch(...)//这个就可以捕获上面我们没写的位置类型的异常，程序就不会终止了
    {
        cout<<"unknown exception"<<endl;
    }
  1. 不管在哪里出现了错误，我们捕获都是统一在一层（最外层，网络层进行处理）,捕获记录日志,但是我们一般都不抛字符串，整形这些，而是抛出自定义类型,实际中抛出和捕获的匹配原则有个例外,并不都是类型完全匹配，可以抛出的派生类对象，用基类捕获，在实际非常实用

catch(const Exception& e)//用一个基类来进行捕获
{}
throw

可以抛出Exception对象，或者Exception的子类对象

  1. 如果异常被捕获，那么catch后面的语句会继续执行
void func1()
{
    try
    {
        int len, time;
        cin >> len >> time;
        cout << Division(len, time) << endl;
    }
    catch (const string &errmsg) //捕获一下,和抛出的类型是要匹配的,抛出异常之后程序就终止了
    {
        //有点像实际参数传给形参
        //把对象进行拷贝捕获
        cout << errmsg << endl;
    }
    func2();//会执行 
}
  1. 异常的重新抛出
void func()
{
    int *arr = new int[10]; //可以用只能指针尝试处理
    int len, time;
    cin >> len >> time;
    try
    {
        cout << Division(len, time) << endl;
    }
    catch (const string &errmsg) //这里提前把他捕获了，后面也能正常运行
                                 //拦截异常不是要处理异常，而是要正常释放资源
    {
        cout << "delete []" << arr << endl; //这样就可以了,但是我们希望最外层进行处理
        delete[] arr;
        throw errmsg; //重复抛出异常
    }
    catch (...) //这里提前把他捕获了，后面也能正常运行
                                 //拦截异常不是要处理异常，而是要正常释放资源
    {
        cout << "delete []" << arr << endl; //这样就可以了,但是我们希望最外层进行处理
        delete[] arr;
        throw; //捕获到什么就抛出什么对象
    }
    //这个地方抛异常，后面的代码就不会执行了，就会出现内存泄露的问题
    //异常安全的问题
    cout<<"delete []"<<arr<<endl;//这样就可以了,但是我们希望最外层进行处理
    delete[] arr;
}

自定义异常体系

写一个基类异常对象
子类异常对象都去继承它

//异常的继承体系
class Exception //异常的基类对象
{
public:
    Exception(const string &errmsg, int &id)
        : _errmsg(errmsg), _id(id)
    {
    }
    virtual string what() const //多态
    {
        return _errmsg;
    }

protected:
    string _errmsg; //错误的描述
    int _id;        //错误的编号,区分某种错误，对某种错误进行特殊处理
    //比如假如说网络错误的话，我们不能直接反馈信息，而是要重复去尝试10次直到不行，才反馈，所以id就是表示错误的编号
};

class SqlException : public Exception
{
public:
    SqlException(const string &errmsg, int id, const string &sql)//记录一下sql语句
        : Exception(errmsg, id), _sql(sql) //调用父类的构造函数
    {
    }
    virtual string what() const //多态,子类重写了父类的虚函数
    {
        string str = "SqlException :"; //前缀
        
        str += _errmsg;
        str+="->";
        str += _sql;
        return str; //这样就行了
    }

private:
    string _sql; //请求类型是什么
};

class CacheException : public Exception
{
public:
    CacheException(const string &errmsg, int id)
        : Exception(errmsg, id) //调用父类的构造函数
    {
    }
    virtual string what() const //多态
    {
        string str = "CacheException :"; //前缀
        str += _errmsg;
        return str; //这样就行了
    }
};

class HttpException : public Exception
{
public:
    HttpException(const string &errmsg, int id, const string &type)
        : Exception(errmsg, id), _type(type) //调用父类的构造函数
    {
    }
    virtual string what() const //多态,子类重写了父类的虚函数
    {
        string str = "HttpException "; //前缀
        str += _type;
        str += ":";
        str += _errmsg;
        return str; //这样就行了
    }

private:
    string _type; //请求类型是什么
};

void SQLMgr()
{
    if (rand() % 9 == 0)
    {
        throw SqlException("权限不足", 100,"select * from name = 'zhansang'"); //但是我们怎么知道是谁的权限不足
    }
    //但是可能三者都会抛异常
}

void CacheMgr()
{
    if (rand() % 3 == 0)
    {
        throw CacheException("权限不足", 100); //但是我们怎么知道是谁的权限不足
    }
    if (rand() % 5 == 0)
    {
        throw CacheException("数据不存在", 101);
    }
    //...缓存里面再查到数据库
    SQLMgr();
}

//我们可以抛任意类型的异常，但是必须要继承父类
void HttpServer()
{
    //...数据来了网络先接收，走到缓存里面去
    if (rand() % 2 == 0)
    {
        throw HttpException("请求资源不在", 100, "get");
    }
    if (rand() % 7 == 0)
    {
        throw HttpException("权限不足", 101, "post");
    }
    throw "xxxxxx";//未知异常，程序不会崩
    CacheMgr();
}
#include <chrono>
#include <thread>
#include <unistd.h>
void ServerStart()
{
    while (1)
    {
        this_thread::sleep_for(chrono::seconds(1));
        try
        {
            HttpServer();
        }

        // 这个下面就是异常的捕获
        catch (const Exception &e) // const类型的this指针，里面的成员也都要在最后面加const
        {
            //我们可以用一个多态,
            // 1.虚函数的重写  2. 父类的指针或引用去调用,

            //这样就可以用了，把他们写到对应的日志库里面就行了
            std::cerr << e.what() << endl; //捕获去调用这个对象就是多态
        }
        catch (...)
        {
            std::cerr << "unknown Exception" << endl;
        }
    }
}

void demo3()
{
    ServerStart();
}

异常安全

  • 资源泄露lock和unlock，malloc和free，new 和delete，fopen和fclose，有异常的话会跳过这些，就会造成内存泄漏
  • 构造函数和析构函数最好不要抛异常，没有初始化完整，没有释放完整

异常规范

  1. 网络规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些，可以在函数的后面接throw（类型），列出这个函数可能抛出的异常的所有类型
//这里表示这个函数会抛出A/B/C/D的某种类型的异常
void fun() throw(A,B,C,D);
  1. 函数后面接throw（），表示这个函数不会抛异常
//不会抛出任何异常
void* operator delete (std::size_t size,void* ptr)throw();//
  1. throw后面只有一个，说明只会抛出这个异常
//这里只会抛出bad_alloc的异常
void * operator new (std::size_t size) throw(std::bad_alloc);

∗ ∗ 但是异常规范在实际中很难被执行 ∗ ∗ **但是异常规范在实际中很难被执行** ∗∗但是异常规范在实际中很难被执行∗∗

C++11的noexcept关键字

在后面加上noexcept就说明不会抛异常

class exception {
public:
  exception () noexcept;
  exception (const exception&) noexcept;
  exception& operator= (const exception&) noexcept;
  virtual ~exception();
  virtual const char* what() const noexcept;
}

异常的优缺点

优点

  1. 可以更加清晰的表示错误，甚至可以包含堆栈调用信息，更容易去定位bug（只能靠日志去进行分析）
  2. 如果返回错误码的话，调用链很长的话，底层很难拿到对应的错误码
  3. 很多第三方库都包含异常，比如gtest，glog等等，所以我们使用的话也要使用异常
  4. 有的函数使用异常更好处理，而向返回值是int这种，返回的不知道是错误码还是正常的值

缺点

  1. 执行流乱跳，很混乱，这对我们跟踪调试时以及分析程序时，比较困难
  2. 异常会有一些性能的开销，但是现在这个影响几乎忽略不计
  3. C++没有垃圾回收机制，资源要自己管理，有了异常很容易照成内存泄露，死锁等异常安全问题（RAII）（智能指针，lock_guard）,出作用域就掉析构函数,学习成本高
  4. C++标准库的异常体系定义的不好，导致很多人各自定义异常体系
  5. 异常必须要规范，不然外层的用户就很难受（尽量抛子类对象，尽量对接口函数声明抛异常的规范）
Zevin~
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C++ 异常
mz474920631的博客
05-31 3112
文章目录一、C语言传统的处理错误的方式二、C++异常概念三、异常的使用异常的抛出和捕获异常的重新抛出异常安全异常规范四、自定义异常体系五、C++标准库的异常体系六、异常的优缺点C++异常的优点C++异常的缺点 一、C语言传统的处理错误的方式 传统的错误处理机制： 终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。 返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误 C 标准库中setjmp和longjmp
C++中的 throw详解
APItesterCris的博客
06-01 788
虽然 func() 函数中发生了异常，但是由于 throw 限制了函数只能抛出 char*、exception 类型的异常，所以 try-catch 将捕获不到异常，只能交给系统处理，终止程序。throw 关键字除了可以用在函数体中抛出异常，还可以用在函数头和函数体之间，指明当前函数能够抛出的异常类型，这称为异常规范（Exception specification），有些教程也称为异常指示符或异常列表。如此，func() 函数就不能抛出任何类型的异常了，即使抛出了，try 也检测不到。
C++异常详细介绍
weixin_57023347的博客
10-29 8788
目录 前言 一.C++异常概念 二.异常的抛出和匹配规则 三.异常的重新抛出 四.异常安全问题 五.异常规范说明 六.自定义异常体系 七.C++标准库的异常体系 八.异常优缺点 前言 在C语言中处理错误的方式和缺陷有： 返回错误码。 缺陷： 1.错误码不好设置，比如：除0操作，就不好返回错误码。如果返回一个数字，可能会有两层含义，是错误，还是结果呢。一般我们会在参数加一个输出型参数返回结果，再规定成功和失败返回的数字。 ...
C++ 异常详解
weixin_59371851的博客
09-30 1563
在c语言中我们只能使用传统的返回错误码方式来处理错误，有时候会很不方便。所以在c++中增加了异常这一特性。1、C语言传统的处理错误的方式终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。本文主要简单介绍了异常的使用，希望能给大家带来帮助。
C++ 异常处理
风间琉璃的博客
10-10 6778
C++标准库当中的异常也是一个基础体系，其中exception就是各个异常类的基类，我们可以在程序中使用这些标准的异常，它们之间的继承关系如下：std::exception 该异常是所有标准C++异常的父类。std::bad_alloc 该异常可以通过new抛出。std::bad_cast 该异常可以通过dynamic_cast抛出。std::bad_exception 这在处理C++程序中无法预期的异常时非常有用。
C++异常处理
weixin_43229348的博客
05-07 1423
1.概述 异常是在程序执行过程中出现的问题。C++ 异常是对程序运行时出现的异常情况的响应，例如尝试除以零。 异常提供了一种将控制从程序的一个部分转移到另一个部分的方法。C++ 异常处理建立在三个关键字之上：try、catch和throw。 throw - 当出现问题时，程序会抛出异常。这是使用throw关键字完成的。 catch - 程序在您要处理问题的程序中使用异常处理程序捕获异常。catch关键字表示捕获异常。 try - try块标识将激活特定异常的代码块。它后面跟着一个或多个 catc
C++异常详解
wuqiongjin的博客
01-30 1903
C语言中处理错误的方式与缺陷、C++异常的介绍、C++异常关键字、异常的使用、异常的抛出和匹配原则、异常的重新抛出、自定义异常体系、异常安全、异常规范、C++标准库的异常体系、异常的优缺点
C++ 异常捕获
lyzzs222的博客
11-19 6330
C++异常的捕获机制
C++ 异常捕捉
cww_sh26的博客
12-11 3076
最近遇到一个问题，线下代码测试没问题，线上偶发性崩溃，所以加了一个异常捕获来分析问题类型，基本实现如下： #include <stdexcept> try{ fun(); } catch(exception& e){ // 这里可以捕获继承自exception的各种异常类 cout<<e.what()<<endl; } catch(...){ cout<<"unknown error\n"; .
【C++高阶(七)】C++异常处理的方式
杭电码农-NEO的博客
12-18 3234
本篇文章着重讲解了C++的异常处理方式,包括try,catch,throw三个关键字的用法以及RAII思想在异常体系中的使用.还讲解了自定义异常体系的设计和C++库中的异常体系.内附代码和图文讲解,看完就能学会
C# 捕获C/C++异常的例子
04-11
为了在C#中处理C++异常，我们需要使用`extern "C"`和`System::Runtime::InteropServices`命名空间中的特性来定义接口和方法。例如： ```csharp using System; using System.Runtime.InteropServices; ...
C++ 异常的详细介绍
01-21
c++异常为处理这种情况提供了一种功能强大的而灵活的工具。异常是相对比较新的C++功能，有些老编译器可能没有实现。另外，有些编译器默认关闭这种特性，我们可能需要使用编译器选项来启用它。 一、异常机制的使用 ...
c++异常处理
08-11
【C++异常处理】 C++异常处理是一种机制，旨在提高程序的健壮性和可靠性，它允许程序员在程序中处理可能出现的错误情况，而无需在每个可能出错的地方都插入检查和错误处理代码，从而简化了错误处理代码。C++异常...
浅谈C++ 异常处理的语义和性能
12-22
3. **C++ 加SEH**（/EHa）：这种模式同时支持C++异常和Windows的SEH异常，因此可以捕获更多类型的错误，包括系统级别的异常。这会进一步增加代码大小，因为需要处理更多的异常情况，但提高了程序的健壮性。 在讨论...
C++异常处理总结
05-12
C++异常处理总结 C++语言提供了异常处理机制，用于处理程序中的错误和异常情况。异常处理机制可以使程序结构更清晰、更健壮，并且可以防止程序崩溃。下面是C++异常处理机制的核心要点： 1. 如果使用普通的处理方式...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1222
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
规控面试常见问题
最新发布
每天进步一点点。
07-28 41
（1）A*在节点的扩张时，只会进行相邻节点的直线移动，没有考虑实际底盘的运动学模型（物理模型），而Hybrid A*在每次节点扩张的时候，会对下个位置进行离散状态空间的采样（比如 旋转角度、前进距离、前进/后退），选择动作之后就可以根据运动学模型计算下一个位置点的位姿，每次扩展的时候选择代价最小的节点进行扩展就能逐步到到目标点。// 8领域的坐标x y 和 g。A*受限于邻近栅格之间的连线，A*在搜索过程中扩展节点的方向被网格形状固定，一般为8邻接，导致路径呈波浪状，不平滑，发生抖动，冗余节点过多。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 670
C++ primer plus 第16章string 类和标准模板库, 关联容器。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zevin~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值