7、C++的类型转换

最新推荐文章于 2022-11-12 17:45:39 发布
最新推荐文章于 2022-11-12 17:45:39 发布
阅读量192 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40807247/article/details/81055065
版权 
#include <iostream>
using namespace std;

/*
C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是：
TYPE b = (TYPE)a
C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。
　　static_cast		静态类型转换。如int转换成char
  reinterpreter_cast	重新解释类型
  dynamic_cast		命名上理解是动态类型转换。如子类和父类之间的多态类型转换。
  const_cast，		字面上理解就是去const属性。
  4种类型转换的格式：
  TYPE B = static_cast<TYPE> (a)
  */

void main01()
{
	double pi = 3.1415926;
	//C风格的强制类型转换(Type Cast)很简单
	//TYPE b = (TYPE)a;
	int num1 = (int)pi;

	//C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。
	//static_cast		静态类型转换。如int转换成char
	//reinterpreter_cast	重新解释类型
	//dynamic_cast		命名上理解是动态类型转换。如子类和父类之间的多态类型转换。
	//const_cast，		字面上理解就是去const属性。
	//4种类型转换的格式：
	//TYPE B = static_cast<TYPE> (a)
	int num2 = static_cast<int> (pi);//静态类型转换  编译的时c++编译器会做类型检查
	int num3 = pi; //c语言中 隐式类型转换的地方 均可使用 static_cast<>() 进行类型转换

	//char* ===> int *
	//1）static_cast<>()	静态类型转换，编译的时c++编译器会做类型检查；
	//基本类型能转换但是不能转换指针类型
	char *p1 = "hello...itcast ";
	int *p2 = NULL;
	//p2 = static_cast<int *>(p1);// 使用static_cast, 编译器编译时,会做类型检查 若有错误 提示错误

	//2）若不同类型之间，进行强制类型转换，用reinterpret_cast<>()进行重新解释
	//3）一般性结论：
	//C语言中能隐式类型转换的，在c++中可用 static_cast<>()进行类型转换。因C++编译器在编译检查一般都能通过；
	//C语言中不能隐式类型转换的，在c++中可以用 reinterpret_cast<>() 进行强行类型解释。总结：static_cast<>()和reinterpret_cast<>()基本上把C语言中的强制类型转换给覆盖
	//reinterpret_cast<>()很难保证移植性

	p2 = reinterpret_cast<int *>(p1); //若不同类型之间，进行强制类型转换，用reinterpret_cast<>() 进行重新解释

	cout << "p1:" << p1 << endl; //%s
	cout << "p2" << p2 << endl; //%d
	//总结:通过 reinterpret_cast<>() 和 static_cast<>()把C语言的强制类型转换 都覆盖了..
	cout << "hello..." << endl;
	system("pause");
	return;
}

7.1 类型转换名称和语法

C风格的强制类型转换(TypeCast)很简单，不管什么类型的转换统统是：

TYPE b =(TYPE)a

C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。

　　　　static_cast                静态类型转换。如int转换成char

                   reinterpreter_cast  重新解释类型

　　         dynamic_cast           命名上理解是动态类型转换。如子类和父类之间的多态类型转换。

const_cast，            字面上理解就是去const属性。

4种类型转换的格式：

         TYPE B = static_cast<TYPE>(a)

7.2 类型转换一般性介绍

         1）static_cast<>()  静态类型转换，编译的时c++编译器会做类型检查；

基本类型能转换但是不能转换指针类型

         2）若不同类型之间，进行强制类型转换，用reinterpret_cast<>()进行重新解释

         3）一般性结论：

C语言中能隐式类型转换的，在c++中可用 static_cast<>()进行类型转换。因C++编译器在编译检查一般都能通过；

C语言中不能隐式类型转换的，在c++中可以用 reinterpret_cast<>() 进行强行类型解释。总结：static_cast<>()和reinterpret_cast<>()基本上把C语言中的强制类型转换给覆盖

reinterpret_cast<>()很难保证移植性。

         4）dynamic_cast<>()，动态类型转换，安全的基类和子类之间转换；运行时类型检查

         5）const_cast<>()，去除变量的只读属性        

#include <iostream>
using namespace std;

/*
C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是：
TYPE b = (TYPE)a
C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。
　　static_cast		静态类型转换。如int转换成char
  reinterpreter_cast	重新解释类型
  dynamic_cast		命名上理解是动态类型转换。如子类和父类之间的多态类型转换
  const_cast，		字面上理解就是去const属性。
  4种类型转换的格式：
  TYPE B = static_cast<TYPE> (a)
  */
//dynamic_cast		命名上理解是动态类型转换。如子类和父类之间的多态类型转换
//抽象类
class Animal
{
public:
	virtual void cry() = 0;//纯虚函数
private:

};

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

	void doHome()
	{
		cout << "看家" << endl;
	}

};

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

	void doThing()
	{
		cout << "抓老鼠" << endl;
	}

};
//发生多态条件
//1.要有继承 2.要有虚函数重写 3.要有父类指针指向子类对象
void playObj(Animal *base)
{
	base->cry();
	//能识别子类对象
	// dynamic_cast 运行时类型识别  RIIT
	Dog *pDog = dynamic_cast<Dog *>(base);
	if (pDog != NULL)
	{
		pDog->doHome();//让狗 做自己特有的事情
	}

	Cat *pCat = dynamic_cast<Cat *>(base);
	if (pCat != NULL)
	{
		pCat->doThing();//让猫 做自己特有的事情
	}

}

class Tree
{
public:


private:

};


void main()
{
	Dog d1;
	Cat c1;

	playObj(&d1);
	playObj(&c1);

	Animal *pBase = NULL;

	pBase = &d1;

	pBase = static_cast<Animal *>(&d1); //让C++编译在编译的时候进行 类型检查 

	//强制类型转换 
	pBase = reinterpret_cast<Animal *>(&d1);

	{
		Tree t1;
		//pBase = static_cast<Animal *>(&t1); // C++编译器会做类型检查
		pBase = reinterpret_cast<Animal *>(&t1);  //reinterpret_cast 重新解释 ....强制类转换的味道
	}
	system("pause");
	cout << "hello..." << endl;
	system("pause");
	return;
}

#include <iostream>
using namespace std;

/*
C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是：
TYPE b = (TYPE)a
C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。
　　static_cast		静态类型转换。如int转换成char
  reinterpreter_cast	重新解释类型
  dynamic_cast		命名上理解是动态类型转换。如子类和父类之间的多态类型转换
  const_cast，		字面上理解就是去const属性。
  4种类型转换的格式：
  TYPE B = static_cast<TYPE> (a)
  */

//const char *p 的const修饰 让p指向的内存空间 变成只读属性
//const char * p 和 char const * p 是一个意思，都是p所指向的变量的值不能改变
//char* const p，意思是p所指向的地址是不能改变的
void printBuf(const char *  p)
{
	//p[0] = 'Z';
	char *p1 = NULL;
	//程序员 要清楚的知道 变量:转换之前是什么类型 ,转换之后是什么类型
	//const char * ===> char * //把只读属性 去掉
	p1 = const_cast<char *>(p);

	p1[0] = 'Z';  //通过p1 去修改了内存空间
	cout << p << endl;
}

void main()
{
	char buf[] = "aaaaaaaaafffffddd";

	char *myp = "aaaaaaaaafffffddd";

	//程序员 要确保 p所指向的内存空间 确实能修改 ;如果不能修改会带来灾难性后果
	//printBuf (buf);

	printBuf(myp);

	system("pause");
	cout << "hello..." << endl;
	system("pause");
	return;
}

7.3 典型案例

7.3.1 static_cast用法和reinterpret_cast用法

 

void main01()

{

         double dPi = 3.1415926;

 

         //1静态的类型转换:  在编译的时进行基本类型的转换能替代c风格的类型转换可以进行一部分检查

         int num1 = static_cast<int> (dPi); //c++的新式的类型转换运算符

         int num2 = (int)dPi;                              //c语言的旧式类型转换

         int num3 = dPi;                                                        //隐士类型转换

         cout << "num1:" << num1 << " num2:" << num2 << " num3:" << num3 << endl;

 

 

         char *p1 = "hello wangbaoming " ;

         int *p2 = NULL;

         p2 = (int *)p1;

 

         //2 基本类型能转换但是不能转换指针类型

         //p2 = static_cast<int *> (p1); //“static_cast”: 无法从“char *”转换为“int *”

 

         //3 可以使用  reinterpret_cast 进行重新解释

         p2 = reinterpret_cast<int *> (p1);

         cout << "p1 " << p1 << endl;

         cout << "p2 " << p2 << endl;

 

         //4 一般性的结论：      c语言中能隐式类型转换的在c++中可以用 static_cast<>()进行类型转换  //C++编译器在编译检查一般都能通过

         //c语言中不能隐式类型转换的,在c++中可以用 reinterpret_cast<>() 进行强行类型解释

        

         system("pause");

         return ;

}

 

7.3.2 dynamic_cast用法和reinterpret_cast用法

 

class Animal

{

public:

         virtual void  cry() = 0;

};

 

class Dog : public Animal

{

public:

         virtual void  cry()

         {

                   cout << "wangwang " << endl;

         }

 

         void doSwim() 

         {

                   cout << "我要狗爬" << endl;

         }

};

 

 

class Cat : public Animal

{

public:

         virtual void  cry()

         {

                   cout << "miaomiao " << endl;

         }

         void doTree() 

         {

                   cout << "我要爬树" << endl;

         }

 

};

 

class Book

{

public:

         void printP()

         {

                   cout << price << endl;

         }

 

private:

         int price;

 

};

 

void ObjPlay(Animal *base)

{

         base->cry();

         Dog *pDog = dynamic_cast<Dog *>(base);

         if (pDog != NULL)

         {

                   pDog->cry();

                   pDog->doSwim();

         }

 

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

         if (pCat != NULL)

         {

                   pCat->cry();

                   pCat->doTree();

         }

}

void main02()

{

         Animal *base = NULL;

 

         //1 可以把子类指针赋给父类指针但是反过来是不可以的需要如下转换

         //pdog = base; 

         Dog *pDog = static_cast<Dog *> (base);

 

         //2 把base转换成其他非动物相关的 err

         //Book *book= static_cast<Book *> (base);

 

         //3  reinterpret_cast //可以强制类型转换

         Book *book2= reinterpret_cast<Book *> (base);

 

         //4 dynamic_cast用法

         ObjPlay(new Cat());

 

         system("pause");

}

 

7.3.3const_cast用法

 

//典型用法把形参的只读属性去掉

void Opbuf(const char *p)

{

         cout << p << endl;

         char *p2 = const_cast<char*>(p);

         p2[0] = 'b';

         cout << p << endl;

}

 

void main()

{

         const char *p1 = "11111111111";

 

         char *p2 = "22222222";

 

         char *p3 = const_cast<char *>(p1);

         char buf[100] = "aaaaaaaaaaaa";

 

         Opbuf(buf);

 

         //要保证指针所执行的内存空间能修改才行若不能修改还是会引起程序异常

         //Opbuf("dddddddddddsssssssssssssss");

 

         system("pause");

}

7.4 总结

结论1：程序员要清除的知道: 要转的变量，类型转换前是什么类型，类型转换后是什么类型。转换后有什么后果。

 

结论2：一般情况下，不建议进行类型转换；避免进行类型转换。


lk小强
关注
专栏目录
C++中的四种类型转换
12-26
这篇笔记是根据StackOverflow上面的一个问题整理而成，主要内容是对C/C++当中四种类型转换操作进行举例说明。在之前其实对它们都是有所了解的，而随着自己在进行总结，并敲了一些测试示例代码进行验证之后，对它们的...
指针强制转换问题
ysdaniel的专栏
04-02 2222
（强制）：如果指针所指向的类型带有const  或volatile               限定符，那么移除限定符 的强制转换是不允许的。  （11.5 A cast shall not be performed that removes any const or volatile qualification from the type  addressed by a pointer. ）     任何通过强制转换移除类型限定符的企图都是对类型限定符规则的违背。注意，这里所 指的限定符与任何可以应用在指
强制类型转换(const_cast)
qq_31904421的博客
07-29 1017
来源：https://www.cnblogs.com/Braveliu/p/3616953.html 强制类型转换 const_cast的作用 常量指针 被强转为 非常量指针，且仍然指向原来的对象； 常量引用 被强转为 非常量引用，且仍然指向原来的对象； 常量对象 被强转为 非常量对象，此过程赋值运算符构造了新的对象，新的对象去掉了源对象的部分const属性。 实列代码 代码如下： #include <iostream> using namespace std; const
通过指针修改带const的只读变量
perseverance51博客
08-02 536
使用二级指针修改带const的只读常量 修饰词带const的常量一般是作为可读常量，不容易被改变其赋值，但是使用二级指针可以改修初始值 虽然编译有报警提示，但是还是可以编译通过的。 #include <stdio.h> int main() { const int n = 88, m = 77; int *pal = &n; int **pal2 = &pal; **pal2 = 66; printf("\n%d", n); } ...
C++基础之const系列
iceYao的博客
09-12 400
1. const有什么用途？ 在 c程序中，const的用法主要有定义常量、修饰函数参数、修饰函数返回值等3个用处。 在c++程序中，它还可以修饰函数的定义体，定义类中某个成员为常态函数，即不改变类中的数据成员。 被const修改的东西都要受到强制保护，可以预防意外的变动，能提高程序的健壮性。 2. const与#define相比有什么不同？ 它们都可以用来定义常量，但const比#de
【C++提高】const_cast＜＞() 去除变量的只读属性
Fanjufei的博客
06-15 281
const_cast， 字面上理解就是去const属性。
C++类型转换运算符介绍
疯狂挖掘机的博客
03-30 2211
C++中的新式类型转换介绍
深入理解C++中五种强制类型转换的使用场景
热门推荐
彼方的博客
07-03 1万+
C++中五种强制类型转换解析1、C风格的强制类型转换2、C++风格的强制类型转换2.1、static_cast2.1.1、类实例转换场景使用static_cast2.1.2、没有多态的场景下使用static_cast2.1.3、具有多态的场景下使用static_cast2.2、const_cast2.3、reinterpret_cast2.4、dynamic_cast3、总结 1、C风格的强制类型转换 C风格的强制类型转换容易理解，不管什么类型的转换都可以直接进行转换，使用格式如下： Type b = (T
C++的四种强制类型转换
bit_zyx的博客
11-12 1万+
目录 1、C语言中的类型转换 2、为什么C++需要四种类型转换 3、C++强制类型转换 static_cast reinterpret_cast const_cast dynamic_cast 4、RTTI（了解） 5、常见面试题
c++显式类型转换示例详解
01-20
标准C++包含一个显式的转换语法： static_cast：用于“良性”和“适度...static_cast：用于所有明确定义的转换，包括void*的强制转换、隐式类型转换、类层次的静态定位。 1. 数据类型由小到大的转换，比如int转换为long
C++class_convert.rar_c++类型转换_类型转换
09-20
7. **类型转换的陷阱与最佳实践**：避免不必要的类型转换，尤其是可能导致精度损失或数据溢出的转换。始终确保在转换前后检查数据范围。在可能的情况下，优先使用安全的转换方法，如`std::to_string`和`std::from_...
vc.zip_c++类型转换_数据类型转换
09-14
本资源“vc.zip”包含了一份关于C++类型转换的详细文档“vc.doc”，涵盖了从基本数据类型到复杂类型的转换方法。下面，我们将深入探讨C++中的类型转换及其重要性。 1. **静态类型转换**： - **C-style类型转换**：...
C++类型转换归纳总结
12-31
本文将详细归纳总结一下C++的类型转换。 C++从C发展而来，也继承两种C风格的转换：隐式转换和显式转换。 1.隐式转换 隐式转换是指由编译系统自动进行，不需要人工干预的类型转换，例如： short a = 2000; int b; b...
中国移动：算网一体定义算力网络未来.pdf
最新发布
11-03
中国移动：算网一体定义算力网络未来.pdf
yolo算法-包装盒检测数据集-26张图像带标签-盒子.zip
11-03
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
VB程序实例-使用Access报表.zip
11-03
VB程序实例-使用Access报表.zip
基于MATLAB图像平滑处理系统GUI面板.zip
11-03
强网杯
叠罗汉游戏，安卓java实现，自定义Framlayout,属性动画.zip
11-03
本资源包含一个基于安卓平台的叠罗汉游戏，使用java语言开发。项目中自定义了FrameLayout布局，并应用了属性动画，使得游戏角色能够以生动的方式堆叠起来。代码结构清晰，注释详细，适合初学者学习和实践Android开发技巧。通过这个项目，开发者可以深入了解Android中的布局管理和动画实现，提升编程技能。
各地级市能源消耗量数据集.xlsx
11-03
各地级市能源消耗量数据集.xlsx
C++类型转换完全指南
"C++类型转换是编程过程中不可或缺的一部分，它允许程序员在不同的数据类型之间进行灵活的操作。本文将深入探讨C++中的类型转换，并提供详细的转换方法和示例，帮助程序员避免在处理类型转换时出错。" C++类型转换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值