c++中的异常处理

最新推荐文章于 2021-08-13 16:47:27 发布

转载最新推荐文章于 2021-08-13 16:47:27 发布 · 418 阅读

c++中的异常处理
try ,将可能发生异常的代码块括起来；
catch,处理异常代码块；
throw，抛出异常对象。
一般情况下，try与catch二者是不可分割的。
例如：

#include<iostream>
#include<fstream>
using namespace std;
int main()
{
    bool running = false;
while(!running)
{
    int a = 0;
    int b = 0;
    int c = 0;
    try      //try不会影响代码的执行流程
    {
        cin>>a>>b>>c;
        if(a<=0||b<=0||c<=0)
        {
            throw "input is invalid!";
        }
        //try中，throw后面的代码不执行。
    }
    catch(const char *errstr)  //专门处理异常代码块
    {
        cout<<errstr<<endl;
    }

}
return 0;
}
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

从上面代码中，我们可以看到在try中，throw后面的代码是不执行的，所以平时就会忽略这个问题，从而导致代码出现bug,这个也是笔试时经常出现的一类问题。

 接下来就用这个例子简单的看一下。

>   try
    {
        int *p = new int;
        ofstream outf("data.txt");//资源的开辟
        cin>>a>>b>>c;
        if(a<=0||b<=0||c<=0)
        {
            throw "input is invalid!";
            // 抛出异常，即抛出常量字符串
        }
        delete p;
        outf.close();//资源的删除
}
catch(const char *errstr)//专门处理异常代码块
    {
        cout<<errstr<<endl;
        delete p;
        outf.close();
    }

 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

我们在try函数中，进行了资源的开辟与释放，一旦我们的输入有问题，我们的throw函数将会截断try函数，使其不会继续进行下去，这样会造成内存泄漏问题。所以我们必须在每个catch里面进行资源的释放。（C++11版本或许会有Finally函数进行统一释放。）

template<typename T,int SIZE>
class CArray
{
public:
    CArray()
    {
        cout<<this<<endl;
        cout<<"CArray()"<<endl;
        mCur = 0;
    }
    ~CArray()
    {
        cout<<this<<endl;
        cout<<"~CArry()"<<endl;
    }
    void push_back(const T &val)
    {
        if(mCur >= SIZE)
        {
            throw "array is false";
        }
        mArr[mCur++] = val;
    }
    void pop_back()
    {
        mCur--;
    }
    T& operator[](int index)
    {
        return mArr[index];
    }
private:
    T mArr[SIZE];
    int mCur;
};
void func1()
{
    CArray<int,5> arr1;
    try
    {
        for(int i=0;i<6;++i)
        {
            arr1.push_back(rand()%100+1);
        }
    }
    catch(const char* err)
    {
        cerr<<err<<endl;
        //cerr对应标准错误流，用于显示错误消息。默认情况下被关联到标准输出流，但它不被缓冲.
    }
}
int main()
{
    func1();
    return 0;
}
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

经过上面的代码，关于异常处理我们可以得出下面俩点：
1、异常处理后，抛到相应的catch块处理，处理完以后，程序仍然可以继续执行。
2、抛出异常，不仅仅是抛出常量字符串，更有各种类型。

  我们可以在下面寻找类型相同的catch块；
  首先在当前函数下寻找类型相同的；
  若没有找到匹配的catch块，则把问题抛给上方（上方即是调用这个函数
  的一个函数，这里指的是func1()函数）
  若一直抛到main函数里面，还没有，则系统返回。

throw CExcepFull<T>("array is full",val);

CExcepFull<T> tmp = CExcepFull<T>("array is full",val);
throw tmp;
 1
2
3
4
 1
2
3
4

throw函数首先构造一个临时的异常对象,存储在异常存储区域. 在抛出对象时，编译器会拷贝构造一个新的对象，然后抛出新对象，临时对象析构。
开始执行catch块，当catch函数的右括号一出，则新对象的生命周期消失（即异常存储区域的异常对象）。

 我们通常在写代码时，可能会有疏忽，并不能全部确定异常情况，这时，我们就可以用到这个语句：

catch（...） //catch all
{
}
 1
2
3
 1
2
3

这个函数可以保证程序不会挂掉，如果没有相同类型，最终会匹配到这里，由于，这个函数与不同类型的函数都可以进行匹配，又因为函数匹配是从上倒下进行的，所以此函数必须写在末尾。

异常的重新抛出

   在深层次函数的调用中，出现了多种异常，同时又解决了多种异常， 对于main函数来说并不知情，现在main函数想检测一下，在整个函数中在运行过程中，抛出异常的个数。

我们可以用rethrow语句，

catch(const CExcepFull<int> &err)
    {
        err.show();
        throw；
    }
 1
2
3
4
5
 1
2
3
4
5

表示将异常抛出到调用方(func1)，在调用方加上一个try，catch语句，加上一个计数器，即可以解决此问题。
异常的规范：
异常的规范是在c++99里面是不支持的，但在此c++11是支持的。

void push_back(const T &val) throw（）;//该接口不抛异常，否则挂掉 ,throw()是函数首部的一部分，是不能缺少的
void push_back(const T &val) throw（int）;//只抛出整形异常，其他挂掉