C/C++教程

C++异常处理机制(超级详细)

本文主要是介绍C++异常处理机制(超级详细),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目录

0.异常处理机制简介

1.传统错误处理机制(通过函数返回值)

2.异常处理机制语法 

​3.异常接口声明

4.异常类型和声明周期

4.1throw基本类型异常(int 、float、char.....)

4.2throw字符串类型异常

​ 4.3throw类对象类型异常

4.3.1第一种:抛出匿名对象,使用形参接收

​ 4.3.2第二种: 抛出局部变量,使用形参接收

4.3.3第三种:抛出匿名对象,使用引用接收(代码优化 )

5.异常和继承


0.异常处理机制简介

异常无处不在,程序随时可能误入歧途!C++ 提出了新的异常处理机制!

异常是一种程序控制机制,与函数机制互补。

函数是一种以栈结构展开的上下函数衔接的程序控制系统,异常是另一种控制结构,它可以在出现“意外”时中断当前函数,并以某种机制(类型匹配)回馈给隔代的调用者相关的信息。

 图像示例:

当C函数发生错误时,不需要将错误一级级 返回给main,利用异常,直接返回给main:

1.传统错误处理机制(通过函数返回值)

需求: 实现文件的二进制拷贝(当希望文件能够原封不动的拷贝时,要用二进制拷贝)

将要拷贝文件:

代码实现:

// demo 15-14  
#include <stdio.h>
#include <stdlib.h>

#define BUFSIZE 1024

//实现文件的二进制拷贝
int copyfile(const char* dest, const char* src) {
	FILE* fp1 = NULL, * fp2 = NULL;

	//rb 只读方式打开一个二进制文件,只允许读取数据
	fopen_s(&fp1, src, "rb");

	if (fp1 == NULL) {
		return -1;
	}

	//wb 以只写的方式打开或新建一个二进制文件,只允许写数据。
	fopen_s(&fp2, dest, "wb");
	if (fp2 == NULL) {
		return -2;
	}

	char buffer[BUFSIZE];
	int readlen, writelen;

	//如果读到数据,则大于0
	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0) {
		writelen = fwrite(buffer, 1, readlen, fp2);
		if (readlen != writelen) {
			return -3;
		}
	}

	fclose(fp1);
	fclose(fp2);
	return 0;
}

void main() {
	int ret = 0;
    //temp.txt为要拷贝的文件,CopyTemp.txt为拷贝文件
	ret = copyfile("CopyTemp.txt","temp.txt");

	if (ret != 0) {
		switch (ret) {
		case -1:
			printf("打开源文件失败!\n");
			break;
		case -2:
			printf("打开目标文件失败!\n");
			break;
		case -3:
			printf("拷贝文件时失败!\n");
			break;
		default:
			printf("出现未知的情况!\n");
			break;
		}
	}
	system("pause");
}

运行截图:

拷贝文档截图:  

当temp.txt文档不存在时,运行截图:

传统错误返回需要一层层返回错误,而异常处理可以直接到达能够处理异常的地方。

2.异常处理机制语法 

异常发生第一现场,抛出异常
void  function( ){
        //... ...
          throw 表达式;
        //... ...
}
在需要关注异常的地方,捕捉异常
try{
        //程序
        function();        把function至于try中
        //程序
}catch(异常类型声明){        比如只写一个int
        //... 异常处理代码 ...
}catch(异常类型 形参){       形参将会取得抛出的值
        //... 异常处理代码 ...
}catch(...){               抛出的其它异常类型,可以接收任意类型
        //
}
如果没有catch(...),并且没有catch子句与抛出的异常类型匹配,程序会直接中断报错。

修改“文件的二进制拷贝”代码:

// demo 15-16  
#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace std;

#define BUFSIZE 1024

//实现文件的二进制拷贝
int copyfile2(const char* dest, const char* src) {
	FILE* fp1 = NULL, * fp2 = NULL;

	//通过throw操作创建一个异常对象并抛掷
	//rb 只读方式打开一个二进制文件,只允许读取数据
	fopen_s(&fp1, src, "rb");

	if (fp1 == NULL) {
		throw new string("文件不存在");
	}

	//wb 以只写的方式打开或新建一个二进制文件,只允许写数据。
	fopen_s(&fp2, dest, "wb");
	if (fp2 == NULL) {
		throw  0.01f;;
	}

	char buffer[BUFSIZE];
	int readlen, writelen;

	//如果读到数据,则大于0
	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0) {
		writelen = fwrite(buffer, 1, readlen, fp2);
		if (readlen != writelen) {
			throw - 3;
		}
	}

	fclose(fp1);
	fclose(fp2);
	return 0;
}

//这种写法是将copyfile2的抛出异常给copyfile1,copyfile1再给main 
int copyfile1(const char* dest, const char* src) {
	try {
		copyfile2(dest, src);
	}
	catch (float e) {
		//throw ;
		printf("copyfile1 - catch ...\n");

		//提示:处理不了的异常,我们可以在catch的最后一个分支,使用throw语法,继续向调用者throw。就比如再抛给main~
		throw;  //throw后面可以写接收到的e,也可以不写,不写的话会给出“未使用局部变量”的警告
	}

	return 0;
}

void main() {
	int ret = 0;

	//在需要捕捉异常的地方,将可能抛出异常的程序段嵌在try块之中
	//按正常的程序顺序执行到达try语句,然后执行try块{}内的保护段
	//如果在保护段执行期间没有引起异常,那么跟在try块后的catch子句就不执行,程序从try块后跟随
    //的最后一个catch子句后面的语句继续执行下去
	try {//保护段
		printf("开始执行 copyfile1...\n");
		ret = copyfile1("CopyTemp.txt", "temp.txt");
		printf("执行 copyfile1 完毕\n");

		//catch子句按其在try块后出现的顺序被检查,匹配的catch子句将捕获并按catch子句中的代码
        //处理异常(或继续抛掷异常)
	}
	catch (int error) {
		printf("出现异常啦!%d\n", error);
	}
	catch (string* error) {
		printf("捕捉到字符串异常:%s\n", error->c_str());
		delete error;
	}
	catch (float error) {
		printf("出现异常啦!%f\n", error);
	}
	catch (...) {
		printf("catch ...\n");
	}


	//如果没有找到匹配,则缺省功能是调用abort终止程序。

	system("pause");
}

 注意:

1.throw后面可跟任何表达式,除了整数外,指针、字符常量等也可以,如:throw "文档打开失败"

2.通过throw操作创建一个异常对象并抛掷

3.在需要捕捉异常的地方,将可能抛出异常的程序段嵌在try块之中

4.按正常的程序顺序执行到达try语句,然后执行try块{}内的保护段

5.如果在保护段执行期间没有引起异常,那么跟在try块后的catch子句就不执行,程序从try块后跟随的最后一个catch子句后面的语句继续执行下去

6.catch子句按其在try块后出现的顺序被检查,匹配的catch子句将捕获并按catch子句中的代码处理异常(或继续抛掷异常)

7.如果没有找到匹配,则缺省功能是调用abort终止程序。

运行结果:

当temp.txt文档不存在,运行结果:

3.异常接口声明

可以在函数声明中列出可能抛出的所有异常类型,加强程序的可读性。

如:

int copyfile2(char *dest, char *src) throw (float, string *, int)  { }

这样,在阅读代码时便可知这个函数会抛出float、string*和int类型异常,增加可读性

注意:

1.对于异常接口的声明,函数声明中列出可能抛出的所有异常类型

2.如果没有包含异常接口声明,此函数可以抛出任何类型的异常

3.如果函数声明中有列出可能抛出的所有异常类型,那么抛出其它类型的异常讲可能导致程序终止(对于有些编译器可以抛出其它未在声明列表中的异常类型,如老式VC++)

4.如果一个函数不想抛出任何异常,可以使用 throw () 声明(有些编译器会警告throw(),如老式VC++)

4.异常类型和声明周期

4.1throw基本类型异常(int 、float、char.....)

// demo 15-17
#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace std;

#define BUFSIZE 1024


//实现文件的二进制拷贝

//第一种情况,throw 普通类型,和函数返回传值是一样的
int copyfile2(const char *dest, const char *src){
	FILE *fp1 = NULL, *fp2 = NULL;

	//rb 只读方式打开一个二进制文件,只允许读取数据
	fopen_s(&fp1, src, "rb");

	if(fp1 == NULL){
		//int ret = -1;
		char ret = 'a';
		throw ret;
	}

	//wb 以只写的方式打开或新建一个二进制文件,只允许写数据。
	fopen_s(&fp2, dest, "wb");
	if(fp2 == NULL){
		throw -2;
	}

	char buffer[BUFSIZE];
	int readlen, writelen;

	//如果读到数据,则大于0
	while( (readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0 ){
		writelen = fwrite(buffer, 1, readlen, fp2);
		if(readlen != writelen){
			throw -3 ;
		}
	}

	fclose(fp1);
	fclose(fp2);
	return 0;
}

int copyfile1(const char *dest, const char *src){
	return copyfile2(dest, src);
}

void main(){
	int ret = 0;

	
	try{//保护段
		//printf("开始执行 copyfile1...\n");
		ret = copyfile1("CopyTemp.txt", "temp.txt");
		//printf("执行 copyfile1 完毕\n");
			
	}catch(int error){
		printf("出现异常啦!%d\n", error);    //error周期只在此语句中
	}catch(char error){
		printf("出现异常啦!%c\n", error);    //error周期只在此语句中
	}

	system("pause");
}  

对于基本类型异常,使用对应的类型 catch捕捉即可~。

4.2throw字符串类型异常

// demo 15-18
#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace std;

#define BUFSIZE 1024


int copyfile3(const char* dest, const char* src) {
	FILE* fp1 = NULL, * fp2 = NULL;

	//rb 只读方式打开一个二进制文件,只允许读取数据
	fopen_s(&fp1, src, "rb");

	if (fp1 == NULL) {
		const char* error = "大佬,你的源文件打开有问题";
		printf("throw 前,error 的地址:%p\n", error);
//第二种情况,throw 字符串类型,实际抛出的指针,而且,修饰指针的const 也要严格进行类型匹配
		throw error;  //常量字符串类型,返回的是个地址
	}

	//wb 以只写的方式打开或新建一个二进制文件,只允许写数据。
	fopen_s(&fp2, dest, "wb");
	if (fp2 == NULL) {
		throw - 2;
	}

	char buffer[BUFSIZE];
	int readlen, writelen;

	//如果读到数据,则大于0
	while ((readlen = fread(buffer, 1, BUFSIZE, fp1)) > 0) {
		writelen = fwrite(buffer, 1, readlen, fp2);
		if (readlen != writelen) {
			throw - 3;
		}
	}

	fclose(fp1);
	fclose(fp2);
	return 0;
}

int copyfile1(const char* dest, const char* src) {
	return copyfile3(dest, src);
}

void main() {
	int ret = 0;

	try {//保护段
		//printf("开始执行 copyfile1...\n");
		ret = copyfile1("CopyTemp.txt", "temp.txt");
		//printf("执行 copyfile1 完毕\n");

	}
	catch (int error) {
		printf("出现异常啦!%d\n", error);
	}
	catch (char error) {
		printf("出现异常啦!%c\n", error);
	}
	catch (string error) {
		printf("出现异常啦!%s\n", error.c_str());
	}
//严格类型匹配,这里也需要加const
	catch (const char* error) {   //接收常量字符串类型异常地址
		printf("出现异常啦(char *)!%s(地址:%p)\n", error, error);
	}
	catch (...) {
		printf("没捉到具体的异常类型\n");
	}

	system("pause");
}

当抛出的异常类型为地址(指针)时候,catch捕捉类型也要为指针。并且,当抛出异常类型有const修饰时,捕捉类型也要有cosnt修饰。即严格类型匹配。

运行结果:

4.3throw类对象类型异常

当抛出的异常类型为一个类对象时:

#include <stdio.h>
#include <stdlib.h>
#include <string>



class ErrorException {
public:
	ErrorException() {
		id = 0;
		printf("ErrorException  构造!\n");
	}

	~ErrorException() {
		printf("ErrorException  ~析构!(id: %d)\n", id);
	}

	ErrorException(const ErrorException& e) {
		id = 1;
		printf("ErrorException  拷贝构造函数!\n");
	}

	int  id;
};


下面对throw语句进行分类研究: 

4.3.1第一种:抛出匿名对象,使用形参接收

throw ErrorException(); //抛出匿名对象

catch (ErrorException error) {
		printf("出现异常啦!捕捉到 ErrorException 类型 id: %d\n", error.id);
}

运行结果:

4.3.2第二种: 抛出局部变量,使用形参接收

ErrorException error1;
throw error1; 

catch (ErrorException error) {
        error.id=2;   //增加一句error.id=2,便于惯出
		printf("出现异常啦!捕捉到 ErrorException 类型 id: %d\n", error.id);
}

运行结果:

由以上两种结果可得,不管是抛出匿名对象,还是抛出局部变量,程序都会生成一个匿名对象,并且,当catch是普通参数时,程序还要再次调用拷贝函数。 

4.3.3第三种:抛出匿名对象,使用引用接收(代码优化 )

throw ErrorException();   //直接抛出匿名对象
	
catch (ErrorException& error) {   用引用方式来接
		//error.id = 2;
		printf("出现异常啦!捕捉到 ErrorException &类型 id: %d\n", error.id);
}

 运行结果: 

当然也可以 动态分配内存,直接抛出指针,当然也要用指针接收。(严格类型匹配)

throw new ErrorException();

catch (ErrorException* error) {
		printf("出现异常啦!捕捉到 ErrorException *类型 id: %d\n", error->id);
		delete error;
}

运行结果:

 

 注意: 引用和普通的形参传值不能共存!

 

因为引用和普通形参都可以catch捕捉,编译器无法识别被哪个捕捉 。

5.异常和继承

异常也是类,我们可以创建自己的异常类,在异常中可以使用(虚函数,派生,引用传递和数据成员等)。

 案例:设计一个数组类容器 Vector,重载[]操作,数组初始化时,对数组的个数进行有效检查

1.index<0 抛出异常errNegativeException  

2.index = 0 抛出异常 errZeroException

3.index>1000抛出异常errTooBigException 

4.index<10 抛出异常errTooSmallException 

5.errSizeException类是以上类的父类,实现有参数构造、并定义virtual void printError()

Vector容器实现:

#include<iostream>
using namespace std;

class Vector{
public:
	Vector(int length = 128); 
	int getLength();
	int& operator[](int index);
	~Vector();
private:
	int*m_base;
	int m_length;
};

Vector::Vector(int length) {
	m_length = length;
	m_base = new int[length];
}

int Vector::getLength() {
	return m_length;
}

//引用方式返回可以作为左值修改(即存储,Vector va(5);  va[1]=0)
int& Vector::operator[](int index) {
	return m_base[index];
}

Vector::~Vector() {
	if (m_base) {
		delete[] m_base;
		m_length = 0;
	}
}

异常类实现:

class errNegativeException {

};
class errZeroException {

};
class errTooBigException {

};
class errTooSmallException {

};

修改Vector的构造函数:

Vector::Vector(int length) {
	if (length < 0) {
		throw errNegativeException();
	}
	else if (length == 0) {
		throw errZeroException();
	}
	else if (length > 1000) {
		throw errTooBigException();
	}
	else if (length <= 10) {
		throw errTooSmallException();
	}
	m_length = length;
	m_base = new int[length]; 
}

实现主函数接口:

int main() {
	try {
		Vector va(10);
		for (int i = 0; i < va.getLength(); i++) {
			va[i] = i + 3;
		}
	}
	catch (errNegativeException& erro) {
		cout << "errNegativeException" << endl;
	}
	catch (errZeroException& erro) {
		cout << "errZeroException" << endl;
	}
	catch (errTooBigException& erro) {
		cout << "errTooBigException" << endl;
	}
	catch (errTooSmallException& erro) {
		cout << "errTooSmallException" << endl;
	}
	
	system("pause");
	return 0;
}

 运行结果:

 这种抛出异常方法跟直接return一个结果没啥两样,现在通过以前学习的虚函数进行代码优化: 

异常类代码优化:

class errSizeException {
public:
	errSizeException(int size) {
		m_size = size;
	}
	virtual void printErroe() {
		cout << "size:" << m_size << endl;
	}
protected:
	int m_size;
};
//子类errNegativeException 
class errNegativeException :public errSizeException {
public:
	errNegativeException(int size) :errSizeException(size){}
	virtual void printErroe() {
		cout << "errNegativeException size:" << m_size << endl;
	}
};
//子类errZeroException 
class errZeroException :public errSizeException {
public:
	errZeroException(int size) :errSizeException(size) {}
	virtual void printErroe() {
		cout << "errZeroException size:" << m_size << endl;
	}
};
//子类errTooBigException 
class errTooBigException :public errSizeException {
public:
	errTooBigException(int size) :errSizeException(size) {}
	virtual void printErroe() {
		cout << "errTooBigException size:" << m_size << endl;
	}
};
//子类errTooSmallException 
class errTooSmallException :public errSizeException {
public:
	errTooSmallException(int size) :errSizeException(size) {}
	virtual void printErroe() {
		cout << "errTooSmallException size:" << m_size << endl;
	}
};

父类是 errSizeException,子类继承父类。通过虚函数,实现子类代替父类。

主函数接口:

int main() {
	try {
		Vector va(10);
		for (int i = 0; i < va.getLength(); i++) {
			va[i] = i + 3;
		}
	}
	catch (errSizeException& erro) {
		erro.printErroe();
	}

	
	system("pause");
	return 0;
}

运行结果:

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

这篇关于C++异常处理机制(超级详细)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!