65-C++中的异常处理(下)

最新推荐文章于 2023-08-27 16:42:15 发布
最新推荐文章于 2023-08-27 16:42:15 发布
阅读量315 收藏
点赞数
分类专栏： # C++基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaoguo60/article/details/108636428
版权

注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。

测试环境：Ubuntu 10.10

GCC版本：9.2.0

 

一、C++中的异常处理

1）catch语句块中可以抛出异常

 需要其它处理异常的代码，接受异常。

try...catch...异常处理中，也有初始化，不过没有转换，必须严格匹配。

try...catch(...)...异常匹配为任意类型，但是不知道参数类型，只能throw再抛出异常（原有类型）

 

问题

            为什么要在catch中重新抛出异常？

2）catch中捕获的异常可以被重新解释后抛出

3）工程开发中使用这样的方式统一异常类型

 

编程实验
异常的重新解释
65-1.cpp
#include <iostream>
#include <string>

using namespace std;

void Demo()        //正常
{
    try
    {
        try
        {
            throw 'c';
        }
        catch(int i)
        {
            cout << "Inner: catch(int i)" << endl;
            throw i;
        }
        catch(...)    //第一次捕捉
        {
            cout << "Inner: catch(...)" << endl;
            throw;
        }
    }
    catch(...)        //外层，第二次捕捉
    {
        cout << "Outer: catch(...)" << endl;
    }
}


/*
    假设： 当前的函数是第三方库中的函数，因此，我们无法修改源代码
    
    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/
void func(int i) //假设这个函数是第三的，不能修改，也就是说这个函数只能被调用！
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func..." << endl;
}

void MyFunc(int i)    //第三方库的异常理解困难，获取第三方库的异常，重新解释异常
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw "Invalid Parameter";
                break;
            case -2:
                throw "Runtime Exception";
                break;
            case -3:
                throw "Timeout Exception";
                break;
        }
    }
}

int main(int argc, char *argv[])
{
    // Demo();
    
    try
    {
        MyFunc(11);
    }
    catch(const char* cs)    //字符串异常，参数类型必须为const char*
    {
        cout << "Exception Info: " << cs << endl;
    }
    
    return 0;
}

操作：

1) g++ 65-1.cpp -o 65-1.out编译正确，打印结果：

Inner:catch(...)
Outer:catch(...)

分析：

        证明异常可以被捕获进行重新解释。

 

2)在func中抛出异常：

#include <iostream>
#include <string>

using namespace std;

/*
    假设： 当前的函数是第三方库中的函数，因此，我们无法修改源代码
    
    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/
void func(int i) //假设这个函数是第三的，不能修改，也就是说这个函数只能被调用！
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func..." << endl;
}

void MyFunc(int i)    //第三方库的异常理解困难，获取第三方库的异常，重新解释异常
{
    try
    {
        func(i);    //抛出异常
    }
    catch(int i)
    {
        switch(i)    //重新解释异常
        {
            case -1:
                throw "Invalid Parameter";    
                break;
            case -2:
                throw "Runtime Exception";
                break;
            case -3:
                throw "Timeout Exception";
                break;
        }
    }
}

int main(int argc, char *argv[])
{  
    try
    {
        MyFunc(11);
    }
    catch(const char* cs)    //字符串异常，参数类型必须为const char*
    {
        cout << "Exception Info: " << cs << endl;
    }
    
    return 0;
}

操作：g++ 65-1.cpp -o 65-1.out编译正确，打印结果：

Exception Info: Timeout Exception

分析：

        模拟使用第三方库中的函数，重新解释抛出的异常。

 

4）异常的类型可以是自定义类类型

5）对于类类型异常的匹配依旧是至上而下严格匹配

6）赋值兼容性原则在异常匹配中依然使用

7）一般而言

        -    匹配子类异常的catch放在上部

        -    匹配父类异常的catch放在下部

8）在工程中会定义一系列的异常类

9）每个类代表工程中可能出现的一种异常类型

10）代码复用时可能需要重解释不同的异常类

11）在定义catch语句块时推荐使用引用作为参数

编程实验
类类型的异常（使用展示）
65-2.cpp
#include <iostream>
#include <string>

using namespace std;

class Base
{
};

class Exception : public Base
{
    int m_id;            //异常ID
    string m_desc;    //异常描述信息
public:
    Exception(int id, string desc)
    {
        m_id = id;
        m_desc = desc;
    }
    
    int id() const
    {
        return m_id;
    }
    
    string description() const
    {
        return m_desc;
    }
};


/*
    假设： 当前的函数式第三方库中的函数，因此，我们无法修改源代码
    
    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/
void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func..." << endl;
}

void MyFunc(int i)
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw Exception(-1, "Invalid Parameter");    //异常类
                break;
            case -2:
                throw Exception(-2, "Runtime Exception");
                break;
            case -3:
                throw Exception(-3, "Timeout Exception");
                break;
        }
    }
}

int main(int argc, char *argv[])
{
    try
    {
        MyFunc(11);
    }
    catch(const Exception& e)    //防止拷贝构造，提高程序效率
    {
        cout << "Exception Info: " << endl;
        cout << "   ID: " << e.id() << endl;
        cout << "   Description: " << e.description() << endl;
    }
    catch(const Base& e)
    {
        cout << "catch(const Base& e)" << endl;
    }
    
    return 0;
}

操作：

1) g++ 65-2.cpp -o 65-2.out编译正确，打印结果：

Exception Info:
ID: -3
Description: Timeout Exception

将父类异常处理放在子类前边：

int main(int argc, char *argv[])
{
    try
    {
        MyFunc(11);
    }
    catch(const Base& e)//如果将父类放在前边，父子兼容性原则，就去执行父类异常
    {
        cout << "catch(const Base& e)" << endl;
    }
    catch(const Exception& e)    //防止拷贝构造，提高程序效率
    {
        cout << "Exception Info: " << endl;
        cout << "   ID: " << e.id() << endl;
        cout << "   Description: " << e.description() << endl;
    }    
    
    return 0;
}

g++ 65-2.cpp -o 65-2.out编译有警告：

65-2.cpp:86:2: warning: exception of type ‘Exception’ will be caught [enabled by default]
  catch(const Exception& e)
  ^
警告：'Exception'异常类型将要被捕获(子类能被父类类型捕获)  
65-2.cpp:82:2: warning:    by earlier handler for ‘Base’ [enabled by default]
  catch(const Base& e)
警告：最先被'Base'处理

分析：

        证明：捕获异常时由于赋值兼容性原则，父类类型可以捕获子类类型异常。因此父类类型建议放在子类异常处理后边。

 

12）C++标准库中提供了实用异常类族

13）标准库中的异常都是从exception类派生的

14）exception类有两个主要的分支

        -    logic_error

            *常用于程序中的可避免逻辑错误

        -    runtime_error

            *常用于程序中无法避免的恶性错误

15）标准库中的异常

 

编程实验
标准库中的异常使用
array.h
#ifndef _ARRAY_H_
#define _ARRAY_H_

#include <stdexcept>

using namespace std;

template
< typename T, int N >
class Array
{
    T m_array[N];
public:
    int length() const;
    bool set(int index, T value);
    bool get(int index, T& value);
    T& operator[] (int index);
    T operator[] (int index) const;
    virtual ~Array();
};

template
< typename T, int N >
int Array<T, N>::length() const
{
    return N;
}

template
< typename T, int N >
bool Array<T, N>::set(int index, T value)
{
    bool ret = (0 <= index) && (index < N);
    
    if( ret )
    {
        m_array[index] = value;
    }
    
    return ret;
}

template
< typename T, int N >
bool Array<T, N>::get(int index, T& value)
{
    bool ret = (0 <= index) && (index < N);
    
    if( ret )
    {
        value = m_array[index];
    }
    
    return ret;
}

template
< typename T, int N >
T& Array<T, N>::operator[] (int index)
{
    if( (0 <= index) && (index < N) )
    {
        return m_array[index];
    }
    else
    {
        throw out_of_range("T& Array<T, N>::operator[] (int index)");
    }
}

template
< typename T, int N >
T Array<T, N>::operator[] (int index) const
{
    if( (0 <= index) && (index < N) )
    {
        return m_array[index];
    }
    else
    {
        throw out_of_range("T Array<T, N>::operator[] (int index) const");
    }
}

template
< typename T, int N >
Array<T, N>::~Array()
{

}

#endif


heapArray.h
#ifndef _HEAPARRAY_H_
#define _HEAPARRAY_H_

#include <stdexcept>

using namespace std;

template
< typename T >
class HeapArray
{
private:
    int m_length;
    T* m_pointer;
    
    HeapArray(int len);
    HeapArray(const HeapArray<T>& obj);
    bool construct();
public:
    static HeapArray<T>* NewInstance(int length); 
    int length() const;
    bool get(int index, T& value);
    bool set(int index ,T value);
    T& operator [] (int index);
    T operator [] (int index) const;
    HeapArray<T>& self();
    const HeapArray<T>& self() const;
    ~HeapArray();
};

template
< typename T >
HeapArray<T>::HeapArray(int len)
{
    m_length = len;
}

template
< typename T >
bool HeapArray<T>::construct()
{   
    m_pointer = new T[m_length];
    
    return m_pointer != NULL;
}

template
< typename T >
HeapArray<T>* HeapArray<T>::NewInstance(int length) 
{
    HeapArray<T>* ret = new HeapArray<T>(length);
    
    if( !(ret && ret->construct()) ) 
    {
        delete ret;
        ret = 0;
    }
        
    return ret;
}

template
< typename T >
int HeapArray<T>::length() const
{
    return m_length;
}

template
< typename T >
bool HeapArray<T>::get(int index, T& value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        value = m_pointer[index];
    }
    
    return ret;
}

template
< typename T >
bool HeapArray<T>::set(int index, T value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        m_pointer[index] = value;
    }
    
    return ret;
}

template
< typename T >
T& HeapArray<T>::operator [] (int index)
{
    if( (0 <= index) && (index < length()) )
    {
        return m_pointer[index];
    }
    else
    {
        throw out_of_range("T& HeapArray<T>::operator [] (int index)");
    }
}

template
< typename T >
T HeapArray<T>::operator [] (int index) const
{
    if( (0 <= index) && (index < length()) )
    {
        return m_pointer[index];
    }
    else
    {
        throw out_of_range("T HeapArray<T>::operator [] (int index) const");
    }
}

template
< typename T >
HeapArray<T>& HeapArray<T>::self()
{
    return *this;
}

template
< typename T >
const HeapArray<T>& HeapArray<T>::self() const
{
    return *this;
}

template
< typename T >
HeapArray<T>::~HeapArray()
{
    delete[]m_pointer;
}


#endif

65-3.cpp
#include <iostream>
#include <string>
#include "Array.h"
#include "HeapArray.h"

using namespace std;

void TestArray()
{
    Array<int, 5> a;
    
    for(int i=0; i<a.length(); i++)
    {
        a[i] = i;
    }
        
    for(int i=0; i<a.length(); i++)
    {
        cout << a[i] << endl;
    }
}

void TestHeapArray()
{
    HeapArray<double>* pa = HeapArray<double>::NewInstance(5);
    
    if( pa != NULL )
    {
        HeapArray<double>& array = pa->self();
        
        for(int i=0; i<array.length(); i++)
        {
            array[i] = i;
        }
            
        for(int i=0; i<array.length(); i++)
        {
            cout << array[i] << endl;
        }
    }
    
    delete pa;
}

int main(int argc, char *argv[])
{
    
    try
    {
        TestArray();
        
        cout << endl;
        
        TestHeapArray();
    }
    catch(...)
    {
        cout << "Exception" << endl;
    }
    
    return 0;
}

 

小结

1）catch语句块中可以抛出异常

2）异常的类型可以是自定义类类型

3）赋值兼容性原则在异常匹配中依然使用

4）标准库中的异常都是从exception类派生的

 

喂你的猴子跑了
关注
专栏目录
C++软件调试与异常排查从入门到精通系列文章汇总
dvlinker的技术专栏
06-29 19万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
C++ Exception
weixin_33998125的博客
07-05 187
Exception Classes for Language SupportExceptions for language support are used by language features. So in a way they are part of the core language rather than the library. These exceptions are thrown...
C++中的异常处理（下）
05-24 147
1，catch 语句块中可以抛出异常： 1，示意图： 2，func() 在 try 语句块中，说明它有可能抛出异常，抛出的异常有可能是整型或其它类型； 3，catch 语句块处理方式是将异常重新抛出去，其它什么也不干； 4，此时需要外层的其它 try ... catch 语句块处理； 5，catch() 中的参数类似于函数里面的参数...
C++ 之 exception
绝知此事要躬行
10-10 1818
本文讲关于C++的异常的所有东西： 绝对不让异常逃离析构函数 阻止exception逃离析构函数，主要是两个原因： 1 防止在异常处理过程中的栈展开行为时，将调用terminate函数。程序将会结束，有时候其实错误并没有那么严重。 [插入： 什么时候会调用terminate函数呢？] [回答 ： By default, the terminate handler call
C++异常处理
u013571243的专栏
10-23 543
An exception is a problem that arises during the execution of a program. A C++ exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divi
gcc/linux下的c++异常实现
最新发布
不会写代码的丝丽
08-27 717
本文不一定具有很好的说教性，仅作为自我学习的笔记。不妨可参阅国外大神博文链接中包含了大量的例子。偶有在对做分析的时候看到如下图一些注释，部分关键字看不懂，比如什么FDEunwind等是什么？由于笔者在开发领域，因此偏向下做实现，部分源码有时候会参阅或者版本。
C++中异常处理的基本思想及throw语句抛出异常的使用
09-02
总的来说，C++的异常处理提供了一种高效且灵活的方式来处理程序中的异常情况，它使得错误处理更加模块化和易于管理，同时保证了资源的正确释放。理解异常处理的基本思想和语法对于编写健壮的C++代码至关重要。
C、C++、Java语言中异常处理机制浅析
01-31
例如，在设计程序时，如果可能会碰到除0错误或者数组访问越界错误，程序员应该在程序中设计相应的异常处理代码以便发生异常情况时，程序做出相应的处理。（1）终止模型在这种模型中，异常是致命的，它一旦发生，将...
C++之异常处理详解
12-26
程序中的错误分为编译时的错误和运行时的错误。编译时的错误主要是语法错误，比如：句尾没有加分号，...C++中所提供的异常处理机制结构清晰，在一定程度上可以保证程序的健壮性。 C++中处理异常的过程是这样的：在执
C和C++中的异常处理
06-09
3. 标准 C++异常处理的基本语法和语义 4. 实例剖析 EH 5. C++的 new 和 delete 操作时的异常处理 6. Microsoft 对于的实现版本中的异常处理 7. 部分构造及 placement delete 8. 自动删除，类属 new 和 delete、...
Exception of type 'System.OutOfMemoryException' was thrown.
weixin_34336292的博客
09-15 1911
[OutOfMemoryException: Exception of type 'System.OutOfMemoryException' was thrown.] 在装有4G物理内存的32位OS机器上内存不足，原因是：The common language runtime throws an OutOfMemoryException error if it cannot allocate ph...
Exception of type 'System.OutOfMemoryException' was thrown
weixin_30814319的博客
05-16 1325
最近刚换了服务器，开始测试的时候未发现什么问题，可是一旦同一时间段操作的人比较多的时候，就会抛出如下错误： Server Error in '/' Application. Exception of type 'System.OutOfMemoryException' was thrown. Description: An unhandled exception occu...
农行网银 交易失败 CI79:Exception of typ
ksrsoft的专栏
11-08 4269
k宝没有，证书没有问题，密码没有问题，电脑换了几台，可是每次输完密码就出现这个提示： 交易失败!   CI79:Exception of type 'Ebf.Core.BusinessComposer.ExceptionModel.EBException' was thrown.
学习C++：C++基础（三）泛型编程&C++模板
qq_41694024的博客
06-10 374
C++ 泛型编程：函数模板及类模板
自己编译时候的一个警告by earlier handler for ‘std::exception’
digitalkee的博客
02-01 226
关于异常的一个警告
C++ exception with description “bad optional access“ thrown in the test body.
weixin_45022086的博客
12-17 4272
昨天写完代码跑case的时候，返现一个很奇怪的问题 case的log里面报了这样一个错误： C++ exception with description “bad optional access” thrown in the test body. 这个错误应该是代码里面对一个空的optional类型的变量取值了，但是我从gdb看backtrace竟然没找到调用栈，bt出来显示的全是gtest.so的东西，导致我以为是测试的framework还不支持这个case的异常场景 后来别人说这是std::option
模板类实现数组
周杰伦
09-02 768
模板类实现数组 . #include&lt;iostream&gt; using namespace std; //数组：是一块连续空间 template&lt;typename T&gt; class Array { public: //声明构造器 Array(); Array(T*,int); T at(int );//返回指定位置的元素 unsigned short ...
c#中 Exception of type 'System.OutOfMemoryException' was throw的解决办法
autumn20080101的专栏
05-18 1808
c#中 Exception of type 'System.OutOfMemoryException' was throw的解决办法 2014-11-06 21:56 1134人阅读 评论(0) 收藏 举报 本文章已收录于： 分类： Ｃ#编程技术（36） 作者同类文章X 版权声明：本文为博主原创文章，未经博
【Xcode】libc++abi.dylib: terminating with uncaught exception of type NSException (lldb)
冯一朔 - 不想当CTO的程序员不是一个好哲学家
09-22 4953
今天，Xcode虚拟机启动遇到了这个错误，由于打包的时候，AppDelegate.m选择的是Release，之后虚拟机启动忘记更改回来，一直在启动页报这个异常。 解决办法：改回Debug，Product --> Clean，重新运行即可。 感兴趣的朋友可以关注一下，分享讨论交流技术~，不定期发放福利
C与C++异常处理深度解析
"C与C++中的异常处理.pdf" 是一本深入探讨C和C++异常处理机制的书籍，由Robert Schmidt撰写并由无情翻译。本书旨在帮助读者理解这两种编程语言中的错误处理策略。 异常处理是编程中至关重要的一部分，它允许程序员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值