【C++】异常

目录

前言

一、异常的概念

二、异常的抛出和捕获

三、栈展开

四、查找匹配的处理代码

*使用基类捕获异常

五、异常的重新抛出

六、异常的安全问题

七、异常规范

八、标准库的异常

总结

前言

       本文介绍了C++中的异常处理机制，包括异常的概念、抛出和捕获、栈展开、查找匹配的处理代码、异常的重新抛出、异常的安全问题、异常规范以及标准库的异常。

一、异常的概念

• 异常处理机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理， 异常使得我们能够将问题的检测与解决问题的过程分开，程序的一部分负责检测问题的出现，然后解决问题的任务传递给程序的另一部分，检测环节无须知道问题的处理模块的所有细节。
• C语言主要通过错误码的形式处理错误，错误码本质就是对错误信息进行分类编号，拿到错误码以后还要去查询错误信息，比较麻烦。异常时抛出一个对象，这个对象可以涵盖更全面的各种信息。（比如对象可以包括错误码，错误提示，出现问题行数等等），这个就比C语言的错误码好用很多。

捕获异常的语法： 

try

{

        //执行的代码...

}

catch(用于接收异常的参数)

{

        //打印异常等代码....

}

二、异常的抛出和捕获

• 1. 程序出现问题时，我们通过抛出(throw)一个对象来引发一个异常，该对象的类型以及当前的调用链决定了应该由哪个catch的处理代码来处理该异常。
• 2.抛出异常对象后，会生成⼀个异常对象的拷贝，因为抛出的异常对象可能是一个局部对象，所以会生成一个拷贝对象，这个拷贝的对象会在catch子句后销毁。（这里的处理类似于函数的传值返回）

比如，观察以下代码：

#include <iostream>
using namespace std;

//用于除法运算
double Divide(int a, int b)
{
	try
	{
		if (b == 0)
		{
			string s("异常，除数不能为0");
			throw s;
		}
		else
		{
			return double(a) / double(b);
		}
	}
	catch (int errid)
	{
		cout << errid << endl;
	}

	return 0;
}

void Func()
{
	int len, time;
	cin >> len >> time;
	try
	{
		Divide(len, time);
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}

	//__FUNCTION__可以读取当前函数名，__LINE__获取当前行数，这两个都是C语言的宏
	cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;
}

int main()
{
	while (1)
	{
		try
		{
			Func();
		}
		catch (const string& errmsg)
		{
			cout << errmsg << endl;
		}
	}

	return 0;
}

运行结果示例：

解释：

• 该代码通过main函数调用Func函数，在Func函数中输入需要做除法运算的两个数，然后调用Divide函数进行除法运算。
• 该代码有3处捕获异常的地方，区别在于catch中的参数类型不同。当Divide函数抛出异常时，异常首先在Divide的catch中识别，发现类型不匹配接着调整到上一层捕获异常的地方，也就是Func函数中的catch，发现类型还是不匹配，接着跳转到main函数的catch中，此时类型匹配，打印异常信息。
• 这里需要注意的是，从throw抛出异常开始，throw后面如果有代码也不会继续执行，它会先跳到最近的catch进行类型匹配，如果当前catch也不匹配，并且跳转到其他函数中了，那么catch及之后的代码也不会运行，一路跳转到匹配的catch中，然后按顺序执行catch及之后的代码。

总结一下：

• 3.当throw执行时，throw后面的语句将不再被执行。程序的执行从throw位置跳到与之匹配的catch模块，catch可能是同一函数中的一个局部的catch，也可能是调用链中另一个函数中的catch，控制权从throw位置转移到了catch位置。这里还有两个重要的含义：1、沿着调用链的函数可能提早退出。（比如上面的Func函数没捕获到异常导致提早退出，也就是销毁函数栈帧）2、一旦程序开始执行异常处理程序，沿着调用链创建的对象都将销毁。（这样就不用担心析构等问题）

• 4.被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那⼀个。根据抛出对象的类型和内容，程序的抛出异常部分告知异常处理部分到底发生了什么错误。
• 简单点说，就是调用链值有多个与异常类型匹配的catch，只会执行与异常最近的那一个。

将上面代码简单修改下就可以验证：

#include <iostream>
using namespace std;

//用于除法运算
double Divide(int a, int b)
{
	try
	{
		if (b == 0)
		{
			string s("异常，除数不能为0");
			throw s;
		}
		else
		{
			return double(a) / double(b);
		}
	}
	catch (const string& errmsg)
	{
		cout << errmsg << endl;
	}

	cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;

	return 0;
}

void Func()
{
	int len, time;
	cin >> len >> time;
	try
	{
		Divide(len, time);
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}

	//__FUNCTION__可以读取当前函数名，__LINE__获取当前行数，这两个都是C语言的宏
	cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;
}

int main()
{
	while (1)
	{
		try
		{
			Func();
		}
		catch (const string& errmsg)
		{
			cout << errmsg << endl;
		}
	}

	return 0;
}

运行结果：

• 很明显，将Divide函数中的catch参数类型修改为与异常类型一致的string后，发生异常后就会直接在Divide中被捕获，进而继续执行后面的代码。

三、栈展开

上面展示的代码捕获异常的过程就是栈展开

• 抛出异常后，程序暂停当前函数的执行，开始寻找与之匹配的catch子句，首先检查throw本身是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。
• 如果当前函数中没有try/catch子句，或者有try/catch子句但是类型不匹配，则退出当前函数，继续在外层调用函数链中查找，上述查找的catch过程被称为栈展开。
• 如果到达main函数，依旧没有找到匹配的catch子句，程序会调用标准库的 terminate 函数终止程序。也就是说异常必须被捕获，否则就报错终止程序。
• 如果找到匹配的catch子句处理后，catch子句代码会继续执行。

示意图：

• 以上只是一种形象的描述（语法逻辑），实际程序在编译时就确定了异常会在哪里被捕获，运行时就会去执行已经形成的指令。

四、查找匹配的处理代码

• 一般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的那个。
• 但是也有⼀些例外，允许从非常量向常量的类型转换，也就是权限缩小（const）；允许数组转换成指向数组元素类型的指针，函数被转换成指向函数的指针；允许从派生类向基类类型的转换（切片），这个点非常实用，实际中继承体系基本都是用这个方式设计的。
• 如果到main函数，异常仍旧没有被匹配就会终止程序，不是发生严重错误的情况下，我们是不期望程序终止的，所以一般main函数中最后都会使用catch(...)，它可以捕获任意类型的异常，但是是不知道异常错误是什么。

我们先演示第3点的catch(...)：

#include <iostream>
using namespace std;

//用于除法运算
double Divide(int a, int b)
{
	try
	{
		if (b == 0)
		{
			string s("异常，除数不能为0");
			throw s;
		}
		else
		{
			return double(a) / double(b);
		}
	}
	catch (const int errid)//不匹配
	{
		cout << errid << endl;
	}

	return 0;
}

void Func()
{
	int len, time;
	cin >> len >> time;
	try
	{
		Divide(len, time);
	}
	catch (const char* errmsg)//不匹配
	{
		cout << errmsg << endl;
	}

	cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;
}

int main()
{
	while (1)
	{
		try
		{
			Func();
		}
		catch (const char* errmsg)//不匹配
		{
			cout << errmsg << endl;
		}
		catch (...)//当异常没有被捕获时，异常最终的落脚点
		{
			cout << "未知异常" << endl;
		}
	}

	return 0;
}

运行结果：

• 因为正常程序运行时我们并不希望因为一些小bug导致程序直接终止，所以catch(...)的存在就比较重要了。
• 但是catch(...)捕获的异常是未知异常，我们也不希望程序抛出一个未知异常出来。
• 一般在实践项目中，像几万甚至几十万的代码的项目中，对于异常的捕获，如果参与项目的每个人都抛出不同类型的异常，那么按照类型匹配一个一个写catch，那么肯定是不现实的，这时候上面提到的异常捕获允许从派生类向基类类型的转换就非常重要了。

*使用基类捕获异常

• 使用这个方法就可以解决项目中捕获各种异常的问题了，我们先确定一个基类Exception，这个基类包含异常的基本信息和异常编号，然后对于不同模块抛出的异常，可以继承这个基类，然后进行重写虚函数，记录不同的异常信息。
• 这就是继承与多态使用的场景。

一般只有大的项目才会使用异常，我们这里使用随机数简单演示一下：

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <thread>
using namespace std;

//异常的基类
class Exception
{
public:
    Exception(const string& errmsg, int id)
        :_errmsg(errmsg)
        , _id(id)
    {}

    virtual string what() const//写成虚函数可以重写
    {
        return _errmsg;
    }

    int getid() const//用于获取异常编号
    {
        return _id;
    }

protected:
    string _errmsg;//具体的错误信息
    int _id;//异常编号
};

//有关数据库模块的异常类
class SqlException : public Exception
{
public:
    SqlException(const string& errmsg, int id, const string& sql)
        :Exception(errmsg, id)
        ,_sql(sql)
    {}

    virtual string what() const//重写虚函数
    {
        string str = "SqlException: ";
        str += _errmsg;
        str += "->";
        str += _sql;

        return str;
    }

private:
    const string _sql;
};

//有关缓存的异常
class CacheException : public Exception
{
public:
    CacheException(const string& errmsg, int id)
        :Exception(errmsg, id)
    {}
    
    virtual string what() const
    {
        string str = "CacheException: ";
        str += _errmsg;

        return str;
    }
};

//关于服务的异常
class HttpException : public Exception
{
public:
    HttpException(const string& errmsg, int id, const string type)
        :Exception(errmsg, id)
        ,_type(type)
    {}

    virtual string what() const
    {
        string str = "HttpException: ";
        str += _type;
        str += ":";
        str += _errmsg;

        return str;
    }

private:
    const string _type;
};

void SQLMgr()
{
    if (rand() % 7 == 0)
    {
        throw SqlException("权限不足", 100, "select * from name = '张三'");
    }
    else
    {
        cout << "SQLMgr 调用成功" << endl;
    }
}

void CacheMgr()
{
    if (rand() % 5 == 0)
    {
        throw CacheException("权限不足", 100);
    }
    else if (rand() % 6 == 0)
    {
        throw CacheException("数据不存在", 101);
    }
    else
    {
        cout << "CacheMgr 调用成功" << endl;
    }

    SQLMgr();//调用下一个函数
}

void HttpServer()
{
    if (rand() % 3 == 0)
    {
        throw HttpException("请求资源不存在", 100, "get");
    }
    else if (rand() % 4 == 0)
    {
        throw HttpException("权限不足", 101, "post");
    }
    else
    {
        cout << "HttpServer 调用成功" << endl;
    }

    CacheMgr();//调用下一个函数
}

int main()
{
    srand(time(0));//设置随机数种子

    while (1)//死循环，模拟跑在服务器上的程序，一直运行
    {
        this_thread::sleep_for(chrono::seconds(1));//休眠1秒，避免程序运行过快

        try
        {
            HttpServer();//调用一连串函数
            cout << "3次调用成功" << endl;
        }
        catch (const Exception& e)//使用基类捕获所有派生类异常
        {
            cout << e.what() << endl;//多态调用
        }
        catch (...)
        {
            cout << "未知异常" << endl;
        }
    }

    return 0;
}

运行结果：

• 基类：Exception。三个派生类：SqlException、CacheException、HttpException
• 以上，通过基类捕获异常，在实践中可以使异常捕获更加规范高效。
• （注意，以上只是使用随机数模拟，实际项目中异常出现概念肯定很低）

五、异常的重新抛出

• 有时catch到一个异常对象后，需要对错误进行分类，其中的某种异常错误需要进行特殊的处理，其他错误则重新抛出异常给外层调用链处理。捕获异常后需要重新抛出，直接 throw；就可以把捕获的对象重新抛出。
• 下面我们看一个场景：假如你使用聊天软件和对方发送消息，如果消息发送失败，那么可能得原因有多个，比如网络状况不好，比如被对面删除/拉黑了，这个就是对消息发送失败的异常进行分类，分类后，比如是网络不好，这时候可以尝试重新发送，如果达到一定次数依旧失败，这时候就可以重新抛出异常提醒用户检查网络，这个重新抛出异常就可以直接 throw。

不啰嗦，下面模拟聊天发送消息失败时的异常重新抛出：

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

//异常的基类
class Exception
{
public:
    Exception(const string& errmsg, int id)
        :_errmsg(errmsg)
        , _id(id)
    {}

    virtual string what() const//写成虚函数可以重写
    {
        return _errmsg;
    }

    int getid() const//用于获取异常编号
    {
        return _id;
    }

protected:
    string _errmsg;//具体的错误信息
    int _id;//异常编号
};

//关于服务的异常
class HttpException : public Exception
{
public:
    HttpException(const string& errmsg, int id, const string type)
        :Exception(errmsg, id)
        ,_type(type)
    {}

    virtual string what() const
    {
        string str = "HttpException: ";
        str += _type;
        str += ":";
        str += _errmsg;

        return str;
    }

private:
    const string _type;
};

void _SeedMsg(const string& s)
{
    if (rand() % 2 == 0)
    {
        throw HttpException("网络不稳定，发送失败", 102, "put");
    }
    else if (rand() % 7 == 0)
    {
        throw HttpException("你已经不是对方的好友，发生失败", 103, "put");
    }
    else
    {
        cout << "发送成功" << endl;
    }
}

void SeedMsg(const string& s)
{
    //如果消息发送失败，就重试3次
    for (size_t i = 0; i < 4; i++)
    {
        try
        {
            _SeedMsg(s);
            break;//发送成功跳出循环
        }
        catch (const Exception& e)
        {
            //异常的分类，这时候编码就展现出作用了
            if (e.getid() == 102)
            {
                if (i == 3)//前面3次重试，到第四次还是失败就重新抛异常
                    throw;

                cout << "开始第" << i + 1 << "次重试" << endl;
            }
            else
            {
                throw;//其他异常就直接重新抛出
            }
        }
    }
}

int main()
{
    srand(time(0));

    string str;
    while (cin >> str)
    {
        try
        {
            SeedMsg(str);
        }
        catch (const Exception& e)
        {
            cout << e.what() << endl;
        }
        catch (...)
        {
            cout << "未知异常" << endl;
        }
    }

	return 0;
}

运行结果：

• 以上就是异常重新抛出的演示，简单点说：异常的重新抛出就是将当前catch捕获的异常，分类处理后需要交给后面的ctach继续处理，这时直接throw，就可以将异常原封不动重新发出，简单方便。
• 当然异常的重新抛出还有很多场景，比如为了清理资源，不得不在当前函数捕获异常，因为异常抛出会导致代码执行会跳过部分代码。下面简单演示下：

//用于除法运算
double Divide(int a, int b)
{
	try
	{
		if (b == 0)
		{
			string s("异常，除数不能为0");
			throw s;
		}
		else
		{
			return double(a) / double(b);
		}
	}
	catch (const int errid)
	{
		cout << errid << endl;
	}

	return 0;
}

void func1()
{
    int* ptr = new int[10];//new申请内存失败会抛异常

    try
    {
        Divide(1, 0);
    }
    catch (...)//可以直接使用...捕获所以情况
    {
        delete[] ptr;//避免内存泄漏
        throw;
    }

    delete[] ptr;
}

六、异常的安全问题

也就是上面哪个代码的情况

• 异常抛出后，后面的代码就不再执行，前面申请了资源(内存、锁等)，后面进行释放，但是中间可能会抛异常就会导致资源没有释放，这里由于异常就引发了资源泄漏，产生安全性的问题。中间我们需要捕获异常，释放资源后面再重新抛出，当然后面智能指针可以解决这种问题是更好的。
• 其次析构函数中，如果抛出异常也要谨慎处理，比如析构函数要释放10个资源，释放到第5个时抛出异常，则也需要捕获处理，否则后面的5个资源就没释放，也资源泄漏了。

七、异常规范

• 对于用户和编译器而言，预先知道某个程序会不会抛出异常大有裨益，知道某个函数是否会抛出异常有助于简化调用函数的代码。
• C++98中函数参数列表的后面接throw()，表示函数不抛异常，函数参数列表的后面接throw(类型1, 类型2...)表示可能会抛出多种类型的异常，可能会抛出的类型用逗号分割。
• C++98的这种方式过于复杂，实践中并不好用，C++11中进行了简化，函数参数列表后面加 noexcept 表示不会抛出异常，啥都不加表示可能会抛出异常。

noexcept在C++11官方文档中很常见

• 编译器并不会在编译时检查noexcept，也就是说如果⼀个函数用noexcept修饰了，但是同时又包含了throw语句或者调用的函数可能会抛出异常，编译器还是会顺利编译通过的(有些编译器可能会报个警告)。但是一个声明了noexcept的函数抛出了异常，程序会调用 terminate 终止程序。
• 总结，noexcept不要乱加，只有确保函数不会抛异常时才可以加，当然也不强制要求必须加，但是，函数会抛出异常，那你就不能加noexcept，因为异常不会被捕获了。

• noexcept(expression)还可以作为一个运算符去检测一个表达式是否会抛出异常，可能会则返回false，不会就返回true。

这个可以演示一下：

#include <iostream>
using namespace std;

//用于除法运算
double Divide(int a, int b)
{

    if (b == 0)
    {
        string s("异常，除数不能为0");
        throw s;
    }

    return double(a) / double(b);
}

int main()
{
    int i;
    cout << noexcept(Divide(1,0)) << endl;
    cout << noexcept(Divide(4,2)) << endl;
    cout << noexcept(i++) << endl;

    return 0;
}

运行结果：

• 结果证明只要可能会抛出异常的表达式，noexcept就会返回false

八、标准库的异常

• C++标准库也定义了一套自己的异常继承体系库，基类是 exception，所以我们日常写程序，需要在主函数捕获exception即可，要获取异常信息，调用what函数，what是一个虚函数，派生类可以重写。（和我们自己模拟的类似）
• 
• 
• exception的类中，有构造、拷贝构造、赋值运算符重载、析构、what函数（怕你忘记，析构写成虚函数是为了在基类指针调用派生类析构时能正确调用析构，避免内存泄漏等问题）

演示：

#include <iostream>
#include <exception>
#include <vector>
using namespace std;

void Func()
{
    vector<int> v(10);//10个空间
    cout << v.at(10) << endl;//at会抛出越界访问异常
}

int main()
{
    try
    {
        Func();
    }
    catch (const exception e)
    {
        cout <<"vector: " << e.what() << endl;
    }
    catch (...)
    {
        cout << "未知异常" << endl;
    }

    return 0;
}

运行结果：

• 标准库的exception具体有以下一些派生类：
• 
• 这里不一一介绍了，感兴趣可以自行阅读官方文档了解。

总结

        以上就是本文的全部内容了，感谢支持！