平武建站

【C++11】异常-创新互联

🌈1.C语言传统处理错误的方式

在讲解C++的异常机制之前我们先来复习一下传统的处理错误的方式。

10多年的洛浦网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都营销网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整洛浦建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联公司从事“洛浦网站设计”,“洛浦网站推广”以来，每个客户项目都认真落实执行。

传统的错误处理机制：

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

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

🌈2.C++异常概念

异常是一种处理错误得方式，当一个函数发现自己无法处理的错误时就可以抛异常，让函数直接的或者间接的调用者处理这个错误。异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw:

  • throw: 当问题出现，程序通过throw抛出一个异常;
  • catch: 在你想要处理问题的地方，通过异常处理程序捕获异常;
  • try: try 块中的代码标识将被激活的特定异常。它后面允许跟着一个或多个 catch 块;
    使用 try/catch 语句的语法：

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

try 
{
     // 保护代码
}

catch( ExceptionName e1 ) 
{
     // catch 块
}

catch( ExceptionName e2 )
 {
    // catch 块
}

catch( ExceptionName eN ) 
{
    // catch 块
}
🌈 3.异常的使用 🍄3.1异常的抛出和使用
🌼异常的抛出和匹配原则：
  • 1.异常是通过抛出对象而引发的，该对象的类型决定了应该激活那个catch的处理代码。
  • 2.被选中的处理代码（catch块）是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
  • 3.抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（类似于函数的传值返回）
  • 4.catch(...)可以捕获任意类型的异常，但捕获后无法知道异常错误是什么。
  • 5.实际异常的抛出和捕获的匹配原则有个例外，捕获和抛出的异常类型并不一定要完全匹配，可以抛出派生类对象，使用基类捕获。

异常必须捕获，不捕获就会报错。

🌼在函数调用链中异常展开栈展开匹配原则
  1. 当异常被抛出后，首先检查throw本身是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。
  2. 如果当前函数栈没有匹配的catch则退出当前函数栈，继续在上一个调用函数栈中进行查找匹配的catch。找到匹配的catch子句并处理以后，会沿着catch子句后面继续执行，而不会跳回到原来抛异常的地方。
  3. 如果到达main函数的栈，依旧没有找到匹配的catch，则终止程序。
  4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

例如以下代码：

#includeusing namespace std;

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;
	cin >>len >>time;
	cout<< Division(len, time)<< endl;
}

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

当Division中的异常被抛出后：

  • 首先会检查throw本身是否在try块内部，这里由于throw不在try块内部，因此会退出Division所在的函数栈，继续在上一个调用函数栈中进行查找，即Func所在的函数栈。
  • Func中也没有匹配的catch，于是就会在main所在的函数栈中进行查找，最终在main函数栈中找到了匹配的catch。
  • 这时就会跳到main函数中对应的catch块中执行对应的代码块，执行完后继续执行该代码块后续的代码.

此代码抛出了一个类型为 const char* 的异常，因此捕获异常时，须在 catch 块中使用 const char*。

  • 如果您想让 catch 块能够处理 try 块抛出的任何类型的异常，则必须在异常声明的括号内使用省略号 ...，如下所示:
try {
 // 保护代码
 }
catch(...) {
 // 能处理任何异常的代码
}

这个可以防止出现未捕获的异常时程序崩溃。

🍄3.2异常的重新抛出 

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

但如果直接让最外层捕获异常进行处理可能会引发一些问题。

double Division(int a, int b)
{
	if (b == 0)  //b==0时会抛出异常
	{
		throw" Division by zero condition!";
	}
	return (double)a / (double)b;
}
void Func()
{
	int* array = new int[10];
	int len, time;
	cin >>len >>time;
	cout<< Division(len, time)<< endl;

	cout<< "delete []"<< array<< endl;
	delete[] array;

}

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

  • 我们就先看Func功能函数那一块，先new一块空间，然后就可以通过delete释放了，这种情况是未抛异常是的运行，但是肯定会有点不正常的情况--------->>>>>>>
  • 如果说Division函数抛出一个异常，这时会直接跳转到main函数中的catch块执行对应的异常处理程序，并且在处理完后继续沿着catch块往后执行。
  • 这时就导致Func中申请的内存块没有得到释放，造成了内存泄露。

  • 这时可以在Func中先对Func抛出的异常进行捕获，捕获后先将申请到的内存释放再将异常重新抛出，这时就避免了内存泄露。
void Func()
{
	int* array = new int[10];
	int len, time;
	cin >>len >>time;
    try
    {
    	cout<< Division(len, time)<< endl;
    }

    catch(...)
    {
       cout<< "delete []"<< array<< endl;
	   delete[] array;
 
	   throw;  //捕获什么抛出什么
    }
    cout<< "delete []"<< array<< endl;
	delete[] array;

}
🍄3.3异常安全问题

将抛异常导致的安全问题叫做异常安全问题，对于异常安全问题下面给出几点建议：

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

为了让函数使用者知道某个函数可能抛出哪些类型的异常，C++标准规定：

  1. 在函数的后面接throw(type1, type2, ...)，列出这个函数可能抛掷的所有异常类型。
  2. 在函数的后面接throw()或noexcept（C++11），表示该函数不抛异常。
  3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。（异常接口声明不是强制的）。

例如以下代码：

//表示func函数可能会抛出A/B/C/D类型的异常
void func() throw(A, B, C, D);
//表示这个函数只会抛出bad_alloc的异常
void* operator new(std::size_t size) throw(std::bad_alloc);
//表示这个函数不会抛出异常
void* operator new(std::size_t size, void* ptr) throw();
🌈4.自定义异常体系 

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。

查看源图像

例如以下代码：

//父类接口
class Exception
{
public:
	Exception(int errid = 0, const string& errmsg = "")
		:ErrId(errid)
		, ErrMsg(errmsg)
	{}


	virtual string what() const
	{
		return ErrMsg;
	}
protected:
	int ErrId;
	string ErrMsg;//异常消息
};

//子类进行继承
//定义一个内存错误
class MemException :public Exception
{
public:
	MemException(int errid = 0, const string& errmsg = "", const string& memstring = "")
		:Exception(errid, errmsg)
		, MemString(memstring)
	{}

	virtual string what() const
	{
		string str = "MemError: ";
		str += ErrMsg;
		str += "[Mem:";
		str += MemString;
		str += "]";

		return str;
	}

private:
	string MemString;
};

//定义一个链接错误
class LinkException :public Exception
{
public:
	LinkException(int errid = 0, const string& errmsg = "", const string& linkstring = "")
		:Exception(errid, errmsg)
		, LinkString(linkstring)
	{}

	virtual string what() const
	{
		string str = "LinkError:";
		str += ErrMsg;

		str += "[Link:";
		str += LinkString;
		str += "]";

		return str;
	}

private:
	string LinkString;
};

void func()
{
	int val = rand() % 10;

	if (val == 2)//假设为内存错误
	{
		MemException e(1, "内存错误", "申请内存过大");//构建一个异常对象
		throw e;
	}
	else if (val == 3)//假设为链接错误
	{
		LinkException e(2, "链接错误", "链接对象过多");//构建一个链接异常对象
		throw e;
	}
	else if (val == 4)
	{
		vector(1000000000, 110000000);//使用系统异常
	}

}
int main()
{

	srand((unsigned)time(NULL));
	for(int i=0;i<100;i++)
	{
		try
		{
			func();
		}
		catch (const Exception& e)
		{
			cout<< "自定义异常体系："<< e.what()<< endl;
		}
		catch (const exception& e)
		{
			cout<< "C++自带异常体系"<< e.what()<< endl;
		}
		catch (...)
		{
			cout<< "未知异常"<< endl;
		}
	}

	return 0;
}

（这个代码是@今天我要写bug大佬写的，我借用以下）

🌈5.C++标准库的异常体系

C++标准库当中的异常也是一个基础体系，其中exception就是各个异常类的基类，我们可以在程序中使用这些标准的异常，它们之间的继承关系如下：

71. 异常

71. 异常

🌈6.异常的优缺点 
  • 异常的优点：
  1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用等信息，这样可以帮助更好的定位程序的bug。
  2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误码，最终最外层才能拿到错误。
  3. 很多的第三方库都会使用异常，比如boost、gtest、gmock等等常用的库，如果我们不用异常就不能很好的发挥这些库的作用。
  4. 很多测试框架也都使用异常，因此使用异常能更好的使用单元测试等进行白盒的测试。
  5. 部分函数使用异常更好处理，比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。
  • 异常的缺点：
  1. 异常会导致程序的执行流乱跳，并且非常的混乱，这会导致我们跟踪调试以及分析程序时比较困难。
  2. 异常会有一些性能的开销，当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
  3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄露、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题，学习成本比较高。
  4. C++标准库的异常体系定义得不够好，导致大家各自定义自己的异常体系，非常的混乱。
  5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，也会让外层捕获的用户苦不堪言。
  6. 异常接口声明不是强制的，对于没有声明异常类型的函数，无法预知该函数是否会抛出异常。

既然C++11提出了异常，那它就是利大于弊的，但是各位小伙伴在使用时一定要注意操作规范！

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧


文章题目：【C++11】异常-创新互联
文章URL：http://pwwzsj.com/article/dsijdi.html

其他资讯