【C++学习】异常

ChuHsiang
128 阅读10分钟

1.异常相关概念

传统C语言处理错误的方式：

传统的错误处理机制：

  • 终止程序，如assert，缺陷：用户难以接收。若发生内存错误，除0错误时就会终止程序。
  • 返回错误码，缺陷：需要程序员自己去查找对应的错误。其中系统的很多库的接口函数都是通过把错误码放到errno中，表示错误。

在实际中C语言基本上使用返回错误码方式处理错误，部分情况下使用终止处理非常严重的错误。

​ 异常是指存在于运行时的反常行为，这些行为超出了函数正常功能的范围。简单来说，异常就是一种处理错误的方式，当一个函数发现自己无法处理的错误就可以抛出异常，让函数直接或间接地调用者处理这个错误。典型的异常包括失去数据库连接以及遇到意外输入等。

​ 当程序的某部分检测到一个它无法处理的问题时，需要用到异常处理。此时，检测出问题的部分因该发出某种信号以表明程序遇到故障，无法继续下去了，而且信号的发出方无须知道故障将在何处得到解决。一旦发出异常信号，检测出问题的部分也就完成了任务。 异常处理机制需要异常检测和异常处理进行协作处理。C++中，异常处理包括：

  • throw表达式，异常检测部分使用throw表达式来表示它遇到了无法处理的问题。throw引发了异常。
  • try语句块，异常处理部分使用try语句块处理异常。try语句块以关键字try开始，并以一个或多个catch子句结束。try语句块中代码抛出的异常通常会被某个catch子句处理。因为catch子句“处理”异常，所以它们也被称作异常处理代码。
  • 一套异常类，用于在throw表达式和相关的catch子句之间传递异常的具体信息。
try
{
    program-statements;
}
catch(exception-declaration)
{
    handler-statements;
}
catch(exception-declaration)
{
    handler-statements;
}//...

若有一个块抛出一个异常，捕获异常的方法会使用try和catch关键字。try块放置可能抛出异常的代码，try块中的代码被称为保护代码。使用try/catch语句的语法如上所示。

1.1 throw表达式

​ 程序的异常检测部分使用throw表达式引发一个异常。throw表达式包含关键字throw和紧随其后的一个表达式，其中表达式的类型就是抛出的异常类型。

1.2 try语句块

​ catch子句包括三部分：关键字catch、括号内一个（可能未命名的）对象的声明（称作异常声明，exception declaration）以及一个块。当选中某个catch子句处理异常之后，执行与之对应的块。catch一旦完成，程序跳转到try语句块最后一个catch子句之后的那条语句继续执行。

1.3标准异常

C++标准库定义了一组类，用于报告标准库函数遇到的问题。这些异常类也可以在用户编写的程序中使用，它们分别在4个文件头中：

  • new文件定义了bad_alloc异常类型；
  • stdexcept头文件定义了几种常用的异常类，如range_error、overflow_error、underflow_error 、logic_error、invalid_argument、domain_error等；
  • exception头文件定义了最通用的异常类exception。它只报告异常的发生，不提供任何额外信息；
  • type_info头文件定义了bad_cast异常类型；

异常类型只定义了一个名为what的成员函数，该函数没有任何参数，返回值是一个指向C风格的字符串的const char*。该字符串的目的是提供关于异常的一些文本信息。

2.异常的使用

2.1 异常的抛出和捕获

异常的抛出和匹配原则：

  1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码；
  2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个；
  3. 抛出异常对象后，会生成一个异常对象拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在catch以后销毁；
  4. catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么；
  5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获；

在函数调用链中异常栈展开匹配原则：

  1. 首先检查throw本身是否在try块内部，如果是再找匹配的catch语句。如果又匹配的，则调用到catch的地方进行处理；
  2. 没有匹配的catch则退出当前函数栈，继续在调用函数栈中进行查找匹配的catch；
  3. 如果到达main函数的栈，依旧没有匹配的，则终止程序；
  4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行；
#include <iostream>
#include <stdexcept>
double Division(int a, int b)
{
	//当 b == 0时抛出异常
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	else
	{
		return ((double)a / (double)b);
	}
}

void Func()
{
	int len, time;
	std::cin >> len >> time;
	std::cout << Division(len, time) << std::endl;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		std::cout << errmsg << std::endl;
	}
	catch (...)
	{
		std::cout << "unkown exception" << std::endl;
	}

	return 0;
}

键盘输入10和0，分别表示a和b，所得结果：

image-20250922193659744

2.2异常的重新抛出

有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。

double Division(int a, int b)
{
	//当b==0时抛出异常
	if (b == 0)
	{
		throw "Division by zero conditon!";
	}
	return (double)a / (double)b;
}

void Func()
{
	int* array = new int[10];
	try
	{
		int len, time;
		std::cin >> len >> time;
		std::cout << Division(len, time) << std::endl;
	}
	catch (...)
	{
		std::cout << "delete []" << array << std::endl;
		delete[] array;
		throw;
	}

	std::cout << "delete[]" << array << std::endl;
	delete[] array;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		std::cout << errmsg << std::endl;
	}
	return 0;
}

image-20250922200545455

2.3异常安全

  • 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化；
  • 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏（内存泄漏、句柄未关闭等）；
  • C++中异常经常会导致资源泄漏问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题。

2.4异常规范

  1. 异常规范说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。可以在函数的后面接throw（类型），列出这个函数可能抛掷的所有异常类型；
  2. 函数后面接throw()，表示函数不抛异常；
  3. 若无异常接口声明，则此函数可以抛掷任何类型的异常；
void func() throw(A,B,C,D);//func函数会抛出A/B/C/D中的某种类型的异常
void* operator new(std::size_t size) throw(std::bad_alloc);//这个函数只会抛出bad_alloc的异常
void* operator delete(std::size_t size ,void* ptr)throw();//表示这个函数不会抛出异常

shared_ptr()noexcept;//C++11新增noexcept，表示不会抛出异常

3.自定义异常体系

下面展示一段服务器开发过程中常用的异常继承体系：

#include <iostream>
#include <stdexcept>
#include <string>
#include <thread>

class Exception {
public:
	Exception(int errid,const const std::string& msg)
		:_errid(errid)
		,_errmsg(msg)
	{ }

	const std::string& GetMsg()const
	{
		return _errmsg;
	}

	int GetErrid()const
	{
		return _errid;
	}

	virtual std::string what()const
	{
		return _errmsg;
	}

protected:
	int _errid;//error code
	std::string _errmsg;//error description
};

class sqlException : public Exception
{
public:
	sqlException(int errid, const std::string& msg, const std::string& sql)
		:Exception(errid, msg)
		,_sql(sql)
	{ }

	virtual std::string what()const
	{
		std::string str = "sqlException: ";
		str += _errmsg;
		str += "->";
		str += _sql;

		return str;
	}
private:
	const std::string _sql;
};

class cacheException :public Exception
{
public:
	cacheException(int errid,const std::string& errmsg)
		:Exception(errid,errmsg)
	{ }

	virtual std::string what()const
	{
		std::string str = "cacheException:";
		str += _errmsg;
		return str;
	}
};

class httpServerException :public Exception
{
public:
	httpServerException(int errid,const std::string& errmsg,const std::string& type)
		:Exception(errid,errmsg)
		,_type(type)
	{ }

	virtual std::string what()const
	{
		std::string str = "httpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}

private:
	const std::string _type;
};

void SQLMgr()
{
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw sqlException(100,"权限不足", "select* from name = '张飞'");
	}
}

void CacheMgr()
{
	srand(time(0));
	if (rand() % 5 == 0)
	{
		throw cacheException(100,"权限不足");
	}
	else if (rand() % 6 == 0)
	{
		throw cacheException(101, "数据不存在");
	}

	SQLMgr();
}

void HttpServer()
{
	srand(time(0));
	if (rand() % 3 == 0)
	{
		throw httpServerException(100, "请求资源不存在", "get");
	}
	else if (rand() % 4 == 0)
	{
		throw httpServerException(101, "权限不足", "post");
	}

	CacheMgr();
}

int main()
{
	while (true)
	{
		std::this_thread::sleep_for(std::chrono::seconds(1));
		try
		{
			HttpServer();
		}
		catch (const Exception& e)
		{
			//多态
			std::cout << e.what() << std::endl;
		}
		catch (...)
		{
			std::cout << "unkown exception" << std::endl;
		}
	}
	return 0;
}

4.C++标准库的异常体系

C++提供了一系列标准的异常，定义在exception中，我们可以在程序中使用这些标准异常。它们以父子类层次结构组织起来的，具体如下：

异常描述
std::exception该异常说所有标准C++异常的父类
std::bad_alloc该异常可以通过new抛出
std::bad_cast该异常可以通过dynamic_cast抛出
std::bad_exception这在处理C++程序中无法预期的异常时非常有用
std::bad_typeid该异常可以通过typeid抛出
std::logic_error理论上可以通过读取代码来检测到的异常
std::domain_error当使用一个无效的数学域时，会抛出该异常
std::invalid_argument当使用了无效的参数时，会抛出该异常
std::length_error当创建了太长的std::string时，会抛出该异常
std::out_of_range该异常可以通过方法抛出，例如std::vector和std::bitset<>::operator
std::runtime_error理论上不可以通过读取代码来检测到的异常
std::overflow_error当发生数学上溢时，会抛出该异常
std::range_error当尝试存储超出范围的值时，会抛出该异常
std::underflow_error当发生数学下溢时，会抛出该异常

说明：实际中，我们可以去继承exception类实现自己的异常类。但是实际开发过程中，会自定义一套异常继承体系，因为C++标准库设计的异常不够好用。

5.异常的优缺点

C++异常的优点

  • 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息（附带各种你要的数据，如SQL语句），甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug；

  • 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误；

  • 很多第三方库都包含异常，如boost、gtest、gmock等；

  • 部分函数使用异常更好处理，如构造函数没有返回值，不方便使用错误码方式处理；

C++异常得缺点

  • 异常会导致程序得执行流乱跳，并且非常的混乱，运行时出错抛异常就会乱跳。这会给程序员跟踪调试及程序分析时添加额外负担；

  • 异常会有一些性能的开销；

  • C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题；

avatar
文章
阅读
粉丝