0
点赞
收藏
分享

微信扫一扫

（P51）异常：异常与继承，异常与指针，异常规格说明，C++标准库异常层次

流计算Alink 2023-03-07 阅读 43
c++#include派生类规格说明Html/CSS前端开发


文章目录

  • ​​1.异常与继承​​
  • ​​2.异常与指针​​
  • ​​3.异常规格说明​​
  • ​​4.C++标准库异常层次​​

1.异常与继承

  • 如果异常类型为C++的类，并且该类有其基类（基类也是一个异常类），则应该将派生类的错误处理程序放在前面，基类的错误处理程序放在后面
  • eg：P51\01.cpp

#include <iostream>
#include <string>

using  namespace std;

class MyException
{
public:
    MyException( const  char *message)
        : message_(message)
    {
        cout <<  "MyException ..." << endl;
    }
    MyException( const MyException &other) : message_(other.message_)
    {
        cout <<  "Copy MyException ..." << endl;
    }
    //因为是继承，最好声明为虚析构函数
    virtual ~MyException()
    {
        cout <<  "~MyException ..." << endl;
    }

    const  char *what()  const
    {
         return message_.c_str();
    }
private:
    string message_;
};

class MyExceptionD :  public MyException
{
public:
    MyExceptionD( const  char *message)
        : MyException(message)
    {
        cout <<  "MyExceptionD ..." << endl;
    }
    MyExceptionD( const MyExceptionD &other)
        : MyException(other)
    {
        cout <<  "Copy MyExceptionD ..." << endl;
    }
    ~MyExceptionD()
    {
        cout <<  "~MyExceptionD ..." << endl;
    }
};

int main( void)
{
    try
    {
        MyExceptionD t;
        MyExceptionD e( "test exception");//抛出一个派生类异常，是可以被基类类型捕获的，因为派生类也是一种基类对象
         throw e;//先调用派生类构造函数，构造MyExceptionD对象
    }
    catch (MyExceptionD &e)//最好将派生类的异常处理程序放在前面，为了减少对象拷贝，最好声明为引用，这样就少一次对象的拷贝
    {                       //这里是引用是不会调用拷贝构造函数，相当于是一种参数传递，传递到catch语句块中
                            输出异常对象的适合要进行栈展开，会寻找合适的catch语句块来处理,此时，局部对象t会调用析构函数进行自动销毁
        cout <<  "catch MyExceptionD ..." << endl;
        cout << e.what() << endl;
    }
    /*
    派生类的异常能够被基类所捕获，且前面的异常处理程序能够匹配的话首先catch，
    如果把基类的放在最前面，而且不是引用的形式，如 catch (MyException e); 那么将会被这个所catch 到，而且在构造e 的过程会有object slicing 的问题。
    */
    catch (MyException &e)//基类的异常处理程序放在后面，如果这里不是引用传递，这里会被切割成基类对象，引用传递
    {                       //是不会构造一个新的对象出来的，所以最好将派生类的异常处理程序放在前面，以便类型完全匹配
        cout <<  "catch MyException ..." << endl;
        cout << e.what() << endl;
    }

     return  0;
}

  • 测试：

2.异常与指针

  • 抛出指针通常是一个坏主意，因为抛出指针要求在对应处理代码存在的任意地方都存在指针所指向的对象(注意此时throw抛出时复制的是指针本身，不会去复制指针指向的内容)
    指针不能指向一个栈上的对象，因为栈上的对象会被销毁，它所指向的对象在指针存在的时候生命周期是不能结束的，否则指针则会出现空悬指针，指针所指向的对象已经被销毁了
  • eg：P51\02.cpp

#include <iostream>
#include <string>

using  namespace std;

class MyException
{
public:
    MyException( const  char *message)
        : message_(message)
    {
        cout <<  "MyException ..." << endl;
    }
    MyException( const MyException &other) : message_(other.message_)
    {
        cout <<  "Copy MyException ..." << endl;
    }
    //因为是继承，最好声明为虚析构函数
    virtual ~MyException()
    {
        cout <<  "~MyException ..." << endl;
    }

    const  char *what()  const
    {
         return message_.c_str();
    }
private:
    string message_;
};

class MyExceptionD :  public MyException
{
public:
    MyExceptionD( const  char *message)
        : MyException(message)
    {
        cout <<  "MyExceptionD ..." << endl;
    }
    MyExceptionD( const MyExceptionD &other)
        : MyException(other)
    {
        cout <<  "Copy MyExceptionD ..." << endl;
    }
    ~MyExceptionD()
    {
        cout <<  "~MyExceptionD ..." << endl;
    }
};

int main( void)
{
     try
    {
        /*
        即抛出局部对象的指针，由于在catch 时MyExeptionD 对象已经被析构了，所以访问不到e->what(); 即e是空悬指针。
        还有一点是，任何类型的指针都能被void* 指针所捕获，如果将catch (void* e);注释打开，那么由于排在前面，异常首先将被它所捕获。
        */
         MyExceptionD e("test exception");
         throw &e;//抛出一个指针，此时抛出的是指针本身，不会去复制指针所指向的内容，通常不要
                    //抛出指针，因为抛出指针还需要自己去释放指针对象，该对象不能是栈上的对象
                    //如果是栈上的对象，那么在栈展开的时候这个局部对象会被销毁，会导致e指针是一个空悬指针，因为抛出一个指针
                    //不是一个好主意
    }
    catch (void* e)//抛出的任何指针异常，都能被void*类型的指针所捕获
    {
        cout<<"catch void* ..."<<endl;
        cout<<((MyExceptionD*)e)->what()<<endl;
        delete (MyExceptionD*)e;
    }
    catch (MyExceptionD *e)
    {
        cout <<  "catch MyExceptionD ..." << endl;
        cout << e->what() << endl;
        delete e;
    }
    catch (MyException &e)
    {
        cout <<  "catch MyException ..." << endl;
        cout << e.what() << endl;
    }

     return  0;
}

  • 测试：

    • （P51）异常：异常与继承，异常与指针，异常规格说明，C++标准库异常层次_c++

  • eg：P51\03.cpp

#include <iostream>
#include <string>

using  namespace std;

class MyException
{
public:
    MyException( const  char *message)
        : message_(message)
    {
        cout <<  "MyException ..." << endl;
    }
    MyException( const MyException &other) : message_(other.message_)
    {
        cout <<  "Copy MyException ..." << endl;
    }
    //因为是继承，最好声明为虚析构函数
    virtual ~MyException()
    {
        cout <<  "~MyException ..." << endl;
    }

    const  char *what()  const
    {
         return message_.c_str();
    }
private:
    string message_;
};

class MyExceptionD :  public MyException
{
public:
    MyExceptionD( const  char *message)
        : MyException(message)
    {
        cout <<  "MyExceptionD ..." << endl;
    }
    MyExceptionD( const MyExceptionD &other)
        : MyException(other)
    {
        cout <<  "Copy MyExceptionD ..." << endl;
    }
    ~MyExceptionD()
    {
        cout <<  "~MyExceptionD ..." << endl;
    }
};

int main( void)
{
     try
    {
         //MyExceptionD e("test exception");
         //throw &e;//抛出一个指针
         /*
         现在MyExeptionD 对象是在堆上分配的，所以在catch 的时候还没释放，还可以访问到
         e->what(); 但需要自己在catch 末尾delete e;
         */
         throw  new MyExceptionD( "test exception");
    }
     /*catch (void* e)//抛出的任何指针，都能被void*类型的指针所捕获
    {
        cout<<"catch void* ..."<<endl;
        cout<<((MyExceptionD*)e)->what()<<endl;
        delete (MyExceptionD*)e;
    }*/
     catch (MyExceptionD *e)
    {
        cout <<  "catch MyExceptionD ..." << endl;
        cout << e->what() << endl;
        delete e;
    }
     catch (MyException &e)
    {
        cout <<  "catch MyException ..." << endl;
        cout << e.what() << endl;
    }

     return  0;
}

  • 测试：

3.异常规格说明

  • （1）异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。
  • （2）可以在函数的声明中列出这个函数可能抛掷的所有异常类型。
    例如：

void fun() throw(A，B，C，D);

  • （3）若无异常接口声明，则此函数可以抛掷任何类型的异常。
  • （4）不抛掷任何类型异常的函数声明如下：

void fun() throw();

  • eg：P51\04.cpp

#include <iostream>
#include <string>

using  namespace std;

class MyException
{
public:
    MyException( const  char *message)
        : message_(message)
    {
        cout <<  "MyException ..." << endl;
    }
    MyException( const MyException &other) : message_(other.message_)
    {
        cout <<  "Copy MyException ..." << endl;
    }
    //因为是继承，最好声明为虚析构函数
    virtual ~MyException()
    {
        cout <<  "~MyException ..." << endl;
    }

    const  char *what()  const
    {
         return message_.c_str();
    }
private:
    string message_;
};

class MyExceptionD :  public MyException
{
public:
    MyExceptionD( const  char *message)
        : MyException(message)
    {
        cout <<  "MyExceptionD ..." << endl;
    }
    MyExceptionD( const MyExceptionD &other)
        : MyException(other)
    {
        cout <<  "Copy MyExceptionD ..." << endl;
    }
    ~MyExceptionD()
    {
        cout <<  "~MyExceptionD ..." << endl;
    }
};

void fun( int n)  throw ( int, MyException, MyExceptionD)
{
     if (n ==  1)
    {
         throw  1;
    }
     else  if (n ==  2)
    {
         throw MyException( "test Exception");
    }
     else  if (n ==  3)
    {
         throw MyExceptionD( "test ExceptionD");
    }

}

void fun2()  throw()
{

}

int main( void)
{
     try
    {
        fun( 2);
    }

     catch ( int n)
    {
        cout <<  "catch int ..." << endl;
        cout <<  "n=" << n << endl;
    }
     catch (MyExceptionD &e)
    {
        cout <<  "catch MyExceptionD ..." << endl;
        cout << e.what() << endl;
    }
     catch (MyException &e)
    {
        cout <<  "catch MyException ..." << endl;
        cout << e.what() << endl;
    }

     return  0;
}

  • 测试：
    就是说VC++编译器现在还不怎么支持异常规格说明，举个例子说，void fun(int n) throw (int, MyException, MyExceptionD); 没有声明double 类型的异常，但在函数内throw 1.0; 在外部catch (double) 还是会成功。

4.C++标准库异常层次

  • 比如dynamic_cast 执行错误会产生bad_cast 异常，new 分配内存错误会产生bad_alloc 异常，其实这些异常类都继承自exception类，但内部的实现都没有有效的代码，只是用来标识当前程序产生了哪种类型的异常而已。

    • （P51）异常：异常与继承，异常与指针，异常规格说明，C++标准库异常层次_#include_02

  • 参考：从零开始学C++之异常（三）：异常与继承、异常与指针、异常规格说明


举报

相关推荐

C++异常处理，标准库中异常

c++

【C++】异常处理 ⑧ ( 标准异常类 | 标准异常类继承结构 | 常用的标准异常类 | 自定义异常类继承 std::exception 基类 )

c++异常异常处理标准异常类exceptionPython后端开发

（P32-P33）异常处理：Python标准异常总结，异常处理，raise

icoPython子类HarmonyOS后端开发

同步异常与异步异常

系统调用javascript虚拟化云计算

【C++】异常处理 ⑦ ( 异常类的继承层次结构 | 抛出 / 捕获 多个类型异常对象 | 抛出子类异常对象 / 捕获并处理 父类异常对象 )

c++开发语言异常处理异常捕获异常Redis数据库

C++——异常

c++

【C++】异常

c++开发语言

c++异常

spring boot后端java在线互动学习系统互动学习系统Powered by 金山文档

C++(异常)

c++笔记开发语言

C++异常

c++开发语言
0 条评论