65、C++中的异常处理（下）

已于 2022-11-20 12:10:36 修改
阅读量219 收藏 1
点赞数
分类专栏： C++ 文章标签： C++中的异常处理
于 2019-09-22 09:06:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiebs/article/details/101116800
版权

1、C++中的异常处理

  • catch 语句块中可以抛出异常
    在这里插入图片描述
    分析：本来一般是 try 里面运行函数，函数里面如果出现异常就会 throw 出一个参数，然后 catch 接收。但是在 catch 里面还能抛出一个 throw 出来，这个 throw 就需要外层的 try…catch…接收。
throw;    //捕获到什么抛出什么

问题：为什么要在 catch 中重新抛出异常呢？

  • catch 中捕获的异常可以被重新解释后抛出
  • 工程开发中使用这样的方式统一异常类型
    在这里插入图片描述
    比如说我们的私有库有些东西没有，这时候我们就去调用第三方库，但是第三方库的返回异常类型和私有库我们常用的异常类型是不一样的，于是我们就可以在 catch 中重新抛出异常使它返回成我们私有库中相同的类型。

示例1：

#include <iostream>
using namespace std;

int main()
{
	try
	{
		throw 1;
	}
	catch (int i)
	{
		throw i;
	}
	catch (...)
	{
		throw;
	}
	return 0;
}

在这里插入图片描述
分析：原因在于我们在 catch 里面再次抛出异常，因为没有外层的 try…catch…接收，因此会报错。解决的方案就是在外层加一个 try…catch…

示例2：

#include <iostream>
using namespace std;

void demo()
{
	try
	{
		try
		{
			throw 1;
		}
		catch (int i)
		{
			cout << "inner:catch (int i)" << endl;
			throw i;
		}
		catch (...)
		{
			cout << "inner:catch (...)" << endl;
			throw;
		}
	}
	catch (int i)
	{
		cout << "outer:catch (int i)" << endl;
	}
}
int main()
{
	demo();
	return 0;
}

在这里插入图片描述
示例3：

#include <iostream>
using namespace std;

void func(int i)				//第三方库
{
	if (i < 0)
	{
		throw -1;
	}
	if (i > 100)
	{
		throw - 2;
	}
	if (i == 11)
	{
		throw - 3;
	}
	cout << "Run func()..." << endl;
}

void MYFUNC(int i)
{
	try
	{
		func(i);
	}
	catch (int i)
	{
		switch (i)
		{
		case -1:
			throw "Invalid Parameter";
			break;
		case -2:
			throw "Run error";
			break;
		case -3:
			throw "Timeout exception";
			break;
		}
	}
}
int main()
{
	try
	{
		MYFUNC(11);
	}
	catch (const char* s)
	{
		cout << "Exception Info : " << s << endl;
	}
	return 0;
}

在这里插入图片描述
2、类类型异常

  • 异常的类型可以是自定义类型
  • 对于类类型的异常的匹配依旧是自上而下严格匹配
  • 赋值兼容性原则在异常匹配中依然适用（子类的异常对象可以被父类的 catch 抓住）
  • 一般而言
    — 匹配子类异常的 catch 放在上部
    — 匹配父类异常的 catch 放在下部

在工程中对定义一系列的异常类

  • 每个类代表工程中可能出现的一种异常类型
  • 代码复用是可能需要重解释不同的异常类
  • 在定义 catch 语句块时推荐使用引用作为参数
#include <iostream>
#include <string>
using namespace std;
class Base
{

};

class Exception : public Base
{
	int m_id;
	string m_desc;
public:
	Exception(int id, string desc)
	{
		m_id = id;
		m_desc = desc;
	}
	int ID()const
	{
		return m_id;
	}
	string description()const
	{
		return m_desc;
	}
};
void func(int i) //第三方库
{
	if (i < 0)
	{
		throw -1;
	}
	if (i > 100)
	{
		throw - 2;
	}
	if (i == 11)
	{
		throw - 3;
	}
	cout << "Run func()..." << endl;
}

void MYFUNC(int i)
{
	try
	{
		func(i);
	}
	catch (int i)
	{
		switch (i)
		{
		case -1:
			throw Exception(-1, "Invalid Parameter");
			break;
		case -2:
			throw Exception(-2, "Run error");
			break;
		case -3:
			throw Exception(-3, "Timeout exception");
			break;
		}
	}
}
int main()
{
	try
	{
		MYFUNC(11);
	}
	catch (const Exception& e)
	{
		cout << "Exception Info : " << endl;
		cout << "ID = : " << e.ID() << endl;
		cout << "Description = : " << e.description() << endl;
	}
	return 0;
}

在这里插入图片描述
在这里插入图片描述
这里主要是为了防止自赋值。防止拷贝构造，提高程序的效率

如果把代码改成下面这样：

#include <iostream>
#include <string>
using namespace std;
class Base
{

};

class Exception : public Base
{
	int m_id;
	string m_desc;
public:
	Exception(int id, string desc)
	{
		m_id = id;
		m_desc = desc;
	}
	int ID()const
	{
		return m_id;
	}
	string description()const
	{
		return m_desc;
	}
};
void func(int i) //第三方库
{
	if (i < 0)
	{
		throw -1;
	}
	if (i > 100)
	{
		throw - 2;
	}
	if (i == 11)
	{
		throw - 3;
	}
	cout << "Run func()..." << endl;
}

void MYFUNC(int i)
{
	try
	{
		func(i);
	}
	catch (int i)
	{
		switch (i)
		{
		case -1:
			throw Exception(-1, "Invalid Parameter");
			break;
		case -2:
			throw Exception(-2, "Run error");
			break;
		case -3:
			throw Exception(-3, "Timeout exception");
			break;
		}
	}
}
int main()
{
	try
	{
		MYFUNC(11);
	}
	catch (const Base& b)
	{
		cout << "catch (const Base& b)" << endl;
	}
	catch (const Exception& e)
	{
		cout << "Exception Info : " << endl;
		cout << "ID = : " << e.ID() << endl;
		cout << "Description = : " << e.description() << endl;
	}
	return 0;
}

在这里插入图片描述
这个程序充分说明了赋值兼容性原则在异常匹配中依然适用（子类的异常对象可以被父类的 catch 抓住）

所以：
匹配子类异常的 catch 放在上部
匹配父类异常的 catch 放在下部

3、C++中的异常处理

  • C++标准库提供了实用 异常 类族
  • 标准库中的异常都是从 exception 类派生的，头文件#include <stdexcept>
  • exception 类有两个主要分支
    — logic_error
    　　常用于程序中的可避免逻辑错误
    — runtime_error
    　　常用于程序中的无法避免的恶性错误
  • 标准库中的异常
    在这里插入图片描述

Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_
#pragma once

#include <stdexcept>
using namespace std;

template <typename T, int N>
class Array
{
private:
	T m_array[N];
public:
	int length()const;
	bool set(int index,T value);
	bool get(int index, T& value);
	T& operator[](int i);
	T operator[](int i)const;
	virtual ~Array();
};

template <typename T, int N>
int Array<T, N>::length()const
{
	return N;
}

template <typename T, int N>
bool Array<T, N>::set(int index, T value)
{
	bool ret = (index >= 0) && (index < N);
	if (ret)
	{
		m_array[index] = value;
	}
	return ret;
}

template <typename T, int N>
bool Array<T, N>::get(int index, T& value)
{
	bool ret = (index >= 0) && (index < N);
	if (ret)
	{
		value = m_array[index];
	}
	return ret;
}

template <typename T, int N>
T& Array<T, N>::operator[](int i)
{
	if (i >= 0 && i < N)
	{
		return m_array[i];
	}
	else
	{
		throw out_of_range("T& Array<T, N>::operator[](int i)");
	}
}

template <typename T, int N>
T Array<T, N>::operator[](int i)const
{
	if (i >= 0 && i < N)
	{
		return m_array[i];
	}
	else
	{
		throw out_of_range("T Array<T, N>::operator[](int i)const");
	}
}


template <typename T, int N>
Array<T, N>::~Array()
{

}
#endif

HeapArray.h

#ifndef _HEAPARRAY_H_
#define _HEAPARRAY_H_
#pragma once

#include <stdexcept>
using namespace std;

template <typename T>
class HeapArray
{
private:
	T* m_pointer;
	int m_length;

	HeapArray(int len);
	bool construct();
public:
	static HeapArray* NewInstance(int length);
	int length()const;
	bool set(int index, T value);
	bool get(int index, T& value);
	HeapArray& self();
	const HeapArray self()const;
	T& operator[](int i);
	T operator[](int i)const;
	HeapArray& operator=(const HeapArray& obj);
	~HeapArray();
};


template <typename T>
HeapArray<T>::HeapArray(int len)
{
	m_length = len;
}

template <typename T>
bool HeapArray<T>::construct()
{
	bool ret = true;
	m_pointer = new T[m_length];

	return (m_pointer != NULL);
}

template <typename T>
HeapArray<T>* HeapArray<T>::NewInstance(int length)
{
	HeapArray* ret = new HeapArray(length);
	if (!(ret && ret->construct()))
	{
		delete ret;
		ret = nullptr;
	}

	return ret;
}

template <typename T>
int HeapArray<T>::length()const
{
	return m_length;
}

template <typename T>
HeapArray<T>& HeapArray<T>::self()
{
	return *this;
}

template <typename T>
const HeapArray&<T> HeapArray<T>::self()const
{
	return *this;
}


template <typename T>
bool HeapArray<T>::set(int index, T value)
{
	bool ret = (index >= 0 && index < m_length);
	if (ret)
	{
		m_pointer[index] = value;
	}
	return ret;
}

template <typename T>
bool HeapArray<T>::get(int index, T& value)
{
	bool ret = (index >= 0 && index < m_length);
	if (ret)
	{
		value = m_pointer[index];
	}
	return ret;
}

template <typename T>
T& HeapArray<T>::operator[](int i)
{
	if (i >= 0 && i < m_length)
	{
		return m_pointer[i];
	}
	else
	{
		throw out_of_range("T& HeapArray<T>::operator[](int i)");
	}
}

template <typename T>
T HeapArray<T>::operator[](int i)const
{
	if (i >= 0 && i < m_length)
	{
		return m_pointer[i];
	}
	else
	{
		throw out_of_range("T HeapArray<T>::operator[](int i)const");
	}
}

template <typename T>
HeapArray<T>& HeapArray<T>::operator=(const HeapArray& obj)
{
	if (this != &obj)
	{
		m_length = obj.m_length;
		delete[]m_pointer;
		m_pointer = new T[obj.m_length];
		if (m_pointer != nullptr)
		{
			for (int i = 0; i < obj.m_length; i++)
			{
				m_pointer[i] = obj.m_pointer[i];
			}
		}
	}
	return *this;
}

template <typename T>
HeapArray<T>::~HeapArray()
{
	delete[]m_pointer;
}
#endif

main.cpp

#include <iostream>
#include "HeapArray.h"
#include "Array.h"
#include <string>
using namespace std;

void TestArray()
{
	Array<char, 5> a;
	for (int i = 0; i < a.length(); i++)
	{
		a[i] = i + 'a';
	}
	for (int i = 0; i < a.length(); i++)
	{
		cout << a[i] << endl;
	}
}
void TestHeapArray()
{
	HeapArray<double> *a = HeapArray<double>::NewInstance(5);
	HeapArray<double>& array = a->self();
	for (int i = 0; i < 10; i++)
	{
		array[i] = i + 1;
	}
	for (int i = 0; i < array.length(); i++)
	{
		cout << array[i] << endl;
	}
}
int main()
{
	try
	{
		TestArray();
	}
	catch (...)
	{
		cout << "Exception" << endl;
	}

	try
	{
		TestHeapArray();
	}
	catch (...)
	{
		cout << "Exception" << endl;
	}

	return 0;
}

小结：

  • catch 语句块中可以抛出异常
  • 异常的类型可以是自定义类类型
  • 赋值兼容性原则在异常匹配中依然适用
  • 标准库中的异常都是从exception类派生而来
xiebs_
关注
专栏目录
C++中异常处理的基本思想及throw语句抛出异常的使用
09-02
总的来说，C++的异常处理提供了一种高效且灵活的方式来处理程序中的异常情况，它使得错误处理更加模块化和易于管理，同时保证了资源的正确释放。理解异常处理的基本思想和语法对于编写健壮的C++代码至关重要。
C++中异常处理中的异常重新抛出的一种用法
风拔萝卜的博客
09-08 3610
本文讨论了C++异常处理中重复抛出异常的一种用法
C++中用try catch抛出异常
hwj729748198的博客
04-01 2095
在学数据中，发现书上的代码段中对输入错误的数据进行throw 处理，以前没搞懂，现在查资料弄一弄。这是线性表插入的代码void List::insert(int n,int x) { if(n&lt;1||n&gt;100)throw"溢出"; if(n&gt;=len)throw"位置"; for(int i=len-1;i&gt;=n-1;i--) { data[i+1]=dat...
c++异常处理机制
jxm_96的博客
11-11 567
异常处理 增强错误恢复能力是提高代码健壮性的最有力的途径之一，C语言中采用的错误处理方法被认为是紧耦合的，函数的使用者必须在非常靠近函数调用的地方编写错误处理代码，这样会使得其变得笨拙和难以使用。C++中引入了异常处理机制，这是C++的主要特征之一，是考虑问题和处理错误的一种更好的方式。使用错误处理可以带来一些优点，如下: · 错误处理代码的编写不再冗长乏味，并且不再和正常的代码混合在一起，程序
TimeoutException（超时异常）可能的原因和解决方法
最新发布
Java开源程序猿
12-28 6928
时，适当地检查异常的类型，并采取适当的处理措施。详细的错误日志和异常堆栈信息对于定位和解决问题非常有帮助。通常表示一个操作在规定的时间内没有完成。时，适当地检查异常的类型，并采取适当的处理措施。
C++之异常处理详解
12-26
程序中的错误分为编译时的错误和运行时的错误。编译时的错误主要是语法错误，比如：句尾没有加分号，...C++中所提供的异常处理机制结构清晰，在一定程度上可以保证程序的健壮性。 C++中处理异常的过程是这样的：在执
C++程序的异常处理技巧
01-19
处理 C++ 中的异常会在语言级别上遇到少许隐含限制，但在某些情况下，您可以绕过它们。学习各种利用异常的方法，您就可以生产更可靠的应用程序。 　保留异常信息 　在C++中，无论何时在处理程序内捕获一个异常，...
C++异常处理的说明及使用
10-09
C++异常处理是一种机制，用于在程序运行时处理意外或错误情况。这种机制允许程序员优雅地处理错误，而不是让程序崩溃。在C++中，异常处理主要依赖于`try`、`catch`和`throw`这三个关键字。 1. **try语句块**：这是...
理解C++中的异常处理机制
01-21
C++中引入了异常处理机制，这是C++的主要特征之一，是考虑问题和处理错误的一种更好的方式。使用错误处理可以带来一些优点，如下: 　错误处理代码的编写不再冗长乏味，并且不再和正常的代码混合在一起，程序员只...
C++中的异常处理（下）
weixin_46258483的博客
09-15 350
#include <iostream> #include <string> using namespace std; void Demo() { try { try { throw 'c'; } catch(int i) { cout << "Inner: catch(int i)" << endl; ...
TimeoutException 超时异常类解析
小白爱学习的专栏
07-29 4342
package test.java.util.concurrent; import java.util.concurrent.TimeoutException; import org.junit.Test; /** * TimeoutException的测试类 * 超时处理异常类 * @date 2020-07-29 20:32:57 */ public class TimeoutExceptionTest { /** * 无参构造函数 * @.
C++异常处理机制（超级详细）
qq_54169998的博客
10-30 1万+
目录 0.异常处理机制简介 1.传统错误处理机制（通过函数返回值） 2.异常处理机制语法 ​3.异常接口声明 4.异常类型和声明周期 4.1throw基本类型异常（int 、float、char.....） 4.2throw字符串类型异常 ​ 4.3throw类对象类型异常 4.3.1第一种：抛出匿名对象，使用形参接收 ​4.3.2第二种： 抛出局部变量，使用形参接收 4.3.3第三种：抛出匿名对象，使用引用接收（代码优化 ） 5.异常和继承 6. 额外补充——标准库里的异常.
SocketTimeoutException和ConnectException简介
热门推荐
孤云博客
01-10 6万+
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) SocketTimeoutException： 一、简介： SocketTimeoutException：指的是服务器响应超时 直接继承自java.io.InterruptedIOException，实现了可...
android部分机型TimeoutException问题解决方案总结
小小9575的博客
12-11 2075
android部分机型TimeoutException问题解决方案总结 java.util.concurrent.TimeoutException这个问题涉及到OPPO的很多机型，华为的部分机型和少量的其他机型，导致这个异常的原因很多GC过程中CPU休眠、IO负载高、FinalizerDaemon线程优先级低等多种原因，反正就是没办法从根源解决。 目前网上给出的解决方案有三种，下面我们一一列举。 ...
TimeoutException错误类的引入
木头生辉的专栏
12-01 2180
在pycharm中，except TimeoutException中的TimeoutException没有报错，但是在延迟时报错，报错原因是name "TimeoutException" is not defined 。。引入TimeoutException就正常 from selenium.common.exceptions import TimeoutException ...
timeoutexception异常_经验分享：TimeoutException问题分析与解决
weixin_39785081的博客
12-03 8644
问题概述在我们项目开发中，在Crash收集平台可能会经常遇到TimeoutException相关的Crash，通常在OPPO的Android 5.0 - 6.0的手机会复现，输出的堆栈日志大概有下面几种： java.util.regex.Pattern.finalize() timed out after 120 seconds com.android.internal.os.BinderI...
C与C++异常处理深度解析
"C与C++中的异常处理.pdf" 是一本深入探讨C和C++异常处理机制的书籍，由Robert Schmidt撰写并由无情翻译。本书旨在帮助读者理解这两种编程语言中的错误处理策略。 异常处理是编程中至关重要的一部分，它允许程序员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值