【C++ 语言】类型转换 ( 转换操作符 | const_cast | static_cast | dynamic_cast | reinterpret_cast | 字符串转换 )

文章目录

        • I . const_cast 转换操作符
        • II . static_cast 转换操作符
        • III . dynamic_cast 转换操作符
        • IV . reinterpret_cast 转换操作符
        • V . int 与 char* 转换
        • VI . 类型转换代码示例



I . const_cast 转换操作符


1. 类型转换方式 : ① C 语言中的强制类型转换 , ② 使用转换操作符进行转换 ;

2. const_cast 转换操作符 : 主要用来修改类型的 const 与 volatile 属性 ;

  • ① const 属性作用 : 修饰常量 ;
  • ② volatile 属性作用 : 保证获取一个变量值时 , 重新从内存读取该属性 ;

3. const 属性转换 : 使用 const_cast 转换 const 属性 , 就是将常量类型转为变量类型 , 或者将变量类型转为常量类型 ;

4. const_cast 转换操作符代码示例 :

  • ① 声明一个常量类型 : 声明一个字符串常量 ;
	const char* str_const = "Hello";
  • ② 将常量转为变量 : 格式为 " const_cast < 要转换的目标类型 > ( 常量或变量名称 ) " ;
	char* str = const_cast<char*> (str_const);
  • ③ 完整代码示例 :
	//新式转换 : 
	//转换操作符 : 
	//const_cast : 主要用来修改类型的 const 与 volatile 属性 , 
	//	将不可修改属性 const 转为 可修改的属性
	//	volatile 属性作用 : 保证获取一个变量值时 , 重新从内存读取该属性 ; 

	//将 const char* 类型变量 转为 char* 类型的变量 
	//	可以理解成将常量转为变量 , 这里也可以将变量转为常量
	const char* str_const = "Hello";
	char* str = const_cast<char*> (str_const);

此处将 const char* 类型变量 转为 char* 类型的变量 , 可以理解成将常量转为变量 , 这里也可以将变量转为常量 ;



II . static_cast 转换操作符


1. static_cast 转换操作符 : 有以下作用 ;

  • ① 基础类型转换 : int 与 float 之间进行转换 等 ;
  • ② 指针类型转换 : void* 与 指针类型之间转换 , 如 void* 与 int* 之间转换 ;
  • ③ 子类与父类之间转换 : 子类指针与父类指针之间的转换 , 子类引用与父类引用之间的转换 ;

2. 定义子类与父类 : 其中父类中定义两个函数 , 分别是普通函数和虚函数 , 子类重写这两个函数 ;

//定义父类 , 其中定义共有虚函数
//	虚函数主要是能根据实际类型调用对应方法
class Parent {
public:
	void function() {
		cout << " 父类方法 " << endl;
	}

	virtual void function_viurtual() {
		cout << " 父类虚函数 " << endl;
	}
};

//定义子类 , 共有继承父类 , 
//	将父类的方法和属性都转为 public 
class Child : public Parent {
public :
	void function() {
		cout << " 子类方法 " << endl;
	}

	void function_viurtual() {
		cout << " 子类虚函数 " << endl;
	}
};

子类重写的普通函数与虚函数区别 :

  • 普通函数 : 编译时确定调用子类的方法还是父类的方法 , 根据声明确定调用谁的方法 , 类型声明成子类 , 就调用子类的方法 , 类型声明成父类 , 就调用父类的方法 ;
  • 虚函数 : 运行时确定调用的是子类的方法还是父类的方法 , 运行时调用哪个类的构造方法 , 该对象就是什么类型的 , 其调用对应类型的虚函数或虚函数实现 ;

3. 创建父类指针变量 :

	Parent* parent = new Parent();

4. 将父类指针变量转为子类指针 :

	Child* child = static_cast<Child*>(parent);

5. 分别调用子类和父类的普通函数 : 该函数调用父类还是子类的在编译时确定 ;

  • ① " child->function() " 讨论 : 调用子类 Child 的 function 方法 , 这里的 function 方法时普通方法 , 其声明的是什么类型的变量 , 那么调用的就是哪个类的方法 , 该对象声明的是 Child 对象 , 那么调用的就是 子类的方法 ;

  • ② " parent->function() " 讨论 : 调用父类 Parent 的 function 方法 , 同理 , parent 对象声明为 Parent 类型 , 那么其调用的方法就是父类的方法 ;

  • ③ 代码示例 :

	Parent* parent = new Parent();
	Child* child = static_cast<Child*>(parent);

	//调用子类 Child 的 function 方法
	//	这里的 function 方法时普通方法 , 其声明的是什么类型的变量 , 
	//	那么调用的就是哪个类的方法 , 该对象声明的是 Child 对象 , 
	//	那么调用的就是 子类的方法
	child->function();

	//调用父类 Parent 的 function 方法
	//	同理 , parent 对象声明为 Parent 类型 , 
	//	那么其调用的方法就是父类的方法
	parent->function();
  • ④ 执行结果 :
 子类方法
 父类方法

6. 分别调用子类和父类的虚函数 : 虚函数方法调用子类还是父类的 , 是运行时决定的 , parent 对象使用 new Parent() 进行创建 , 那么无论何时 , 其虚函数都是调用父类的方法 ;

  • ① 代码示例 :
	Parent* parent = new Parent();
	Child* child = static_cast<Child*>(parent);
	
	//这里测试调用子类和父类虚函数方法 , 
	//	与上面的结果不同 , 虚函数方法调用子类还是父类的 , 是运行时决定的 , 
	//	parent 对象使用 new Parent() 进行创建 , 
	//	那么无论何时 , 其虚函数都是调用父类的方法 ; 
	//	即使将其类型转为 Child 类型 , 其实际运行时的类型还是 Parent 类型
	//	调用的虚函数方法始终是父类的方法 ; 
	parent->function_viurtual();
	child->function_viurtual();
  • ② 执行结果 :
 父类虚函数
 父类虚函数

即使将其类型转为 Child 类型 , 其实际运行时的类型还是 Parent 类型 , 调用的虚函数方法始终是父类的方法 ;



III . dynamic_cast 转换操作符


1. dynamic_cast 转换操作符简介 :

  • ① 转换对象 : 该转换只对多态的情况下有效 , 主要是将父类转为子类或子类转成父类 ;
  • ② 作用 : 将父类 指针类型 变量转为子类 指针类型 变量 , 将父类 引用类型 变量转为子类 引用类型 变量 ;
  • ③ 安全性 : 这个动态转换操作是安全的 , 在运行期间对类型转换操作进行安全检查 ;

安全检查内容 1 : 使用 dynamic_cast 转换操作符, 进行父类与子类强制转换时 , 父类必须有一个虚函数 , 否则代码编写的时候就会报错 ( 运行时 dynamic_cast 的操作数必须包含多态类型 ) ; 下图是删除父类的虚函数后 , IDE 开发环境提示出的错误 ;
【C++ 语言】类型转换 ( 转换操作符 | const_cast | static_cast | dynamic_cast | reinterpret_cast | 字符串转换 )_第1张图片

2. 安全检查内容 2 : 类型不符合转换要求 ( 主要是将父类转为子类或子类转成父类 ) , 会转换失败 , 返回 null ;

  • ① 报错行为 : 在父类中定义虚函数 , 在编写代码时没有报错 , 但是在运行时报错 ( 引发了异常 : 读取访问权限冲突 ) ;
  • ② 转换失败 : 这是因为创建的 parent1 对象是 Parent 父类类型的 , 将 Parent 类型动态强转成 Child 类型 , 该操作会转换失败 , 其转换结果是 null ;
  • ② 调用空对象方法 : 此时 child1 指针变量为 null , 调用 null 变量的方法 , 就会抛出上述异常 ;
    【C++ 语言】类型转换 ( 转换操作符 | const_cast | static_cast | dynamic_cast | reinterpret_cast | 字符串转换 )_第2张图片

3. dynamic_cast 转换操作符转换失败示例 :

  • ① 代码示例 :
	//定义父类对象 , 然后将父类对象强转为子类对象
	Parent* parent1 = new Parent();
	Child* child1 = dynamic_cast<Child*>(parent1);

	//根据转换结果打印不同的信息
	if (!child1) {
		//如果 child1 变量是 0 , 说明其转换结果为 null , !child1 结果大于 0 
		cout << " 父类 Parent 指针变量 转为 子类 Child 指针变量 转换失败 " << endl;
	}
	else {
		//转换结果不为 null
		child1->function_viurtual();
	}
  • ② 执行结果 :
 父类 Parent 指针变量 转为 子类 Child 指针变量 转换失败

4. 转换成功的情况 : 转换成功的前提是 , 子类可以转成父类 , 但是父类不能转换成子类 ; 开始时要创建子类对象 , 将其赋值给父类变量 , 之后还可以将该变量再次转为子类对象 , 反之则不可行 , 转换会失败 ;

  • ① 代码示例 :
	//定义子类对象 , 然后将父类对象强转为子类对象
	Parent* parent2 = new Child();
	Child* child2 = dynamic_cast<Child*>(parent2);

	//根据转换结果打印不同的信息
	if (!child2) {
		//如果 child1 变量是 0 , 说明其转换结果为 null , !child1 结果大于 0 
		cout << " 父类 Parent 指针变量 转为 子类 Child 指针变量 转换失败 " << endl;
	}
	else {
		//转换结果不为 null
		child2->function_viurtual();
	}
  • ② 执行结果 :
 子类虚函数


IV . reinterpret_cast 转换操作符


reinterpret_cast 转换操作符作用 : 对指针变量 , 引用变量进行原始的转换 , 即将地址值转成对应的类型 ;

  • ① 代码示例 :
	// 4. reinterpret_cast 转换操作符

	//作用 : 对指针变量 , 引用变量进行原始的转换 ; 

	char* hello = "Hello";

	//获取 hello 字符串地址 , 将其转为 int 类型
	int hello_address = reinterpret_cast<int> (&hello);

	//打印 hello 的地址 , 并以 16 进制形式打印出来
	cout << hex << &hello << endl;
	//打印 hello_address , 并以 16 进制形式打印出来
	cout << hex << hello_address << endl;
  • ② 执行结果 :
000000B6B62FE898
b62fe898


V . int 与 char* 转换


1. char* 转 int : 字符串变量转成整型变量 , 调用 C 函数 atoi(char*) 函数可以将字符串变量转成 int 类型变量 ;
2. char* 转 float : 字符串变量转成浮点型变量 , 调用 atof(char*) 函数可以将字符串变量转成 float 类型变量 ;

3. int 转 char* 变量 :

  • ① 使用 itoa 函数 : 可以将 int 类型变量转为字符串 ;
  • ② 使用 sprintf 函数 : 也可以将 int 类型变量转为字符串 ;

4. int 与 char* 转换代码示例 :

  • ① 代码示例 :
	// 5. char* 与 int 进行转换

	//将字符串转为 int 类型变量
	int int_var = atoi("88888");

	//将字符串转为浮点型变量
	float float_var = atof("88.88f");

	//打印转换结果 : 注意要输出 十进制数
	cout << "int_var : " << dec << int_var << " float_var :  " << float_var << endl;


	//int 类型 转为字符串
	char c[10];
	itoa(888, c, 10);

	//打印转换后的字符串
	cout << c << endl;

	char c1[10];
	sprintf(c1, "%d", 8888);

	//打印转换后的字符串
	cout << c1 << endl;
  • ② 执行结果 :
int_var : 88888 float_var :  88.88
888
8888


VI . 类型转换代码示例


1. 代码示例 :

  • ① 父类子类定义 :
//定义父类 , 其中定义共有虚函数
//	虚函数主要是能根据实际类型调用对应方法
class Parent {
public:
	void function() {
		cout << " 父类方法 " << endl;
	}

	virtual void function_viurtual() {
		cout << " 父类虚函数 " << endl;
	}
};

//定义子类 , 共有继承父类 , 
//	将父类的方法和属性都转为 public 
class Child : public Parent {
public:
	void function() {
		cout << " 子类方法 " << endl;
	}

	void function_viurtual() {
		cout << " 子类虚函数 " << endl;
	}
};
  • ② 函数调用 :
	// IX . 类型转换

	//新式转换 : 
	// 1. const_cast 转换操作符 :
	//const_cast : 主要用来修改类型的 const 与 volatile 属性 , 
	//	将不可修改属性 const 转为 可修改的属性
	//	volatile 属性作用 : 保证获取一个变量值时 , 重新从内存读取该属性 ; 

	//将 const char* 类型变量 转为 char* 类型的变量 
	//	可以理解成将常量转为变量 , 这里也可以将变量转为常量
	const char* str_const = "Hello";
	char* str = const_cast<char*> (str_const);


	// 2. static_cast 转换操作符 

	//定义父类对象 , 然后将父类对象强转为子类对象
	Parent* parent = new Parent();
	Child* child = static_cast<Child*>(parent);

	//调用子类 Child 的 function 方法
	//	这里的 function 方法时普通方法 , 其声明的是什么类型的变量 , 
	//	那么调用的就是哪个类的方法 , 该对象声明的是 Child 对象 , 
	//	那么调用的就是 子类的方法
	child->function();

	//调用父类 Parent 的 function 方法
	//	同理 , parent 对象声明为 Parent 类型 , 
	//	那么其调用的方法就是父类的方法
	parent->function();


	//这里测试调用子类和父类虚函数方法 , 
	//	与上面的结果不同 , 虚函数方法调用子类还是父类的 , 是运行时决定的 , 
	//	parent 对象使用 new Parent() 进行创建 , 
	//	那么无论何时 , 其虚函数都是调用父类的方法 ; 
	//	即使将其类型转为 Child 类型 , 其实际运行时的类型还是 Parent 类型
	//	调用的虚函数方法始终是父类的方法 ; 
	parent->function_viurtual();
	child->function_viurtual();


	// 3. dynamic_cast 转换操作符
	
	//定义父类对象 , 然后将父类对象强转为子类对象
	Parent* parent1 = new Parent();
	Child* child1 = dynamic_cast<Child*>(parent1);

	//根据转换结果打印不同的信息
	if (!child1) {
		//如果 child1 变量是 0 , 说明其转换结果为 null , !child1 结果大于 0 
		cout << " 父类 Parent 指针变量 转为 子类 Child 指针变量 转换失败 " << endl;
	}
	else {
		//转换结果不为 null
		child1->function_viurtual();
	}


	//定义子类对象 , 然后将父类对象强转为子类对象
	Parent* parent2 = new Child();
	Child* child2 = dynamic_cast<Child*>(parent2);

	//根据转换结果打印不同的信息
	if (!child2) {
		//如果 child1 变量是 0 , 说明其转换结果为 null , !child1 结果大于 0 
		cout << " 父类 Parent 指针变量 转为 子类 Child 指针变量 转换失败 " << endl;
	}
	else {
		//转换结果不为 null
		child2->function_viurtual();
	}


	// 4. reinterpret_cast 转换操作符

	//作用 : 对指针变量 , 引用变量进行原始的转换 ; 

	char* hello = "Hello";

	//获取 hello 字符串地址 , 将其转为 int 类型
	int hello_address = reinterpret_cast<int> (&hello);

	//打印 hello 的地址 , 并以 16 进制形式打印出来
	cout << hex << &hello << endl;
	//打印 hello_address , 并以 16 进制形式打印出来
	cout << hex << hello_address << endl;


	// 5. char* 与 int 进行转换

	//将字符串转为 int 类型变量
	int int_var = atoi("88888");

	//将字符串转为浮点型变量
	float float_var = atof("88.88f");

	//打印转换结果 : 注意要输出 十进制数
	cout << "int_var : " << dec << int_var << " float_var :  " << float_var << endl;


	//int 类型 转为字符串
	char c[10];
	itoa(888, c, 10);

	//打印转换后的字符串
	cout << c << endl;

	char c1[10];
	sprintf(c1, "%d", 8888);

	//打印转换后的字符串
	cout << c1 << endl;

2. 执行结果 :

 子类方法
 父类方法
 父类虚函数
 父类虚函数
 父类 Parent 指针变量 转为 子类 Child 指针变量 转换失败
 子类虚函数
00000033C8AFE698
c8afe698
int_var : 88888 float_var :  88.88
888
8888

你可能感兴趣的:(C++,const_cast,static_cast,dynamic_cast,类型转换)