首页 > 编程语言 >C++中关于异常的知识点

C++中关于异常的知识点

时间：2024-07-18 15:25:39浏览次数：10  
标签：知识点 cout C++ try catch 异常 throw 函数

C++中关于异常的知识点

异常基本概念

  1. 异常是一种程序控制机制，与函数机制独立和互补

函数是一种以栈结构展开的上下函数衔接的程序控制系统,异常是另一种控制结构,它依附于栈结构,却可以同时设置多个异常类型作为网捕条件,从而以类型匹配在栈机制中跳跃回馈.

  1. 异常设计目的：

栈机制是一种高度节律性控制机制,面向对象编程却要求对象之间有方向、有目的的控制传动,从一开始，异常就是冲着改变程序控制结构，以适应面向对象程序更有效地工作这个主题，而不是仅为了进行错误处理。
异常设计出来之后，却发现在错误处理方面获得了最大的好处。

传统错误处理机制：通过函数返回值来处理错误。

异常处理的基本思想

在这里插入图片描述

  1. C++的异常处理机制使得异常的引发和异常的处理不必在同一个函数中，这样底层的函数可以着重解决具体问题，而不必过多的考虑异常的处理。上层调用者可以再适当的位置设计对不同类型异常的处理。
  2. 异常是专门针对抽象编程中的一系列错误处理的，C++中不能借助函数机制，因为栈结构的本质是先进后出，依次访问，无法进行跳跃，但错误处理的特征却是遇到错误信息就想要转到若干级之上进行重新尝试，如图
    在这里插入图片描述
  3. 异常超脱于函数机制，决定了其对函数的跨越式回跳。
  4. 异常跨越函数

C++异常处理的实现

异常基本语法

在这里插入图片描述

  1. 若有异常则通过throw操作创建一个异常对象并抛掷。
  2. 将可能抛出异常的程序段嵌在try块之中。控制通过正常的顺序执行到达try语句，然后执行try块内的保护段。
  3. 如果在保护段执行期间没有引起异常，那么跟在try块后的catch子句就不执行。程序从try块后跟随的最后一个catch子句后面的语句继续执行下去。
  4. catch子句按其在try块后出现的顺序被检查。匹配的catch子句将捕获并处理异常（或继续抛掷异常）。
  5. 如果匹配的处理器未找到，则运行函数terminate将被自动调用，其缺省功能是调用abort终止程序。
  6. 处理不了的异常，可以在catch的最后一个分支，使用throw语法，向上扔。

案例1：被零整除案例

int divide(int x, int y )
{
	if (y ==0)
	{
		throw x;
	}
	return x/y;
}

void main41()
{
	try
	{
		cout << "8/2 = " << divide(8, 2) << endl;
		cout << "10/0 =" << divide(10, 0) << endl;
	}
	catch (int e)
	{
		cout << "e" << " is divided by zero!" << endl;
	}
	catch(...)
	{
		cout << "未知异常" << endl;
	}
	
	cout << "ok" << endl;
 	system("pause");
	return ;
}

案例2：

class A{};
void f(){
  if(...) throw A;
}
void g(){
  try{
    f();
  }catch(B){
    cout<<“exception B\n”;
  }
}
int main(){
  g();
}

throw A将穿透函数f，g和main，抵达系统的最后一道防线——激发terminate函数（停止进程内所有线程的执行）。
该函数调用引起运行终止的abort函数（调用abort()时，不进行任何清理工作，直接终止程序）。
最后一道防线的函数可以由程序员设置．从而规定其终止前的行为。

修改系统默认行为：

  1. 可以通过set_terminate函数修改捕捉不住异常的默认处理器，从而使得发生捉不住异常时，被自定义函数处理：
  2. void myTerminate(){cout<<“HereIsMyTerminate\n”;}
  3. set_terminate(myTerminate);
  4. set_terminate函数在头文件exception中声明，参数为函数指针void(*)().

案例3：
构造函数没有返回类型，无法通过返回值来报告运行状态，所以只通过一种非函数机制的途径，即异常机制，来解决构造函数的出错问题。

异常机制与函数机制互不干涉，但捕捉的方式是基于类型匹配。捕捉相当于函数返回类型的匹配，而不是函数参数的匹配，所以捕捉不用考虑一个抛掷中的多种数据类型匹配问题
比如：

class A{};
class B{};

int main()
{
	try
	{
		int 	j = 0;    
		double 	d = 2.3;    
		char 	str[20] = "Hello";
		cout<<"Please input a exception number: ";
		int a; 
		cin>>a;
		switch(a)
		{
		case  1: 
			throw d;      
		case  2: 
			throw j;      
		case  3: 
			throw str;
		case  4: 
			throw A();      
		case  5: 
			throw B();
		default: 
			cout<<"No throws here.\n";    
		}
	}
	catch(int)
	{
		cout<<"int exception.\n";
	}
	catch(double)
	{
		cout<<"double exception.\n";
	}
	catch(char*)
	{
		cout<<"char* exception.\n";
	}
	catch(A)
	{
		cout<<"class A exception.\n";
	}
	catch(B)
	{
		cout<<"class B exception.\n";
	}
	cout<<"That's ok.\n";
	system("pause");
}

catch代码块必须出现在try后，并且在try块后可以出现多个catch代码块，以捕捉各种不同类型的抛掷。
异常机制是基于这样的原理：程序运行实质上是数据实体在做一些操作，因此发生异常现象的地方，一定是某个实体出了差错，该实体所对应的数据类型便作为抛掷和捕捉的依据。

异常捕捉严格按照类型匹配

异常捕捉的类型匹配之苛刻程度可以和模板的类型匹配媲美,它不允许相容类型的隐式转换,比如,抛掷char类型用int型就捕捉不到．例如下列代码不会输出“int
exception.”，从而也不会输出“That’s ok.” 因为出现异常后提示退出

int main(){
  try{
    throw ‘H’;
  }catch(int){
    cout<<"int exception.\n";
  }
  cout<<"That's ok.\n";
}

栈解旋(unwinding)

异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反。这一过程称为栈的解旋(unwinding)。

class MyException {};

class Test
{
public:
	Test(int a=0, int b=0)
	{
		this->a = a;
		this->b = b;
		cout << "Test 构造函数执行" << "a:" << a << " b: " << b << endl;
	}
	void printT()
	{
		cout << "a:" << a << " b: " << b << endl;
	}
	~Test()
	{
		cout << "Test 析构函数执行" << "a:" << a << " b: " << b << endl;
	}
private:
	int a;
	int b;
};

void myFunc() throw (MyException)
{
	Test t1;
	Test t2;

	cout << "定义了两个栈变量,异常抛出后测试栈变量的如何被析构" << endl;

	throw MyException();
}

void main()
{
	//异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象，
	//都会被自动析构。析构的顺序与构造的顺序相反。
	//这一过程称为栈的解旋(unwinding)
	try  
	{
		myFunc();
	}
	//catch(MyException &e) //这里不能访问异常对象
	catch(MyException ) //这里不能访问异常对象
	{
		cout << "接收到MyException类型异常" << endl;
	}
	catch(...)
	{
		cout << "未知类型异常" << endl;
	}
	
	system("pause");
	return ;
}

异常接口声明

  1. 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw(A,B,C);这个函数func能够且只能抛出类型A,B,C及其子类型的异常。
  2. 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如:void func()
  3. 一个不抛任何类型异常的函数可声明为:void func() throw()
  4. 如果一个函数抛出了它的异常接口声明所不允许抛出的异常,unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序。
//可抛出所有类型异常
void TestFunction01(){
	throw 10;
}

//只能抛出int char char*类型异常
void TestFunction02() throw(int,char,char*){
	string exception = "error!";
	throw exception;
}

//不能抛出任何类型异常
void TestFunction03() throw(){
	throw 10;
}

int main(){

	try{
		//TestFunction01();
		//TestFunction02();
		//TestFunction03();
	}
	catch (...){
		cout << "捕获异常!" << endl;
	}
	
	system("pause");
	return EXIT_SUCCESS;
}

异常变量生命周期

  1. throw的异常是有类型的，可以是数字、字符串、类对象。
  2. throw的异常是有类型的，catch需严格匹配异常类型。
class MyException
{
public:
	MyException(){
		cout << "异常变量构造" << endl;
	};
	MyException(const MyException & e)
	{
		cout << "拷贝构造" << endl;
	}
	~MyException()
	{
		cout << "异常变量析构" << endl;
	}
};
void DoWork()
{
	throw new MyException(); //test1 2都用 throw MyExecption();
}

void test01()
{
	try
	{
		DoWork();
	}
	catch (MyException e)
	{
		cout << "捕获 异常" << endl;
	}
}
void test02()
{
	try
	{
		DoWork();
	}
	catch (MyException &e)
	{
		cout << "捕获 异常" << endl;
	}
}

void test03()
{
	try
	{
		DoWork();
	}
	catch (MyException *e)
	{
		cout << "捕获 异常" << endl;
		delete e;
	}
}

异常的多态使用

//异常基类
class BaseException{
public:
	virtual void printError(){};
};

//空指针异常
class NullPointerException : public BaseException{
public:
	virtual void printError(){
		cout << "空指针异常!" << endl;
	}
};
//越界异常
class OutOfRangeException : public BaseException{
public:
	virtual void printError(){
		cout << "越界异常!" << endl;
	}
};

void doWork(){

	throw NullPointerException();
}

void test()
{
	try{
		doWork();
	}
	catch (BaseException& ex){
		ex.printError();
	}
}

C++标准异常库

标准库介绍

标准库中也提供了很多的异常类，它们是通过类继承组织起来的。异常类继承层级结构图如下：
在这里插入图片描述
标准异常类的成员：
① 在上述继承体系中，每个类都有提供了构造函数、复制构造函数、和赋值操作符重载。
② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述
③ 所有的异常类都有一个what()方法，返回const char* 类型（C风格字符串）的值，描述异常信息。

编写自己的异常类

① 标准库中的异常是有限的；

② 在自己的异常类中，可以添加自己的信息。（标准库中的异常类值允许设置一个用来描述异常的字符串）。

如何编写自己的异常类？

① 建议自己的异常类要继承标准异常类。因为C++中可以抛出任何类型的异常，所以我们的异常类可以不继承自标准异常，但是这样可能会导致程序混乱，尤其是当我们多人协同开发时。

② 当继承标准异常类时，应该重载父类的what函数和虚析构函数。

③ 因为栈展开的过程中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供自己的复制构造函数。

//自定义异常类
class MyOutOfRange:public exception
{
public:
	MyOutOfRange(const string  errorInfo)
	{
		this->m_Error = errorInfo;
	}

	MyOutOfRange(const char * errorInfo)
	{
		this->m_Error = string( errorInfo);
	}

	virtual  ~MyOutOfRange()
	{
	
	}
	virtual const char *  what() const
	{
		return this->m_Error.c_str() ;
	}

	string m_Error;

};

class Person
{
public:
	Person(int age)
	{
		if (age <= 0 || age > 150)
		{
			//抛出异常 越界
			//cout << "越界" << endl;
			//throw  out_of_range("年龄必须在0~150之间");

			//throw length_error("长度异常");
			throw MyOutOfRange(("我的异常 年龄必须在0~150之间"));
		}
		else
		{
			this->m_Age = age;
		}
		
	}

	int m_Age;
};


void test01()
{
	try
	{
		Person p(151);
	}
	catch ( out_of_range & e )
	{
		cout << e.what() << endl;
	}
	catch (length_error & e)
	{
		cout << e.what() << endl;
	}
	catch (MyOutOfRange e)
	{
		cout << e.what() << endl;
	}
}

标签：知识点,cout,C++,try,catch,异常,throw,函数
From： https://blog.csdn.net/2401_83614570/article/details/140406170

相关文章

  • Java中的异常处理与容错设计最佳实践
    Java中的异常处理与容错设计最佳实践大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java编程中，异常处理是一个非常重要的环节。良好的异常处理和容错设计可以提升系统的健壮性和可维护性。本文将介绍Java中的异常处理与容错设计最佳实践，包括异常的分类......
  • C++ 返回数组指针简单测试
    C++返回数组指针简单测试：#include<iostream>staticconstsize_tARR_SIZE=10;staticintarr[ARR_SIZE];//更新数组#defineUPDATE_ARR_DATA(i)for(size_tj=0;j<ARR_SIZE;++j)\{\a......
  • c++中push_back和emplace_back
     push_back 和 emplace_back 都是用于在容器（如 std::vector, std::deque 等）的末尾添加元素的方法，但它们在实现细节和性能上有显著区别：构造方式:push_back 首先在容器外部构造一个完整的对象，然后将这个对象移动或拷贝到容器的末尾。emplace_back 直接在容器管理的......
  • 如何让Python爬虫在遇到异常时继续运行
    概述在数据收集和数据挖掘中，爬虫技术是一项关键技能。然而，爬虫在运行过程中不可避免地会遇到各种异常情况，如网络超时、目标网站变化、数据格式不一致等。如果不加以处理，这些异常可能会导致爬虫程序中断，影响数据采集效率和完整性。本文将概述如何使用Python编写一个健壮的爬......
  • C#调用C++库，进行串口通信
    1、添加C++接口实现，将dll放置在运行路径下。dll文件下载：https://files.cnblogs.com/files/ZM191018/SerialPortLib.7z?t=1721271982&download=true[DllImport("SerialPortLib.dll",CharSet=CharSet.Unicode,CallingConvention=CallingConvention.StdCall)]......
  • 高质量C/C++编程指南总结（十）—— const 用法
    const的用法1）用const修饰函数的输入参数如果输入的参数采用“指针传递”，那么加const修饰可以防止意外地改动该指针，起到保护作用。如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。对于非内部数据类......
  • Java语言，MySQL数据库；基于Node+Vue的健康信息管理系统的设计与实现32355（免费领源码）计算
    Node.js健康信息管理系统的设计摘要在如今IT技术快速发展和Internet广泛应用的时代，电子和网络技术给人们生活带来了便利，同时也会直接或间接损害人们的健康。所以，本次的毕业设计创作的意义就是通过信息化的统一管理，给用户录入和查看健康信息提供了方便。本设计主要实现集人......
  • C++日志头文件[gpt]
    只要include头文件就能使用，单例模式#ifndefMONITORING_LOGGER_H#defineMONITORING_LOGGER_H#include<iostream>#include<string>#include<sstream>#include<mutex>#include<cstdarg>#include<iomanip>//Setloglevel#defineMO......
  • 高质量C/C++编程指南总结（八）—— C++高级特性
    1.成员函数重载特征相同的范围（在同一个类中）函数名称相同参数不同virtual关键字可有可无2.覆盖的特征覆盖是指派生类函数覆盖基类函数，所以范围不同（分别位于派生类和基类）函数名称相同参数相同基类函数必须有virtual关键字如下示例中，函数Base::f（int）与Base::f（flo......
  • C++ 数组作为函数参数示例
    C++数组作为函数参数示例：#include<iostream>staticvoidprint(constint*beg,constint*end){while(beg!=end){std::cout<<*beg++<<std::endl;}}staticvoidprint(constint*arr,constsize_tsize){for(size......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99