成C++应用程序世界------异常处理

一、 概述

C++自身有着很强的纠错能力，发展到现在，已经建立了比較完好的异常处理机制。C++的异常情况无非两种，一种是语法错误，即程序中出现了错误的语句，函数，结构和类，致使编译程序无法进行。还有一种是执行时发生的错误，一般与算法有关。

关于语法错误，不必多说，写代码时心细一点就能够解决。C++编译器的报错机制能够让我们轻松地解决这些错误。

第二种是执行时的错误，常见的有文件打开失败、数组下标溢出、系统内存不足等等。

而一旦出现这些问题，引发算法失效、程序执行时无故停止等故障也是常有的。这就要求我们在设计软件算法时要全面。比方针对文件打开失败的情况。保护的方法有非常多种，最简单的就是使用“return”命令。告诉上层调用者函数执行失败；第二种处理策略就是利用c++的异常机制，抛出异常。

二、c++异常处理机制

C++异常处理机制是一个用来有效地处理执行错误的很强大且灵活的工具。它提供了很多其它的弹性、安全性和稳固性，克服了传统方法所带来的问题.

异常的抛出和处理主要使用了下面三个keyword： try、 throw 、 catch 。

抛出异常即检測是否产生异常。在C++中。其採用throw语句来实现，假设检測到产生异常，则抛出异常。该语句的格式为：

throw 表达式;

假设在try语句块的程序段中（包含在当中调用的函数）发现了异常，且抛弃了该异常，则这个异常就能够被try语句块后的某个catch语句所捕获并处理，捕获和处理的条件是被抛弃的异常的类型与catch语句的异常类型相匹配。因为C++使用数据类型来区分不同的异常，因此在推断异常时。throw语句中的表达式的值就没有实际意义。而表达式的类型就特别重要。

try-catch语句形式例如以下 ：

try
{
包括可能抛出异常的语句；
}
catch(类型名 [形參名]) // 捕获特定类型的异常
{

}
catch(类型名 [形參名]) // 捕获特定类型的异常
{

}
catch(...)    // 三个点则表示捕获全部类型的异常
{
}

【范例1】处理除数为0的异常。该范例将上述除数为0的异常能够用try/catch语句来捕获异常。并使用throw语句来抛出异常，从而实现异常处理，实现代码如代码清单1-1所看到的。

// 代码清单1-1

#include<iostream.h>     //包括头文件
#include<stdlib.h>

double fuc(double x, double y) //定义函数
{
if(y==0)
{
throw y;     //除数为0，抛出异常
}
return x/y;     //否则返回两个数的商
}

void main()
{
double res;
try  //定义异常
{
res=fuc(2,3);
cout<<"The result of x/y is : "<<res<<endl;
res=fuc(4,0); 出现异常，函数内部会抛出异常
}
catch(double)             //捕获并处理异常
{
cerr<<"error of dividing zero.\n";
exit(1);                //异常退出程序
}
}

【范例2】自己定义异常类型 （在本文開始的代码中已经给出示范）

三、异常的接口声明

为了加强程序的可读性，使函数的用户可以方便地知道所使用的函数会抛出哪些异常，可以在函数的声明中列出这个函数可能抛出的全部异常类型。比如：

void fun() throw( A,B,C,D);
这表明函数fun()可能而且仅仅可能抛出类型(A,B,C,D)及其子类型的异常。

假设在函数的声明中没有包含异常的接口声明。则此函数能够抛出不论什么类型的异常，比如：

void fun();

一个不会抛出不论什么类型异常的函数能够进行例如以下形式的声明：

void fun() thow();

五、异常处理中须要注意的问题

1. 假设抛出的异常一直没有函数捕获(catch)。则会一直上传到c++执行系统那里，导致整个程序的终止

2. 一般在异常抛出后资源能够正常被释放，但注意假设在类的构造函数中抛出异常，系统是不会调用它的析构函数的，处理方法是：假设在构造函数中要抛出异常，则在抛出前要记得删除申请的资源。

3. 异常处理只通过类型而不是通过值来匹配的，所以catch块的參数能够没有參数名称。只须要參数类型。

4. 函数原型中的异常说明要与实现中的异常说明一致。否则easy引起异常冲突。

5. 应该在throw语句后写上异常对象时，throw先通过Copy构造函数构造一个新对象，再把该新对象传递给 catch.

那么当异常抛出后新对象怎样释放？

异常处理机制保证：异常抛出的新对象并不是创建在函数栈上，而是创建在专用的异常栈上。因此它才干够跨接多个函数而传递到上层，否则在栈清空的过程中就会被销毁。全部从try到throw语句之间构造起来的对象的析构函数将被自己主动调用。

但假设一直上溯到main函数后还没有找到匹配的catch块，那么系统调用terminate()终止整个程序，这样的情况下不能保证全部局部对象会被正确地销毁。

6. catch块的參数推荐採用地址传递而不是值传递，不仅能够提高效率，还能够利用对象的多态性。另外，派生类的异常扑获要放到父类异常扑获的前面，否则。派生类的异常无法被扑获。

7. 编写异常说明时。要确保派生类成员函数的异常说明和基类成员函数的异常说明一致，即派生类改写的虚函数的异常说明至少要和相应的基类虚函数的异常说明同样，甚至更加严格，更特殊。

#include "stdafx.h"
#include<stdlib.h>
#include<crtdbg.h>
#include <iostream>
// 内存泄露检測机制
#define _CRTDBG_MAP_ALLOC
#ifdef _DEBUG
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

// 自己定义异常类
class MyExcepction
{
public:

// 构造函数,參数为错误代码
MyExcepction(int errorId)
{
// 输出构造函数被调用信息
std::cout << "MyExcepction is called" << std::endl;
m_errorId = errorId;
}

// 拷贝构造函数
MyExcepction( MyExcepction& myExp)
{
// 输出拷贝构造函数被调用信息
std::cout << "copy construct is called" << std::endl;
this->m_errorId = myExp.m_errorId;
}

~MyExcepction()
{
// 输出析构函数被调用信息
std::cout << "~MyExcepction is called" << std::endl;
}

// 获取错误码
int getErrorId()
{
return m_errorId;
}

private:
// 错误码
int m_errorId;
};

int main(int argc, char* argv[])
{
// 内存泄露检測机制
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );

// 能够改变错误码,以便抛出不同的异常进行測试
int throwErrorCode = 110;

std::cout << " input test code :" << std::endl;
std::cin >> throwErrorCode;

try
{
if ( throwErrorCode == 110)
{
MyExcepction myStru(110);

// 抛出对象的地址 -> 由catch( MyExcepction*    pMyExcepction) 捕获
// 这里该对象的地址抛出给catch语句,不会调用对象的拷贝构造函数
// 传地址是提倡的做法,不会频繁地调用该对象的构造函数或拷贝构造函数
// catch语句运行结束后,myStru会被析构掉
throw    &myStru;
}
else if ( throwErrorCode == 119 )
{
MyExcepction myStru(119);

// 抛出对象,这里会通过拷贝构造函数创建一个暂时的对象传出给catch
// 由catch( MyExcepction    myExcepction) 捕获
// 在catch语句中会再次调用通过拷贝构造函数创建暂时对象复制这里传过去的对象
// throw结束后myStru会被析构掉
throw    myStru;
}
else if ( throwErrorCode == 120 )
{
// 不提倡这种抛出方法
// 这样做的话,假设catch( MyExcepction*    pMyExcepction)中不运行delete操作则会发生内存泄露

// 由catch( MyExcepction*    pMyExcepction) 捕获
MyExcepction * pMyStru = new MyExcepction(120);
throw pMyStru;
}
else
{
// 直接创建新对象抛出
// 相当于创建了暂时的对象传递给了catch语句
// 由catch接收时通过拷贝构造函数再次创建暂时对象接收传递过去的对象
// throw结束后两次创建的暂时对象会被析构掉
throw MyExcepction(throwErrorCode);
}
}
catch( MyExcepction*    pMyExcepction)
{
// 输出本语句被运行信息
std::cout << "运行了 catch( MyExcepction*    pMyExcepction) " << std::endl;

// 输出错误信息
std::cout << "error Code : " << pMyExcepction->getErrorId()<< std::endl;

// 异常抛出的新对象并不是创建在函数栈上，而是创建在专用的异常栈上,不须要进行delete
//delete pMyExcepction;
}
catch ( MyExcepction myExcepction)
{
// 输出本语句被运行信息
std::cout << "运行了 catch ( MyExcepction myExcepction) " << std::endl;

// 输出错误信息
std::cout << "error Code : " << myExcepction.getErrorId()<< std::endl;
}
catch(...)
{
// 输出本语句被运行信息
std::cout << "运行了 catch(...) " << std::endl;

// 处理不了,又一次抛出给上级
throw ;
}

// 暂停
int temp;
std::cin >> temp;

return 0;

/*File : exception.cpp
*Auth : sjin
*Date : 20140515
*Mail : 413977243@qq.com
*/

#include <iostream>
#include <exception>

using namespace std;

class MyExcception:public exception{

public:
const char * what() const throw(){
return "this is a exception";
}
};

/*假设抛出异常，没有接收。程序将终止*/
void exception_1()throw(double,int,const char *,MyExcception)
{
int i;
cout << "输入1-3整数" <<endl;
cin >> i;
if(i == 1)throw MyExcception();
if(i == 2)throw "hello";
if(i== 3)throw 123;

cout << "==========end =========" <<endl;

}
int main()
{
try{

exception_1();
}catch(const char *ex){
cout <<" exceptiong is occur!" <<ex<< endl;
}catch(double e){
cout << e << endl;
}catch (int e){
cout << e <<endl;
}catch (MyExcception e){
cout << "MyExcception is occur!" << e.what()<< endl;
}

return 0;
}