C++异常处理 try,catch,throw,finally的用法

C++异常处理 try,catch,throw,finally的用法

在C++中，异常处理机制是一种用于处理程序运行时出现错误的机制。当程序发生错误时，通常会中断其继续执行。异常处理机制能够使程序有机会处理这些错误，并继续执行而不崩溃。

try-catch块

在C++中，异常处理块包括try-catch块和finally块。try-catch块是一个用来捕捉并处理异常的块。在try块中，如果有代码引发了异常，则会将控制流转移到与其匹配的catch块。catch块中则可以处理异常，或者将该异常传递给调用其的函数。

语法:

try {
    // 包含可能引发异常的代码
}
catch(ExceptionType e) {
    // 处理异常的代码
}

在上述语法中，try块中是可能引发异常的代码，如果在执行这些代码时引发了异常，那么程序就会跳转到与其匹配的catch块中处理该异常。e是异常类型的名称，可以根据需要更改。可以有多个catch块来捕捉不同类型的异常。

示例1

#include <iostream>
using namespace std;

int main() {
    int dividend, divisor, quotient;
    cout<<"Enter dividend: ";
    cin >> dividend;
    cout<<"Enter divisor: ";
    cin >> divisor;
    try {
        if(divisor == 0) {
            throw "Division by zero";
        }
        quotient = dividend / divisor;
        cout << "Quotient = " << quotient << endl;
    }
    catch(const char* msg) {
        cerr << msg << endl;
    }
    return 0;
}

在上述代码中，我们通过输入分子和分母，计算它们的商。try块中的语句可能会引发“Divison by zero”异常，因此我们检查除数是否为0。如果除数为0，我们抛出一个异常，阻止程序崩溃。然后，我们捕捉该异常并输出错误信息。

输出：

Enter dividend: 10
Enter divisor: 0
Division by zero

示例2

#include<iostream>
#include<cstring>
using namespace std;

void fun(int n)
{
    try
    {
        int* array = new int[n];
        throw "An exception occurred";
        delete[] array;
    }
    catch(const char* msg)
    {
        cerr << "Exception: " << msg << endl;
    }
}

int main()
{
    fun(0);
    return 0;
}

在上述代码中，我们使用new运算符为数组分配内存。然后，我们抛出一个异常并捕捉它。该程序会输出以下内容：

Exception: An exception occurred

throw语句

throw语句被用来在程序执行期间抛出异常。抛出给定类型的异常时，将在try块中查找一个catch块。如果能找到，则由匹配的catch块进行处理。

语法：

throw ExceptionType;

在上述语法中，ExceptionType是异常类型的名称，可以根据需要更改。

示例3

#include<iostream>
#include<cstring>
#include<stdexcept>
using namespace std;

double divide(int dividend, int divisor)
{
    if(divisor == 0)
    {
        throw runtime_error("Division by zero");
    }
    return static_cast<double>(dividend)/divisor;
}

int main()
{
    int dividend, divisor;
    cout<<"Enter dividend: ";
    cin>>dividend;
    cout<<"Enter divisor: ";
    cin>>divisor;

    try
    {
        double quotient = divide(dividend, divisor);
        cout<<"quotient = "<<quotient<<endl;
    }
    catch(runtime_error e)
    {
        cerr<<"Exception: "<<e.what()<<endl;
    }
    return 0;
}

在上述代码中，我们使用throw语句抛出一个运行时错误，当除数为0时会抛出该异常。然后，我们捕捉该异常并输出错误消息。

输出：

Enter dividend: 10
Enter divisor: 0
Exception: Division by zero

异常传递

我们可以从一个函数抛出异常，并在调用该函数的函数中捕获该异常。因此，在程序中，异常可以传递给调用方的程序块。如果未捕捉异常，它会一直传播到调用程序的下一级，直到被处理为止。

示例4

#include<iostream>
#include<cmath>
using namespace std;

void my_sqrt(double n)
{
    if(n < 0)
    {
        throw "Negative argument is not allowed";
    }
    cout<<"sqrt("<<n<<") = "<<sqrt(n)<<endl;
}

void process(double n)
{
    try
    {
        my_sqrt(n);
    }
    catch(const char* msg)
    {
        cerr<<"Exception caught: "<<msg<<endl;
    }
}

int main()
{
    process(16);
    process(-25);
    return 0;
}

在上述代码中，my_sqrt()函数用于计算平方根。如果函数的参数为负数，则会抛出一个异常，该异常将被传递给在调用my_sqrt()的主函数中。然后，我们捕捉该异常并输出错误消息。

输出：

sqrt(16) = 4
Exception caught: Negative argument is not allowed

finally块

finally块是一个可选的块，用于在try-catch块中的代码执行完后进行清理工作。无论是否引发异常，finally块中的代码都会被执行。

语法：

try
{
    // 代码，可能会引发异常
}
catch(ExceptionType e)
{
    // 处理异常
}
finally
{
    // 清理代码，无论是否引发异常都会执行
}

在上述语法中，如果执行try块中的代码时引发了某个异常，程序将跳转到与其匹配的catch块中进行处理，然后执行finally块中的代码。如果try块中的代码未引发异常，则会直接执行finally块中的代码。

示例5

#include<iostream>
using namespace std;

void do_something(bool flag)
{
    try
    {
        if(flag)
        {
            throw "An exception occurred";
        }
        cout<<"Doing something..."<<endl;
    }
    catch(const char* msg)
    {
        cerr<<"Exception: "<<msg<<endl;
    }
    finally
    {
        cout<<"Finalizing..."<<endl;
    }
}

int main()
{
    do_something(true);
    cout<<endl;
    do_something(false);
    return 0;
}

在上述代码中，我们定义了一个do_something()函数，该函数根据传入的flag值来决定是否引发异常。如果引发了异常，程序将跳转到catch块中进行处理，然后执行finally块中的代码。如果未引发异常，则仅执行finally块中的代码。

输出：

Exception: An exception occurred
Finalizing...

Doing something...
Finalizing...

以上为C++异常处理机制用法攻略。