C/C++类型转换和异常处理

最新推荐文章于 2023-11-28 11:19:00 发布
最新推荐文章于 2023-11-28 11:19:00 发布
阅读量957 收藏 2
点赞数
分类专栏： C++
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/Poisx/article/details/74200087
版权

前言

C++中异常的处理

正文

一，C/C++类型转换， 继承的使用

分为四种类型

  1. static_cast
  2. reinterpret_cast
  3. dynamic_cast 使用在继承中
  4. const_cast 改数值的

下面是具体的使用情况

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using namespace std;

class Animal
{
public:
	Animal()
	{}
	~Animal()
	{}
	virtual void cry() = 0;
private:

};

class Dog : public Animal
{
public:
	virtual void cry()
	{
		cout << "dkfdk" << endl;
	}

	void doHome()
	{
		cout << "2222222" << endl;
	}
};

class Cat : public Animal
{
public:
	virtual void cry()
	{
		cout << "333" << endl;
	}

	void doHome()
	{
		cout << "Cat " << endl;
	}
};

void playOBj(Animal *base)
{
	base->cry(); // 有继承， 和多态


	//C++的类型的识别
	//dynamic_cast 运行时类型识别
	Dog *pDog =dynamic_cast<Dog *>(base);

	if (pDog != NULL)
	{
		pDog->doHome(); //dog的工作
	}

	Cat *pCat = dynamic_cast<Cat *>(base);

	if (pCat != NULL)
	{
		pCat->doHome();
	}
}

void printBuf(const char *p)
{
	char *p1 = NULL;
	p1 = const_cast<char *>(p);
	p1[0] = 'Z';

	cout << p << endl;
}

int main(void)
{
	double dp1 = 3.1415926;

	//C类型转换
	int num = (int)dp1;

	//C++静态类型转换  编译的时
	int num2 = static_cast<int>(dp1);

	int num3 = dp1; //C语言中  隐式转换 都可以使用static_cast转换

	//char* ====> int*

	//C++    reinterpret_cast 不同类型的转换

	char *p1 = "hello world !";
	int *p2 = NULL;
	p2 = reinterpret_cast<int *>(p1);

	cout << "p1: " << p1 << endl;
	cout << "p2: " << p2 << endl;

	//总结：通过上面C类型转换的替代了



	//C++
	Cat c;   //向下转型
	playOBj(&c);
	//buf必须是可改的  数组的
	char buf[] = "chenli";
	printBuf(buf);
		
	printf("\n");
	system("pause");
	return 0;
}

二，异常处理的

1, 异常的按照类型补获得

(…) 这个是获取所有的异常


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using namespace std;


void mycatch(int x, int y)
{
	if (y == 0)
	{
		throw y;
	}


	cout << x / y << endl;
}

void myDirde(int x,int y)
{
	mycatch(x, y);
}

int main(void)
{


	try
	{
		mycatch(4, 4);
		mycatch(4, 0);

	}
	catch (int e)
	{
		cout << "0错误" << endl;
	}
	catch (...)
	{
		cout << "程序错误" << endl;
	}

	printf("\n");
	system("pause");
	return 0;
}

三 ，异常接口声明

1，抛出int，char类型的异常

void fcun() throw (int , char){}

2，抛出所有类型异常

void fcun() throw(){}

3, throw “抛出char类型异常”
Created with Raphaël 2.2.0 try 运行 throw catch 结果 yes no

结论1，：如果 接受异常的时候， 使用一个异常变量， copy构造异常变量

结论2,使用引用的话 throw时候的那个对象

结论3：指针可以和引用/元素写在一块 ， 但是引用和元素不能一起使用


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using namespace std;
//重点异常处理
class BadSrcType {};
class BadDecType {};
class BadProcessType 
{

public:
	BadProcessType()
	{
		cout << "1111" << endl;
	}

	BadProcessType()
	{
		cout << "~~~~~~~~~1111";
	}
};



int my_strcpy(char *tc, char *from)
{
	if (from == NULL)
	{
		//异常处理
		throw BadProcessType();
	}
	if (tc == NULL)
	{
		return 2;
	}


	if (*from == 'a')
	{
		return 3;
	}

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

int main(void)
{
	int ret = 0;
	char buf1[] = "dfd";
	char buf2[1024];

	ret = my_strcpy(buf2, buf1);

	if (ret != 0)
	{
		switch (ret)
		{
		case 1:
			cout << "buf1错误" << endl;
			break;
		case 2:
			cout << "buf2 错误" << endl;
			break;
		case 3:
			cout << "未知错误" << endl;
			break;
		default:
			break;
		}
	}

	printf("\n");
	system("pause");
	return 0;
}

四 ,异常在框架的使用案例

内部类的使用

没有优化的代码


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using namespace std;


class MyArray
{
public:
	MyArray(int len);
	int& operator[](int index);
	
	int getLen();
	~MyArray();
	//内部类   异常处理
	class eNegative {};
	class eZero{};
	class eTooBig {};
	class eTooSmall {};
	class eSize {};

private:
	int *m_space;
	int m_len;
};

MyArray::MyArray(int len)
{
	if (len < 0)
	{
		throw eNegative();  // 抛出异常
	}
	else if (len == 0)
	{
		throw eZero();

	}
	else if (len > 1000)
	{
		throw eTooBig();
	}
	else if (len < 3)
	{
		throw eTooSmall();
	}
	this->m_len = len;
	this->m_space = new int[len];
}

int & MyArray::operator[](int index)
{
	return m_space[index];
}

int MyArray::getLen()
{
	return this->m_len;
}

MyArray::~MyArray()
{
	if (this->m_space != NULL)
	{
		delete[] this->m_space;
		this->m_space = NULL;
		this->m_len = 0;
	}
}

int main(void)
{

	try
	{
		MyArray a(5);
		MyArray b(-5);
		int i;
		for (i = 0; i < a.getLen(); i++)
		{
			a[i] = i + 1;
			printf("%d\n", a[i]);
		}
	}
	catch (MyArray::eNegative e)  //类内类
	{
		cout << "eNegative 异常" << endl;

	}
	catch (MyArray::eSize e)  //类内类
	{
		cout << "eSize 异常" << endl;

	}
	catch (MyArray::eTooBig e)  //类内类
	{
		cout << "eTooBig 异常" << endl;

	}
	catch (MyArray::eTooSmall e)  //类内类
	{
		cout << "eTooSmall 异常" << endl;

	}
	catch (MyArray::eZero e)  //类内类
	{
		cout << "eZero 异常" << endl;

	}
	catch (...)
	{
		cout << "..." << endl;
	}
	printf("\n");
	system("pause");
	return 0;
}

优化后

加入多态的继承的使用


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using namespace std;


class MyArray
{
public:
	MyArray(int len);
	int& operator[](int index);
	
	int getLen();
	~MyArray();
	//内部类   异常处理   继承
	class eSize
	{
	public:
		eSize(int size)
		{
			this->m_size = size;

		}
		virtual void printErr()
		{
			cout << "eSize--->size:" << this->m_size << " ";
		}
	protected:
		int m_size;
		 
	};

	class eNegative : public eSize
	{
	
	public: 
		eNegative(int size) :eSize(size)
		{

		}
		virtual void printErr()
		{
			cout << "eNegative--->size:" << this->m_size << " ";
		}
	};
	class eZero : public eSize
	{
	public:
		eZero(int size) :eSize(size)
		{

		}
		virtual void printErr()
		{
			cout << "eZero--->size:" << this->m_size << " ";
		}
	};
	class eTooBig : public eSize
	{
	public:
		eTooBig(int size) :eSize(size)
		{

		}
		virtual void printErr()
		{
			cout << "eTooBig--->size:" << this->m_size << " ";
		}
	};
	class eTooSmall : public eSize
	{
	public:
		eTooSmall(int size) :eSize(size)
		{

		}
		virtual void printErr()
		{
			cout << "eTooSmall-->size:" << this->m_size << " ";
		}
	};
	

private:
	int *m_space;
	int m_len;
};

MyArray::MyArray(int len)
{
	if (len < 0)
	{
		throw eNegative(len);  // 抛出异常
	}
	else if (len == 0)
	{
		throw eZero(len);

	}
	else if (len > 1000)
	{
		throw eTooBig(len);
	}
	else if (len < 3)
	{
		throw eTooSmall(len);
	}
	this->m_len = len;
	this->m_space = new int[len];
}

int & MyArray::operator[](int index)
{
	return m_space[index];
}

int MyArray::getLen()
{
	return this->m_len;
}

MyArray::~MyArray()
{
	if (this->m_space != NULL)
	{
		delete[] this->m_space;
		this->m_space = NULL;
		this->m_len = 0;
	}
}

int main(void)
{

	try
	{
		MyArray a(5);
		MyArray b(-5);
		int i;
		for (i = 0; i < a.getLen(); i++)
		{
			a[i] = i + 1;
			printf("%d\n", a[i]);
		}
	}
	//多态的使用    MyArray::eSize &e
	catch (MyArray::eSize &e)
	{
		cout << "len的大小" << endl;
		e.printErr();
	}
	catch (...)
	{
		cout << "..." << endl;
	}
	printf("\n");
	system("pause");
	return 0;
}

效果图

五, C++中库文件的异常处理


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

//C++异常处理库 
#include <stdexcept>


using namespace std;



class Myexception : public exception
{
public:
	Myexception(const char *p) :exception(p)
	{
		this->p = p;
	}

	virtual const char * what()
	{
		return p;
	}

private:
	const char *p;
};

void setAge(int age)
{
	if (age > 100)
	{
		throw out_of_range("您输入的年龄太大！！！");
	}
}

int main(void)
{

	try
	{
		setAge(111);
	}
	catch (out_of_range e)
	{
		cout << e.what() << endl;
	}



	//2,
	try
	{
		throw Myexception("ckfjdkdkf");
	}
	catch (exception &e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "chnfd throw " << endl;
	}
	printf("\n");
	system("pause");
	return 0;
}

结语

个人博客地址:https://chensongpoixs.github.io

C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
C/C++开发人员要了解的几大著名C/C++开源库
热门推荐
dvlinker的技术专栏
07-24 1万+
本文详细讲述C/C++开发人员需要了解的几大著名C/C++开源库。
C变量类型转换
11-26
C语言变量类型的转换,字符,整形,字符串!
C 类型转换
记一忘三二
06-14 2768
1. 二进制码的含义 计算机内存中的数据以二进制的方式存储，一段二进制序列可能表示整型数据、浮点型数据及指令，这段二进制的具体含义由访问它的指令决定。在没有数据类型转换的前提下，访问二进制数据的指令由编译器产生（编译器根据定义此段二进制数据的类型决定产生何种访问指令）。如用整型（int）声明一段二进制序列（内存），单纯的访问此段二进制序列时编译器就会产生整型指令去访问这段内存，以得到这段二进制所
C类型转换
starinthenightlee的博客
01-27 609
/** 类型转换 1.隐式类型转换(implicit conversion) 当两个操作数类型相同时计算机才能进行二元算数操作 而在二元算术运算中使用不同类型的操作数,编译器会把值域较小的操作数类型转换为另一个操作数类型 隐式类型转换规则 两个操作数类型包含long double,则另一个转换为long double;无且含double,则另一个变为double;又无且含float,另一个变为float 否则,若两个均为整数,把低级别操作数类型变为另一个数类型,无符号整数低到高:char,short,i
C语言类型转换
weixin_51948279的博客
01-21 581
/* convert.c -- 自动类型转换 */ #include <stdio.h> int main(void) { char ch; int i; float fl; fl = i = ch = 'C'; /* 第9行 */ //定义变量值 printf("ch = %c, i = %d, fl = %2.2f\n", ch, i, fl); /* 第10行 */ ch = ch + 1; /* 第11行 */ //24个字母里加一即是向下一位进一 i = fl + 2 * ch;.
C# 捕获C/C++异常的例子
04-11
总结来说，理解和处理C#与C++之间的异常转换是跨语言开发的关键技能。通过适当的设计和实现，我们可以确保C++的异常能够被C#有效地捕获和处理，从而增强程序的健壮性和稳定性。在实际项目中，确保正确处理各种异常...
UDS_ISO-14229-中文.zip_C/C++__C/C++_
08-09
- **数据解析**：UDS服务的数据结构需要正确解析和构建，这涉及位字段操作和数据类型转换。 - **多线程编程**：通常，诊断通信需要同时处理多个并发请求，因此理解并发和同步是必要的。 - **错误处理和异常处理**：...
1216.zip_C/C++__C/C++_
08-09
3. **数组和字符串**：C/C++中的基本数据结构，用于存储和处理序列数据，特别是在解决算法问题时。 4. **结构体与联合体**：用于组合不同类型的数据，创建自定义数据结构。 5. **文件操作**：可能涉及到读写文件，...
C语言中的 类型转换
weixin_44982036的博客
12-30 1463
C语言中的 类型转换 C语言中的类型转换分为隐式类型转换和强制类型转换。 隐式类型转换一般要由低字节转到高字节，否则可能会发生精度降低的情况。 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <math.h> #include <time.h> // 隐式类型转换。 int main(void) { int a = 321; char ch = a;
C语言 类型转换
Mi-ronin的博客
11-13 8243
C语言 类型转换一般是为了解决如下的一些问题： 算术运算中或者逻辑判断表达式中操作室，不匹配的时候。 赋值时，如果左右操作数类型不匹配。 函数传递进去的实参和匹配的形参对应不上。 函数返回的表达式的类型和函数返回类型不匹配。 出现上述问题我们一般会进行相应的类型转换 否则编程在调试的时候会出现警告甚至报错。 C语言中类型转换主要分为两种： 1. 隐式类型转换 2. 显示类型转换 隐式类型转换：编译器自动将左右操作数变成相同类型去计算。 显式类型转换：程序开发者主观上去将类型强制转换。 在类型转换
C语言的类型转换
最新发布
2301_80448965的博客
11-28 691
关于在隐式转换中，若要向着高精度转换，针对char以及short运算时转换成int型，这个过程叫做整型提升。若本身的大小已经有比char，short大的发生转换时叫做算术转换。
C++的类型转换与异常处理
小白杨的博客
08-06 688
一 名称和语法 1 C语言风格：不管什么类型的转换统统是： TYPE b = (TYPE)a； 2 C++风格： 1）static_cast，静态类型转换。如int转换成char 2）reinterpreter_cast，重新解释类型 3） dynamic_cast，命名上理解是动态类型转换。如子类和父类之间的多态类型转换，运行时进行类型识别,把父类转换成子类。 4）const_ca...
C语言中的类型转换
C_AWARD
07-20 471
**在c语言中类型转换分为两类： 强制类型转换； 自动类型转换；**例如：（float）a;//把a转换为浮点型。这种由程序员显式进行的转换称为强制类型转换。除了强制类型转换，在不同数据类型的混合运算中编译器也会隐式地进行数据类型转换，称为自动类型转换。自动类型转换遵循下面的规则： 1. 若参与运算的数据类型不同，则先转换成同一类型，然后进行运算。 2. 转换按数据长度增加的方向进行
标准C 类型转换
07-17 2217
Linux下的整数转换为字符    订阅        在Linux下itoa()这个函数是不能用的，如果要实现这样的功能，只能是自己编写程序来实现。这里我在网上搜索到了一个这样的函数，放在这里供大家参考。 上篇文章说到linux需要itoa函数，下面我就提供一份跨平台的itoa函数。 //return the length of resul
C语言中的数据类型转换
liebecl的博客
01-13 1万+
C语言中的数据类型转换一般分为两种，自动转换和强制转换。 自动转换 自动转换发生在不同数据类型的量混合运算时，由编译系统自动完成。自动转换遵循以下规则： 1.若参与运算量的类型不同，则先转换成同一类型，然后进行运算。 2.转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。 3.所有的浮点运算都是以双精度进行的，即使仅含float单...
C/C++语言进制转换与字符串数字转换函数详解
本文主要介绍了C++/C语言中用于进制转换的函数，包括将字符串转换为不同类型的数值函数，如atof、atoi、atol、strtod、strtol和strtoul，以及一些字符串处理函数如toascii、toupper和tolower。这些函数在处理数字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值