C/C++异常处理总结

最新推荐文章于 2023-11-29 14:02:35 发布

帝都小鸟

最新推荐文章于 2023-11-29 14:02:35 发布

阅读量490

点赞数

分类专栏： c++ 文章标签： c++

本文链接：https://blog.csdn.net/tanlovezhao/article/details/108083644

版权

c++ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.C的异常处理

c语言异常处理使用较少，给出具体事例代码：

c语言异常处理的结构体 jmp_buf

typedef struct
{
    unsigned j_sp;  // 堆栈指针寄存器
    unsigned j_ss;  // 堆栈段
    unsigned j_flag;  // 标志寄存器
    unsigned j_cs;  // 代码段
    unsigned j_ip;  // 指令指针寄存器
    unsigned j_bp; // 基址指针
    unsigned j_di;  // 目的指针
    unsigned j_es; // 附加段
    unsigned j_si;  // 源变址
    unsigned j_ds; // 数据段
} jmp_buf;

示例代码：（通过宏的方式进行c++的模拟）

#include"stdio.h"
#include"conio.h"
#include"setjmp.h"
jmp_buf Jump_Buffer;
#define try if(!setjmp(Jump_Buffer))
#define catch else
#define throw longjmp(Jump_Buffer,1)
int Test(int T)
{
    if(T>100)
        throw;
    else
          puts("OK.");
    return 0;
}
int Test_T(int T)
{
    Test(T);
    return 0;
}
int main()
{
    int T;
    try{
          puts("Input a value:");
          scanf("%d",&T);
          T++;
          Test_T(T);
      } catch{
          puts("Input Error!");
      }
    getch();
    return 0;
}

说明：调用setjmp将当前程序的栈信息保存到jmp_buf并返回0，当程序出错时通过longjmp跳转到jmp_buf的位置并返回错误码1；

1.非常类似于goto，比goto稍微好点，增强了可读性；

2.内存的释放只能通过错误码的方式，程序员自己在“#define catch else”中进行处理；

3.有文章说这种方式应用到c++上会导致栈上类的析构函数不调用，这种对比不科学，C比C++先出来，当然不会去兼容C++；因为C没有gc所以其实对于C而言这已经是非常好的方式了；

2.C++的异常处理

try{
    //do something
    throw string("this is exception");
} catch(const string& e) {
    cout << "catch a exception " << e << endl;
}

c++异常重点说明需要注意的地方：

异常不会对基本类型做转换，下面输出的是c；

try{
    throw 'a';
}catch(int a) {
    cout << "int" << endl;
}catch(char c) {
    cout << "char" << endl;
}

允许从派生类到基类的类型转换

//基类
class Base{
    public:
        Base(string msg):m_msg(msg)
        {
        }
        virtual void what(){
            cout << m_msg << endl;
        }
    protected:
        string m_msg;
};
//派生类，重新实现了虚函数
class CBase : public Base
{
    public:
        CBase(string msg):Base(msg)
        {

        }
        void what()
        {
           cout << "CBase:" << m_msg << endl;
        }
        void test()
        {
            cout << "I am a CBase" << endl;
        }
};

int main()
{
    try {
        //do some thing
    //抛出派生类对象
        throw CBase("I am a CBase exception");
    }catch(Base& e) {  //使用基类可以接收
        e.what();
    }
}

允许非常量到常量的类型转换，也就是说可以抛出一个非常量类型，然后使用catch捕捉对应的常量类型版本
允许数组被转换为数组指针，允许函数被转换为函数指针

可以使用…捕获所有异常

    try{
        throw Exception("I am a exception");    
    }catch(...) {
        //log the exception
        throw;
    }

默认异常处理函数，set_terminate函数可以用来设置自己的terminate函数

#include <exception>
#include <iostream>
#include <cstdlib>
using namespace std;

class MyError {
    const char* const data;
public:
    MyError(const char* const msg = 0):data(msg)
    {
        //idle
    }
};

void do_error() {
    throw MyError("something bad happend");
}
//自定义的terminate函数，函数原型需要一致
void terminator()
{
    cout << "I'll be back" << endl;
    exit(0);
}

int main()
{
    //设置自定义的terminate，返回的是原有的terminate函数指针
    void (*old_terminate)() = set_terminate(terminator);
    do_error();
}
上面的代码会输出I'll be back

标准异常类

C++ 提供了一系列标准的异常，定义在中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：

C++ 异常的层次结构

下表是对上面层次结构中出现的每个异常的说明：

异常	描述
std::exception	该异常是所有标准 C++ 异常的父类。
std::bad_alloc	该异常可以通过 new 抛出。
std::bad_cast	该异常可以通过 dynamic_cast 抛出。
std::bad_exception	这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid	该异常可以通过 typeid 抛出。
std::logic_error	理论上可以通过读取代码来检测到的异常。
std::domain_error	当使用了一个无效的数学域时，会抛出该异常。
std::invalid_argument	当使用了无效的参数时，会抛出该异常。
std::length_error	当创建了太长的 std::string 时，会抛出该异常。
std::out_of_range	该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator。
std::runtime_error	理论上不可以通过读取代码来检测到的异常。
std::overflow_error	当发生数学上溢时，会抛出该异常。
std::range_error	当尝试存储超出范围的值时，会抛出该异常。
std::underflow_error	当发生数学下溢时，会抛出该异常。

定义自己的异常：

#include <iostream>
#include <exception>
using namespace std;
 
struct MyException : public exception
{
  const char * what () const throw ()
  {
    return "C++ Exception";
  }
};
 
int main()
{
  try
  {
    throw MyException();
  }
  catch(MyException& e)
  {
    std::cout << "MyException caught" << std::endl;
    std::cout << e.what() << std::endl;
  }
  catch(std::exception& e)
  {
    //其他的错误
  }
}

3.C++异常的安全处理

注意点：

1.C++异常使用最主要的是需要避免内存泄露，C++只是保证栈上已经构造的对象正常析构，并不能保证非RAII的资源正常析构，也不能保证事务的完整性。其实在没有gc的情况下要保证C++异常使用的安全是一件需要非常小心的事情。

2.C++异常是可以再构造函数抛出，但是该对象的析构函数不会调用。；其实很好理解分配内存就能抛出异常。

3.析构函数不应该抛出异常（如果抛出异常也要自己吃掉）。

C++异常安全的三个层面：

1.no_throw guarantee 不抛出异常使用关键字nothrow标识

2.basic exception safety guarantee 不会产生内存泄露

3.strong exception safety guarantee 事务上的原子性，通过copy swap保证事务的原子性。

其实要实现这三个安全，个人感觉非常难。

4.为什么析构函数不能抛出异常

 class Base
 {
 public:
    void fun()     {   throw 1;    }
    ~Base()        {   throw 2;    }
 };
 
 int main()
 {
   try
   {
       Base base;
      //base.fun();
   }
   catch (...)
   {
       //cout <<"get the catch"<<endl;
   }
 }

如果在base.fun()抛出异常后，在执行catch就会对base进行析构，如果这时析构再抛出异常就不能进行catch，windows平台会直接崩溃。