C++ 异常的语法，栈解旋和接口声明，异常的生命周期、层次结构、标准异常库

最新推荐文章于 2022-01-02 15:01:49 发布
最新推荐文章于 2022-01-02 15:01:49 发布
阅读量214 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ai_King/article/details/104144744
版权

1. 基本语法

通过异常可以使原本会发生宕机的异常被特殊处理。程序给出提示，但程序不崩溃。

  1. 发生异常之后，是跨函数的
  2. 接收异常之后，可以不处理，再抛出
  3. catch异常时，按照类型进行catch
  4. 异常捕捉严格按照类型匹配
#include <iostream>
using namespace std;

//1 发生异常之后，是跨函数的
//2 接收异常之后，可以不处理，再抛出
//3 catch异常时，按照类型进行catch
//4 异常捕捉严格按照类型匹配

//异常的 栈解旋 就是在抛出异常时，调用相应的析构函数。

void divide(int x, int y)
{
	if (y == 0)
	{
		throw x;//抛出int类型异常
	}
	cout << "divide result: " << x / y << endl;
}

//发生异常之后，是跨函数的
void myDivide(int x, int y)
{
	try
	{
		divide(x, y);
	}
	catch (...)
	{
		cout << "我接收了divide的异常，不处理往上抛" << endl;
		throw;
	}
}

int main()
{
	try
	{
		divide(10, 2);
		//divide(100, 0);

		myDivide(20, 0);
	}
	catch (const int e)
	{
		cout << e << " is divided by 0!" << endl;
	}
	catch (...)
	{
		cout << "其他未知类型异常" << endl;
	}

	return 0;
}

2. 栈解旋和异常接口声明

#include <iostream>
using namespace std;

class Test3
{
public:
	Test3(int a = 0, int b = 0)
	{
		this->a = a;
		this->b = b;
		cout << "构造函数" << endl;
	}
	~Test3()
	{
		cout << "析构函数" << endl;
	}

private:
	int a;
	int b;
};

//不写，抛出所有类型异常
void myDivide()
{
	Test3 t1(1, 2), t2(3, 4);
	cout << "myDide即将发生异常" << endl;
	throw 1;//抛出异常时，会析构t1，t2，这就是栈解旋，这样可以防止程序崩溃
}

//抛出已写类型的异常
void myDivide2() throw(int, char, char*)
{
	Test3 t1(1, 2), t2(3, 4);
	cout << "myDide2即将发生异常" << endl;
	throw 1;
}

//不抛出任何类型的异常
void myDivide3() throw()
{
	Test3 t1(1, 2), t2(3, 4);
	cout << "myDide3即将发生异常" << endl;
	throw 1;
}

int main()
{
	try
	{
		//myDivide();//抛出异常时，程序结束
		myDivide2();
		//myDivide3();

	}
	catch (int a)
	{
		cout << "int 型异常" << endl;
	}

	return 0;
}

3. 异常的生命周期

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

//使用异常的方式进行处理


void my_strcpy1(char *dst, char *from) {
	if (dst == NULL) {
		throw 1; //1 代表目的地址有问题
	}
	else if (from == NULL) {
		throw 2; //2 代表源地址有问题
	}

	if (*from == 'a') {
		throw 3; //代表copy过程出现问题
	}


	while (*from != '\0') {
		*dst = *from;
		dst++;
		from++;
	}
	*dst = '\0';
}


void my_strcpy2(char* dst, char *from) 
{
	if (dst == NULL) {
		throw "目的地址有问题"; //1 代表目的地址有问题
	}
	else if (from == NULL) {
		throw "源地址有问题"; //2 代表源地址有问题
	}

	if (*from == 'a') {
		throw "copy过程出现问题"; //代表copy过程出现问题
	}


	while (*from != '\0') {
		*dst = *from;
		dst++;
		from++;
	}
	*dst = '\0';
}

//目的地址有问题的异常类型
class BadDstAddrType{};
class BadSrcAddrType{};
class BadProcessAddrType{
public:
	BadProcessAddrType()
	{
		cout << "BadProcessAddrType().." << endl;
	}
	BadProcessAddrType(const BadProcessAddrType & obj)
	{
		cout << "BadProcessAddrType(const BadProcessAddrType &)..." << endl;
	}
	void print() {
		cout << "copy过程出现了异常" << endl;
	}
	~BadProcessAddrType(){
		cout << "~BadProcessAddrType()..." << endl;
	}
};

void my_strcpy3(char *dst, char *from)
{
	if (dst == NULL) {
		throw BadDstAddrType(); //1 代表目的地址有问题
	}
	else if (from == NULL) {
		throw BadSrcAddrType(); //2 代表源地址有问题
	}

	if (*from == 'a') {
		//throw new BadProcessAddrType(); //在抛出这个BadProcessAddrType() 会创建一个匿名对象 
		throw BadProcessAddrType();
	}


	while (*from != '\0') {
		*dst = *from;
		dst++;
		from++;
	}
	*dst = '\0';
}

int main(void)
{
	char buf1[] = "a234567";
	char buf2[128] = { 0 };

	try {
		my_strcpy3(buf2, buf1);
	}
	catch (int e)
	{
		cout << "捕获到异常代码e = " << e << endl;
	}
	catch (char *e)
	{
		cout << "捕获到char*类型异常e = " << e << endl;
	}
	//catch (BadProcessAddrType e) { //BadProcessAddrType e = 匿名对象temp //在捕获的时候，如果用一个元素捕获
													//会发生拷贝构造，异常对象e和被抛出来的匿名对象不是一个对象
													//会有深拷贝和浅拷贝的风险
//		cout << "捕获到了BadProcessAddrType 异常类型e  " << endl;
//		e.print();
//	}
	catch (BadProcessAddrType *e) { //此时那个匿名对象已经被释放了，e是一个野指针
		cout << "捕获到了BadProcessAddrType* 异常类型e" << endl;
		delete e; //如果抛出的异常类型是new出来的，需要显示的delete掉
	}
	catch (BadProcessAddrType &e) { //1 普通元素类型的异常捕获，不能够跟 引用捕获同时存在。
		cout << "捕获到了 BadProcessAddrType & 异常类型" << endl;
		//编译器发现使用引用捕获的，那么不会立刻释放掉匿名对象， 而是在异常处理完之后，才把e释放。
		//可以理解为 BadProcessAddrType &e = BadProcessAddrType()
	}
	catch(...) 
	{
		cout << "捕获到未知异常" << endl;
	}
}

#if 0
int my_strcpy(char *dst, char *from)
{
	if (dst == NULL) {
		return 1; //1 代表目的地址有问题
	}
	else if (from == NULL) {
		return 2; //2 代表源地址有问题
	}

	if (*from == 'a') {
		return 3; //代表copy过程出现问题
	}


	while (*from != '\0') {
		*dst = *from;
		dst++;
		from++;
	}
	*dst = '\0';

	return 0;
}

//传统的捕获错误方法
int main(void)
{
	char buf1[] = "a234567";
	char buf2[128] = { 0};
	int ret = 0;

	ret = my_strcpy(buf2, buf1);
	if (ret != 0) {
		switch (ret)
		{
		case 1:
			cout << "目的地址有问题" << endl;
			break;
		case 2:
			cout << "原地址有问题" << endl;

			break;
		case 3:
			cout << "拷贝过程有问题" << endl;

			break;
		default:
			break;
		}
	}
	else {
		cout << "buf2 = " << buf2 << endl;
	}

	
	return 0;
}
#endif

4. 异常的层次结构

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

class eSize
{
public:
	eSize(int len)
	{
		this->len = len;
	}
	virtual void printErr() {
		cout << "eSize error: len = " << len << endl;
	}
protected:
	int len;
};

class eNagtive :public eSize
{
public:
	eNagtive(int len): eSize(len) {
	}

	virtual void printErr()
	{
		cout << "eNagtive error: len = " << len << endl;
	}
};

class eZero :public eSize
{
public:
	eZero(int len) :eSize(len) {

	}

	virtual void printErr()
	{
		cout << "eZero error: len = " << len << endl;
	}
};

class eTooBig :public eSize
{
public:
	eTooBig(int len) :eSize(len) {

	}

	virtual void printErr()
	{
		cout << "eTooBig error: len = " << len << endl;
	}
};

class eTooSmall :public eSize
{
public:
	eTooSmall(int len) :eSize(len) {

	}

	virtual void printErr()
	{
		cout << "eTooSmall error: len = " << len << endl;
	}
};

class MyArray
{
public:
	MyArray(int len)
	{
		if (len < 0) {
			throw eNagtive(len);
		}
		else if (len == 0) {
			throw eZero(len);
		}
		else if (len > 1000) {
			throw eTooBig(len);
		}
		else if (len < 10) {
			throw eTooSmall(len);
		}
		this->len = len;
		this->space = new int[len];
	}

	int & operator[](int index)
	{
		return this->space[index];
	}

	int getLen()
	{
		return this->len;
	}

	~MyArray() {
		if (this->space != NULL) {
			delete[] this->space;
			this->space = NULL;
			this->len = 0;
		}
	}
private:
	int len;//元素的个数
	int *space;
};

int main(void)
{
	try {
		MyArray array(3);

		for (int i = 0; i < array.getLen(); i++) {
			array[i] = i + 1;
		}

		for (int i = 0; i < array.getLen(); i++) {
			cout << array[i] << endl;
		}
	}
	catch (eSize &e) //eSize &e = eNagtive(len);
	{
		cout << "捕获到异常" << endl;
		e.printErr();//发生多态
	}

#if 0
	catch (eNagtive &e)
	{
		cout << "捕获到eNagive 异常" << endl;
		e.printErr();
	}
	catch (eZero &e) {
		cout << "捕获到eZero 异常" << endl;
		e.printErr();
	}
	catch (eTooBig &e) {
		cout << "捕获到eTooBig 异常" << endl;
		e.printErr();
	}
	catch (eTooSmall &e) {
		cout << "捕获到eTooSmall 异常" << endl;
		e.printErr();
	}
	catch (...)
	{
		cout << "捕获到未知异常" << endl;
	}
#endif

	
	return 0;
}

5. 标准异常库

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include <stdexcept>
#include <string>

using namespace std;

//自定义的MyException 也加入标准的异常库
class MyException :public exception
{
public:
	MyException(char *str) {
		this->m_s = str;
	}
	virtual const char *what() const{
		cout << "MyException 的异常" << endl;
		return this->m_s;
	}
private:
	char *m_s;
};

class Teacher
{
public:
	Teacher(string name, int id)
	{
		this->name = name;
		if (id > 100) {
			string str = "id 超出范围";
			throw out_of_range(str);
		}
		this->id = id;
	}
private:
	int id;
	string name;
};

int main(void)
{
	try
	{
		Teacher t1("zhangsan", 10001);
	}
	catch (exception &e)
	{
		cout << e.what() << endl;
	}
	

	try {
		throw MyException("aaaa");

	}
	catch (exception &e){
		cout << e.what() << endl;
	}
	
	return 0;
}
banjitino
关注
专栏目录
C++多线程--C++异常处理(1)
qls315的博客
04-18 538
异常(exception）是现代C++中的一个特性，使用该特性可以将程序的异常处理和正常程序接耦。一个异常(exception)是一个错误事件，对程序运行时出现的异常情况的响应，例如尝试除以零。异常提供了一种将控制从程序的一个部分转移到另一个部分的方法。C++ exception可由throw表达式,typeid,new表达式,allocation函数,以及任何被指定为抛出异常以指示某些错误情况的标准库函数（例如 std::vector::at、std::string::substr 等）抛出。
C++异常的基本语法与应用
lanyu051的专栏
06-04 906
                                           如果在程序的代码中出现了异常情况——也就是说，通过当前语境无法获得足够的信息以决定应该采取什么样的措施——程序员可以创建一个包含错误信息的对象并把它抛出当前语境，通过这种方式将错误信息发送到更大范围的语境中去。这种方式被称为“抛出一个异常”。    try块    如果在一个函数内部抛出了异常（或
C++ 异常基本语法
weixin_43903378的博客
01-20 149
#define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; class MyException { public: void printError() { cout << "我自己的异常类的错误" << endl; } }; class Person { publi...
C++异常之基本语法
MISAYAONE的博客
05-07 312
异常是一种程序控制机制，与函数机制独立且互补 函数是一种上下衔接的以栈结构展开的程序控制系统，而异常则是一种控制结构，它依据于栈结构，可以同时设置多个异常类型作为捕获条件，从而以类型匹配在栈结构中跳跃回馈 异常的设计目的 栈机制是一种高度节律性的控制机制，面向对象编程却要求对象之间有方向、有目的的控制传动。从一开始，异常的目的就是为了改变程序的控制结构，以适应面向对象程序更好的更高效的...
C++异常（异常的基本语法、栈解旋unwinding、异常接口声明、异常变量的生命周期、异常的多态使用、C++系统标准异常库）
NewsomTech
02-21 733
文章目录
C++学习笔记：异常的基本语法
patkritLee的博客
03-05 480
1）若有异常 则通过throw 操作 创建一个异常对象 并抛出。 2）将可能抛出异常的程序段嵌在try块之中。控制通过正常的顺序执行到达try语句。然后执行try块内的保护段 3）如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执行。程序从try块后跟随的最后一个catch子句后面的语句继续执行下去 4）catch子句按其在try块后出现的顺序被检查。匹配的catch
可重用组件设计：C++异常处理与库的可靠性构建
# 1. C++异常处理基础 异常处理是C++语言中非常重要的一个特性，它提供了错误...本章将从基本的异常处理概念开始，介绍如何在C++中抛出和捕获异常，并讨论异常的分类和它们在程序中的流动方式。通过本章的学习，你将掌
C++异常处理的现代方法：C++11特性打造先进自定义异常
![C++异常处理的现代方法：C++11特性打造先进...C++作为一门高性能的编程语言，其异常处理机制经过多年的演进，特别是从C++11开始，引入了许多现代特性和最佳实践。 异常处理不仅仅是关于捕捉和处理错误，它还包括了如
C语言和C++的重要知识点提炼.zip
最新发布
07-27
- **异常类层次**：标准库提供了std::exception基类及其派生类。 #### 标准模板库（STL） - **容器**：如vector、list、set、map等，用于存储和操作数据。 - **迭代器**：遍历容器的接口。 - **算法**：如排序、...
C++异常处理教学：一步步构建自定义异常框架的教程
在C++中，异常处理能有效分离错误检测和错误处理代码，增强程序的健壮性和可读性。正确使用异常处理可以减少错误传播和资源泄漏的风险，是构建稳定软件系统的基石。 ## C++异常处理的工作原理 C++的
C++异常（十五）
qq_35496811的博客
01-02 157
异常的基本语法 C++异常的处理关键字 try throw catch 可以出现异常的代码 放到 try块 利用throw抛出异常 利用catch捕获异常 catch( 类型) 如果想捕获其他类型 catch(…) 如果捕获到的异常不想处理，而继续向上抛出，利用 throw 异常必须有函数进行处理，如果都不去处理，程序自动调用 terminate函数，中断掉 异常可以是自定义数据类型 栈解旋 从try代码块开始，到throw抛出异常之前，所有栈上的数据都会..
C++异常机制：引用原因与使用原则
C++ 爱好者 make_it_simple888
10-05 1276
为何要用异常 下面首先引用《C++ 程序设计语言》中的段落来描述C++异常的目标（虽然该书描述为何需要异常时已经非常全面，这里只简单列举最为重要的思想）： 1 当程序是由相互分离的模块组成时，库的作者可以检查出运行时错误，但是一般却不知道怎样去处理他们（抛出异常）；用户的代码知道如何处理他们（捕获异常），却又无法检查它们（因为异常发生在库的代码中） 2 将错误的产生和错误的处理分离（解耦）；
C++中异常的处理方法以及使用了哪些关键字
小肥羊快快跑
06-29 1904
C++异常处理使用的关键字有：try、catch、throw。C++中的异常处理机制只能处理由throw捕获的异常，没有捕获的将被忽略。使用try({}catch{}语句来捕获异常，把可能发生异常的代码放在try语句块中，后面跟若干个catch{}负责处理具体的异常类型，这样一组有try块和不少于一个的catch块就构成了一级异常捕获。如果本级没有带死党类型参数的catch块，将不能捕获异常，异常...
面试复习（六）——C/C++关键字：C++中异常的处理方法以及使用了哪些关键字
qq_37764129的博客
08-10 539
C++异常处理使用的关键字有：try、catch、throw。 C++中的异常处理机制只能处理由throw捕获的异常，没有捕获的将被忽略。 使用 try { throw... } catch（...'type） { cout << 'Err_infomation!" << endl; } 语句来捕获异常，把可能发生异常的代码放在try{}...
C++中的异常捕获与处理：Try、Throw、Catch关键字的理解和使用
jack_20的博客
08-23 3435
一、C++异常机制使用了三个新的关键字  （SEH(结构化异常处理)) try    ──标识可能出现的异常代码段 throw  ──抛出一个异常 catch  ──标识处理异常的代码段 二、抛出异常 throw throw必须在 try代码块中.后边跟的值决定抛出异常的类型。 三、捕获异常 catch   出现在try代码块后，后边跟的数据决定捕获的类型 catch(...) /
C++ 纯虚函数的简单实现
Ai_King的博客
01-22 3895
纯虚函数的简单实现 纯虚函数是一个在基类中说明的虚函数，在基类中没有定义，要求任何派生类都定义自己的版本 纯虚函数为个派生类提供一个公共界面（接口的封装和设计、软件的模块功能划分） 含有纯虚函数的类，称为抽象基类，不可实列化。即不能创建对象，存在的意义就是被继承，提供族类的公共接口。 纯虚函数只有声明，没有实现，被“初始化”为0。 如果一个类中声明了纯虚函数，而在派生类中没有对该函数定义，则该...
C++ 和 C 的关系、区别
Ai_King的博客
01-16 2920
1. C++对C语言的加强 1. namespace命名空间 1）当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。若不引入using namespace std,需要这样做。std::cout。 2）c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。 3） C++命名空间的定义： n...
C++ 采用顺序栈的回文判断
Ai_King的博客
11-02 2476
采用顺序栈的回文判断 栈是一种后进先出（LIFO）的线性表，限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 下面给出顺序栈的操作实现 顺序栈 //SqStack.h #pragm...
C++ 抽象类实现计算雇员工资
Ai_King的博客
01-24 2130
抽象类实现计算雇员工资 公司有三类雇员：管理员：Manger（按月薪发工资）；钟点工：HourlyWorker（按工时和时薪发工资）；计件工：PieceWorker（按月总工件数和工件单价发工资） 实现如下： 头文件 employee.h #define _CRT_SECURE_NO_WARNINGS #include "employee.h" employee::employee(const...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

banjitino

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值