C++：异常

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()
{
	//Func();

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

	return 0;
}

3. 异常的使用

（1）异常的抛出和捕获

异常的抛出和匹配原则

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。

2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，

所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似

于函数的传值返回）

例如：throw str； catch(const string& s); str生成一个临时拷贝传给s

4. catch(...)可以捕获任意类型的异常，只是不知道异常错误是什么。

5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，

使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

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

1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则

调到catch的地方进行处理。

2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。

3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的

catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异

常，否则当有异常没捕获，程序就会直接终止。

4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

解释：2.被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个：（同一个位置不可有两个相同的捕获，只能在不同位置有捕获）

假设输入cin >> len >> time; 是1,0，此处Func和main都有异常捕获，main调用Func函数，Func调用Division函数，Division中抛的异常，则会跳到最近的Func中被捕获，被捕获后面的代码正常运行，main中的捕获就不执行了。

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

void Func()
{
	try
	{
		int len, time;
		cin >> len >> time;
		cout << Division(len, time) << endl;
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
正常运行下面的代码：
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}

int main()
{
	//Func();

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

	return 0;
}

解释：4. catch(...)可以捕获任意类型的异常，只是不知道异常错误是什么。

	
    try
    {
        
    }
    catch (...) // 捕获没有匹配的任意类型异常
	{
		cout << "未知异常" << endl;
	}

解释：5. 可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

库中定义了一个基类叫 exception，抛异常的类型只要继承exception或者就是exception，即抛异常的类是exception的子类，就可以利用exception捕获。例如 bad_alloc类是基类exception 的子类，则new抛异常既可以用bad_alloc类捕获异常，也可以用基类exception捕获异常。

new抛异常用bad_alloc类捕获

what()返回字符串异常的信息——了解错误的描述

公司中标准的捕获写法：

    try
    {
       ……
    }
    catch(const exception& e)    ——捕获正常的异常
    {
       ……
    }
    catch(...)                ——捕获某些新手写的未知异常
    {
       ……
    }

		try
		{
            ……			
		}
		catch (const bit::Exception& e)  这里捕获自己定义的父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (const std::exception& e)  这里捕获库中父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)                    这里捕获未知异常
		{
			cout << "Unkown Exception" << endl;
		}

4.自定义异常体系

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

namespace bit
{
	// 服务器开发中通常使用的异常继承体系
	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 HttpServerException : public Exception
	{
	public:
		HttpServerException(const string& errmsg, int id, const string& type)
			:Exception(errmsg, id)
			, _type(type)
		{}

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

			return str;
		}

	private:
		const string _type;
	};

	void SQLMgr()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw SqlException("权限不足", 100, "select * from name = '张三'");
		}
		else
		{
			cout << "Sql success" << endl;
		}
	}

	void CacheMgr()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw CacheException("权限不足", 100);
		}
		else if (rand() < RAND_MAX / 4)
		{
			throw CacheException("数据不存在", 101);
		}
		else
		{
			cout << "Cache success" << endl;
		}

		SQLMgr();
	}

	void SeedMsg(const string& str)
	{
		if (rand() < RAND_MAX - 10000)
		{
			throw HttpServerException("SeedMsg::网络错误", 2, "put");
		}
		else if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("SeedMsg::你已经不是对方好友", 1, "post");
		}
		else
		{
			cout << "消息发送成功！->" << str << endl;
		}
	}

	void HttpServer()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("请求资源不存在", 404, "get");
		}
		else if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("权限不足", 501, "post");
		}
		else
		{
			cout << "Http success" << endl;
		}

		CacheMgr();
	}
}

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

	while (1)
	{
		//this_thread::sleep_for(chrono::seconds(1));
		::Sleep(1000);

		try
		{
			//bit::HttpServer();

			// 发送出现网络错误，要求重试10次
			// 权限错误就直接报错 -- 17:20继续
			for (size_t i = 0; i < 10; ++i)
			{
				try
				{
					bit::SeedMsg("你好啊！今晚一起看电影怎么样？");
					break;
				}
				catch (const bit::Exception& e)
				{
					if (e.getid() == 2) // 异常编码的价值，针对某个错误进行特殊处理
					{
						cout << "网络错误，重试发消息第" <<i<<"次"<< endl;
						continue;
					}
					else // 其他错误
					{
						//break;
						throw e;	// 异常重新抛出 
					}
				}
			}
			
		}
		catch (const bit::Exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (const std::exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}

	return 0;
}

4.异常规范

1. 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。可以在函数的

后面接 throw( 类型 ) ，列出这个函数可能抛掷的所有异常类型。

2. 函数的后面接 throw() ，表示函数不抛异常。

3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。

     这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
     这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
     这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();

     C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;

5.异常的优缺点

C++异常的优点：

1. 异常对象定义好了，相比错误码的方式可以 清晰准确 的展示出错误的各种信息，甚至可以包

含堆栈调用的信息，这样可以帮助更好的定位程序的bug。

2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那

么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。即：错误码调用深的时候需要层层返回，而异常一步到位

3. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们

也需要使用异常。

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

T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回

值表示错误。

C++异常的缺点：

1. 异常会导致程序的 执行流乱跳 ，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会

导致我们跟踪调试时以及分析程序时，比较困难。

2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。

3. C++没有垃圾回收机制 ，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常

安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。

4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。

5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常

规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都

使用 func（） throw();的方式规范化。

总结：异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外OO的语言基本都是

用异常处理错误，这也可以看出这是大势所趋。

其他语法,异常机制基本差不多
C+ +独有缺陷:
1、标准库定义不够好用。还想看堆栈等都不支持等，所以很多公司自己定义一套自己的。
2、C+ +没有垃圾回收器，所以申请内存和释放内存位置要非常小心。容易泄漏，需要RAII机制再补充。

sponge'

关注

8
点赞
踩
7

收藏

觉得还不错? 一键收藏
6
评论
C++：异常

此时throw抛异常的地方直接跳到catch中，抛的异常类型要对上，所以这里跳到catch (const char* errmsg){// 当b == 0时抛出异常";try{Func();}3. 异常的使用3.1 异常的抛出和捕获异常的抛出和匹配原则1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。2. 被选中的处理代码。
复制链接

扫一扫