C++异常

最新推荐文章于 2024-06-01 17:17:13 发布
最新推荐文章于 2024-06-01 17:17:13 发布
阅读量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++ throw
weixin_45743799的博客
03-19 8574
我们知道C++ 异常处理的流程，具体为： 抛出（Throw）--> 检测（Try） --> 捕获（Catch） 异常必须显式地抛出，才能被检测和捕获到；如果没有显式的抛出，即使有异常也检测不到。 在 C++ 中，我们使用 throw 关键字来显式地抛出异常，它的用法为： throw exceptionData; exceptionData 是“异常数据”的意思，它可以包含任意的信息...
C++之throw和exception
weixin_43667308的博客
01-26 2187
throw 是C++中的关键字，用来抛出异常。如果不使用 throw 关键字，try 就什么也捕获不到； at() 函数在内部也使用了 throw 关键字来抛出异常。 throw 既可以用在标准库中，也可以用在自定义的函数中，抛出我们期望的异常。throw 关键字语法为： throw exceptionData; exceptionData 是“异常数据”的意思，它既可以是一个普通变量，也可以是...
C++中的throw和exception简述
jingwawa666的博客
03-05 1万+
throw 是C++中的关键字，用来抛出异常。如果不使用 throw 关键字，try 就什么也捕获不到；上节提到的 at() 函数在内部也使用了 throw 关键字来抛出异常。throw 既可以用在标准库中，也可以用在自定义的函数中，抛出我们期望的异常。throw 关键字语法为：throw exceptionData;exceptionData 是“异常数据”的意思，它既可以是一个普通变量，也可以...
C++中的 throw详解
最新发布
APItesterCris的博客
06-01 794
虽然 func() 函数中发生了异常，但是由于 throw 限制了函数只能抛出 char*、exception 类型的异常，所以 try-catch 将捕获不到异常，只能交给系统处理，终止程序。throw 关键字除了可以用在函数体中抛出异常，还可以用在函数头和函数体之间，指明当前函数能够抛出的异常类型，这称为异常规范（Exception specification），有些教程也称为异常指示符或异常列表。如此，func() 函数就不能抛出任何类型的异常了，即使抛出了，try 也检测不到。
C++异常(exception)
weixin_56169816的博客
07-11 3260
​ 所谓的异常就是不正常，指在程序运行的过程中，由于系统条件、操作不当等原因所引起的程序运行错误​ 常见的异常：除零错误、指针访问受保护的空间、数组越界、内存分配失败、打开的文件不错在…在C++中，新增加了一种错误(异常)处理方式编译时错误：在程序编译阶段就能够发现的错误运行时错误：编译能够通过，在运行的时候会有一些错误产生为了提高系统的健壮性，加强容错能力，在编程过程中，这些错误(异常)必须要处理，防止系统崩溃。
try-catch和throw,throws的区别
zuo_er_lyf的博客
12-09 930
java里的异常多种多样，这是一种非常有用的机制，它能帮助我们处理那些我们未知的错误，在java里，关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。 1.throw throw 就是抛出一个异常，并获取这个异常的引用，这个异常会被抛到外部的环境，由外部环境进行处理 class A{ public void func() throws Exc...
C++异常处理
GangStudyIT的博客
06-14 245
c++中异常处理 程序在运行过程中，有对也就有错，正确那么就不用说了，但是如果错误，那么我们如何快速的定位到错误的位置，以及知道发生了什么错误，在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. 如果使用普通的处理方式...
Java的throws Exception
hanxiaoyong_的博客
04-21 7万+
转：https://www.cnblogs.com/feichengwulai/articles/3793261.html 1、(终极解释！！！)throwsException放在方法后边，是throwsException表示的是本方法不处理异常，交给被调用处处理(如果你不希望异常层层往上抛，你就要用throws Exception)，而且被调用处必须处理。 2、throw new Exce...
C++ 异常处理（throw、try、catch）
qq_43799400的博客
04-09 3018
文章目录一、throw表达式二、try语句块（try--catch语句） 参考《C++ Primer 第五版》P172 一、throw表达式 一个简单的例子： #include <iostream> using namespace std; int main() { int a=5,b=0; if(b==0) throw b; //抛出异常 return 0; } //output: terminate called after throwing
C++的throw抛出异常机制
ArtAndLife的博客
08-22 1万+
关于C++的“抛出异常”机制： 关键点： （1）throw是将抛出的表达式的值拷贝到“异常对象”中，catch则是根据异常对象进行参数匹配并处理异常； （2）throw可一次性跳出多层函数调用，直到最近一层的try语句，称为“栈展开”； （3）catch捕获时是将异常对象与catch参数的进行 类型比较，而不是值比较，所以只要类型相同，就可以进入catch中处理。（例如throw抛出一个int类型的值，catch(int &i)就可以对其进行处理；或者throw抛出一个类对象，catch(Base&
【C++】异常处理
Hi, Boy
11-02 258
如果你写的方法是给他人使用，那么，如果这个方法失败，最好是以抛异常的方式告诉别人，而不是在方法声明的地方写注释：“0：成功，1：网络连接失败，3：参数错误”。
C++ 异常 exception throw
绝知此事要躬行
02-24 6119
之前很少用到C++的exception机制，看到C++ Primer的第6章，简要的介绍一下： 首先，C++ 的异常处理包括： throw表达式。如： #include #include using namespace std; int main() { int x; while(cin >> x) { if (x == 0) { throw runtime_error(
c++ try catch 问题
热门推荐
windhaunting的专栏
10-27 8万+
try{} catch(…){}以前都是用try{} catch(…){}来捕获C++中一些意想不到的异常， 今天看了Winhack的帖子才知道，这种方法在VC中其实是靠不住的。例如下面的代码：try { BYTE* pch ; pch = ( BYTE* )00001234 ;   //给予一个非法地址 *pch = 6 ; //对非法地址赋值，会造成Access V
C++异常处理深度解析
"一本关于C++异常处理的书籍，作者为Robert Schmidt，译者为无情。本书涵盖了C和C++中的异常处理机制，包括标准C++异常处理的基本语法和语义，异常安全，模板安全等内容，并探讨了如何混合使用C++异常和Visual C++的...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Zevin~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值