C++异常处理机制

错误测试通常是涉及 if 语句或其他控制机制的简单过程。例如，以下代码段会在发生被零除错误之前捕获该错误：

if (denominator == 0)
    cout << "ERROR: Cannot divide by zero. \n";
else
    quotient = numerator / denominator;

但如果类似的代码是返回商的函数的一部分，如下例所示：

//不可靠的除非函数
double divide(double numerator, double denominator)
{
    if (denominator == 0)
    {
        cout << "ERROR: Cannot divide by zero.\n";
        return 0;
    }
    else
        return numerator / denominator;
}

函数通常通过返回一个预定的值来发出错误信号。在以上示例中，当尝试被零除时，函数返回 0。然而，这是不可靠的，因为 0 是除法操作的有效结果。即使函数显示错误消息，调用该函数的程序部分也不会知道何时发生了错误。因此，像这样的问题需要更复杂的错误处理技术。

抛出异常

处理复杂错误情况的一种方法是使用异常。异常是指示错误的值或对象。当错误发生时，一个异常被 "抛出"，因为控制权将传递给程序负责捕获和处理该类型错误的那一部分。

例如，以下代码显示了修改后的 divide 函数，当试图除零时将抛出异常：

double divide(double numerator, double denominator)
{
    if (denominator == 0)
        throw string("ERROR: Cannot divide by zero.\n");
    else
        return numerator / denominator;
}

以下语句将导致异常被抛出：

throw string("ERROR: Cannot divide by zero.\n");

throw 关键字后跟一个参数，可以是任何值。实际上，参数的类型将用于确定错误的性质。上面的函数只是抛出一个包含描述性错误信息的字符串对象。

包含 throw 语句的行称为抛出点。当执行一个 throw 语句时，控制权传递给称为异常处理程序的另一部分程序。

处理异常

为了处理异常，程序必须有一个 try/catch 结构。try/catch 结构的一般格式如下：

try
{
    //此处调用可能抛出异常的
    //函数或对象成员函数
}
catch(exception parameter)
{
    //此处处理异常
}
//根据需要重复catch代码段

构造的第一部分是 try 块。它从关键字 try 开始，然后是任何可能直接或间接导致拋出异常的执行语句的代码块。try 块之后紧跟着一个或多个 catch 块，它们是异常处理程序。一个 catch 块以关键字 catch 开始，随后是一对圆括号，里面包含异常参数声明。

例如，下面就是一个 try/catch 结构，它可以与 divide 函数一起使用：

try
{
    quotient = divide(num1, num2);
    cout<< "The quotient is " << quotient << endl;
}
catch (string exceptionString)
{
    cout << exceptionString;
}

由于 divide 函数抛出的是一个类型为字符串的异常，因此必须有一个捕获字符串的异常处理程序。显示的 catch 块会捕获 exceptionString 形参中的错误消息，然后使用 cout 显示它。

现在来看一个完整的程序，了解 throw、try 和 catch 是如何一起合作的。在下面程序的第一次示例运行中，给出的是有效的数据，所以显示了程序在没有错误情况下的正常运行结果；在第二次示例运行中，给出的分母是 0，于是显示抛出异常的结果。

//This program illustrates exception handling.
#include <iostream>
#include <string>
using namespace std;

// Function prototype
double divide(double, double);

int main()
{
    int num1, num2;
    double quotient;
    cout << "Enter two numbers:";
    cin >> num1 >> num2;
    try
    {
        quotient = divide(num1, num2);
        cout << "The quotient is " << quotient << endl;
    }
    catch (string exceptionString)
    {
        cout << exceptionString;
    }
    cout << "End of the program.\n";
    return 0;
}
double divide(double numerator, double denominator)
{
    if (denominator == 0)
        throw string ("ERROR: Cannot divide by zero. \n");
    else
        return numerator / denominator;
}

程序输出结果：

Enter two numbers:12 0
ERROR: Cannot divide by zero.
End of the program.

从输出结果中可以看出，异常导致程序跳出 divide 函数并进入 catch 块。在 catch 块完成之后，程序继续执行在 try-catch 结构之后第一个语句。

异常未被捕获的情形

有两种可能的方式导致抛出的异常未被捕获。第一种可能性是程序未包含具有正确数据类型的异常形参的 catch 块。第二种可能性是异常在 try 块外部抛出。在这两种情况下，异常都会导致整个程序中止执行。

面向对象的异常处理类

在理解了 C++ 中的异常机制工作方式之后，现在来探讨一下面向对象的异常处理方法。先来看一个 IntRange 类。

//IntRange.h 的内容
#ifndef INTRANGE_H
#define INTRANGE_H

#include <iostream>
using namespace std;

class IntRange
{
    private:
        int input; // For user input
        int lower; // Lower limit of range
        int upper; // Upper limit of range
    public:
        // Exception class
        class OutOfRange
        { }; // Empty class declaration
        // Member functions
        IntRange(int low, int high) // Constructor
        {
            lower = low;
            upper = high;
        }
        int getInput()
        {
            cin >> input;
            if (input < lower || input > upper)
                throw OutOfRange();
            return input;
        }
};
#endif

IntRange 是一个简单的类，其成员函数 getInput 允许用户输入一个整数值。该值与成员变量 lower 和 upper（由类构造函数初始化）进行比较。如果输入的值小于 lower 或大于 upper，则抛出异常，表示该值超出范围。否则，该值将从函数返回。

该函数不是抛出一个字符串或一个原始类型的值，而是抛出一个异常类。请注意在 public 部分中出现的空类声明：

class OutOfRange
{ };//空类声明

请注意，这个类没有成员。该类唯一重要的部分是它的名字，这个名字将被异常处理代码使用。请看 getinput 函数中的if语句：

if (input < lower || input > upper)
    throw OutOfRange();

throw 语句的参数 OutOfRange() 会使 OutOfRange 类的实例被创建并作为异常拋出。剩下的就是由一个 catch 块来处理异常。以下是一个示例：

catch (IntRange::OutOfRange)
{
    cout << "That value is out of range. \n";
}

所有必须出现在 catch 块括号内的是异常类的名称。异常类是空的，所以不需要声明一个实际的参数。catch 块需要知道的只是异常的类型。

由于 OutOfRange 类是在 IntRange 类中声明的，因此其名称必须完全符合作用域解析运算符。下面的程序显示了在驱动模块程序中起作用的类。

//This program demonstrates the use of obj ect-oriented exception handling.
#include <iostream>
#include "IntRange.h"
using namespace std;

int main()
{
    IntRange range(5, 10);
    int userValue;
    cout << "Enter a value in the range 5-10: ";
    try {
        userValue = range.getInput();
        cout << "You entered " << userValue << endl;
    }
    catch (IntRange::OutOfRange)
    {
        cout << "That value is out of range. \n";
    }
    cout << "End of the program.\n";
    return 0;
}

程序输出结果：

Enter a value in the range 5-10: 12
That value is out of range.
End of the program.