【C++中的类型转换】C语言类型转换与C++类型转换对比,以及4种C++类型转换详解

简介: 【C++中的类型转换】C语言类型转换与C++类型转换对比,以及4种C++类型转换详解

C语言中的类型转换

在C语言中,类型转换有隐式类型转换和强制类型转换,例:

1. 隐式类型转换

可以转换基础类型,指针类型不能隐式类型转换。

1. int a = 97;
2. char c1 = a; //隐式类型转换
3. cout << c1 << endl;  //打印结果为字符 'a'

2. 强制类型转换

1. char p1[] = "abcdefg";
2. int* p2 = (int*)p1; //强制类型转换
3. //int* p2 = p1; //注意:指针类型不能隐式类型转换
4. //错误(活动) E0513 不能将 "char *" 类型的值分配到 "int *" 类型的实体  
5. cout << p2 << endl; //打印结果为字符串地址

C++中的类型转换

在C++中一共提供了4种类型转换,他们分别是

  • static_cast:静态类型转换;
  • reinterpret_cast:重新解释类型;
  • dynamic_cast:动态类型转换;
  • const_cast:const只读类型变量转为非const变量;

这四种类型转换分别应用于各自的应用场景,一般不能混场景使用,否则可能会出现问题,下面分别举例说明,并结合程序详细分析。

1. static_cast

静态类型转换,对应于C语言中的隐式类型转换场景,可以转换基础数据类型,但是不能转换指针类型。该类型转换会在编译时进行类型检查。

1. #include <iostream>
2. using namespace std;
3. 
4. int main()
5. {
6.  //1.转换基础数据类型
7.  int a = 97;
8.  char b = static_cast<char>(a);
9.  cout << b << endl;
10. 
11.   //2.转换指针类型
12.   char str[] = "static_cast";
13.   int* p;
14.   //报错
15.   //p = static_cast<int*>(str);
16.   //错误  C2440 “static_cast” : 无法从“char[12]”转换为“int* ” 
17.   //错误(活动)  E0171 类型转换无效  
18.   //解决方法,强制转换
19.   p = reinterpret_cast<int*>(str); //相当于 p = (int*)str; //强制类型转换
20.   cout << p << endl;
21. 
22.   system("pause");
23.   return 0;
24. }

2. reinterpret_cast

重新解释类型,可用于转换指针,但是不能转换基础数据类型。

1. #include <iostream>
2. using namespace std;
3. 
4. int main()
5. {
6.  //1.转换指针类型
7.  char str[] = "reinterpret_cast";
8.  int* p;
9.  p = reinterpret_cast<int*>(str); //相当于 p = (int*)str; //强制类型转换
10.   cout << p << endl;
11. 
12.   //2.转换基础数据类型
13.   int a = 97;
14.   char b;
15.   //b = reinterpret_cast<char>(a);
16.   //错误  C2440 “reinterpret_cast” : 无法从“int”转换为“char”
17.   //错误(活动)  E0171 类型转换无效  
18. 
19.   system("pause");
20.   return 0;
21. }

3. dynamic_cast

动态类型转换,会进行动态类型检查,应用场景是在多态场景中(子类对象传给父类指针或引用),可以动态检查子类的类型,下面通过程序举例说明:

1. #include <iostream>
2. using namespace std;
3. 
4. class GetArea
5. {
6. public:
7.  virtual double get_area(int a, int b) = 0;
8. };
9. 
10. class Square : public GetArea
11. {
12. public:
13.   virtual double get_area(int a, int b)
14.   {
15.     return a * b;
16.   }
17.   void print_Square()
18.   {
19.     cout << "Is Square" << endl;
20.   }
21. };
22. 
23. class Triangle : public GetArea
24. {
25. public:
26.   virtual double get_area(int a, int b)
27.   {
28.     return a * b * 0.5;
29.   }
30.   void print_Triangle()
31.   {
32.     cout << "Is Triangle" << endl;
33.   }
34. };
35. 
36. void print_area(int a, int b, GetArea* g)
37. {
38.   cout << g->get_area(a, b) << endl;
39. 
40.   //使用 dynamic_cast 进行动态类型检查
41.   if (dynamic_cast<Square*>(g))
42.   {
43.     Square* s_temp = dynamic_cast<Square*>(g);
44.     s_temp->print_Square();
45.   }
46.   else if (dynamic_cast<Triangle*>(g))
47.   {
48.     Triangle* t_temp = dynamic_cast<Triangle*>(g);
49.     t_temp->print_Triangle();
50.   }
51.   else
52.   {
53.     cout << "Is Parent Class" << endl;
54.   }
55. }
56. 
57. int main()
58. {
59.   Square    s;
60.   Triangle  t;
61.   print_area(10, 10, &s);
62.   print_area(10, 10, &t);
63. 
64.   system("pause");
65.   return 0;
66. }

运行程序并查看打印结果

可以看到,通过dynamic_cast自动检查出了传入的子类究竟是矩形类还是三角形类。在上面的基础上添加代码继续分析以下两种情况,一是使用其他转换对子类父类进行转换,二是将类转换为另一种类。具体分析如下:  

1. class GetLen{};
2. 
3. void func_test()
4. {
5.    GetArea* g = NULL;
6.    Square* s = NULL;
7.    g = s; //子类可以传给父类 //类型兼容性原则
8.    //s = g; //不能直接将父类传给子类
9.    //错误  C2440 “ = ”: 无法从“GetArea * ”转换为“Square * ”  
10.     //错误(活动)  E0513 不能将 "GetArea *" 类型的值分配到 "Square *" 类型的实体  
11.     s = dynamic_cast<Square*>(g); //ok
12.     s = static_cast<Square*>(g); //ok
13.     s = reinterpret_cast<Square*>(g); //ok
14. 
15.     GetLen* gl = NULL;; //其他类
16.     //g = dynamic_cast<GetArea*>(gl);
17.     //错误  C2683 “dynamic_cast” : “GetLen”不是多态类型 
18.     //错误(活动)  E0698 运行时 dynamic_cast 的操作数必须包含多态类类型  
19. 
20.     //g = static_cast<GetArea*>(gl); //err
21.     //错误  C2440 “static_cast” : 无法从“GetLen * ”转换为“GetArea* ”  
22.     //错误(活动)  E0171 类型转换无效  
23. 
24.     g = reinterpret_cast<GetArea*>(gl); //ok
25. }

4. const_cast

应用场景是去除只读属性,但有一个前提是内存本身必须是可以修改的。

1. #include <iostream>
2. using namespace std;
3. 
4. void MyPrintStr1(const char* str) //const char* str,对实参设置只读属性,防止误修改
5. {
6.  cout << str << endl;
7. }
8. 
9. void MyPrintStr2(const char* str)
10. {
11.   cout << str << endl;
12.   //str[0] = 'H'; //需要修改实参的场景,但const只读属性,无法修改内存
13.   char* temp = NULL;
14.   temp = const_cast<char*>(str);
15.   temp[0] = 'H';
16. 
17.   cout << str << endl;
18. }
19. 
20. int main()
21. {
22.   //1.在堆栈上分配内存
23.   char str1[] = "how to use const_cast";
24.   MyPrintStr2(str1);
25. 
26.   //2.使用常量区字符串(内存的常量区不可修改)
27.   const char* pStr = "how to use const_cast";
28.   MyPrintStr1(pStr);
29.   //MyPrintStr2(pStr);
30.   //引发了异常: 写入访问权限冲突。temp 是 0xDD9BF4。
31. 
32.   //3.const 类型的字符串
33.   const char str2[] = "how to use const_cast";
34.   MyPrintStr2(str2);
35. 
36.   system("pause");
37.   return 0;
38. }

在测试函数中,我们分了三种情况,可以看出第1、3种情况可以正常通过const_cast去除只读属性,从而达到修改内存数据的目的,而第2种情况却出现了异常。这是因为,第1、3种情况虽然对字符串增加了只读属性,但是内存本身是在栈上分配的,而栈内存本身是可以修改的,所以运行成功。而第二种情况是使用了常量区(全局区)的内存,这段内存是不可修改的,所以即使我们使用const_cast去除了字符串的只读属性,也无法正常运行,这是因为内存本身不可修改的原因。所以,在使用const_cast的时候,首先要知道,const属性的变量是在哪分配的内存,该内存本身是否可以修改。

总结

一般C语言中能进行隐式类型转换的,都可以用 static_cast进行类型转换,指针不能进行隐式类型转换,也不能用static_cast转换;reinterpret_cast强制类型转换,重新解释类型,但不能用于C语言中能进行隐式类型转换的情况,也就是说static_cast和reinterpret_cast各司其职,不能混用;通过static_cast和reinterpret_cast,覆盖了C语言中的类型转换功能。dynamic_cast运行时类型识别,可用于区分子类。const_cast用于去除只读属性。

static_cast与dynamic_cast区别:static_cast是静态类型转换,在编译时进行类型检查;dynamic_cast是动态类型转换,在运行时进行类型检查。


相关文章
|
14小时前
|
存储 关系型数据库 MySQL
C语言/C++雷霆战机代码(终极版)
C语言/C++雷霆战机代码(终极版)
|
10天前
|
存储 关系型数据库 MySQL
C语言/C++雷霆战机代码(终极版)
C语言/C++雷霆战机代码(终极版)
C语言/C++雷霆战机代码(终极版)
|
10天前
|
存储 关系型数据库 MySQL
C语言/C++实战项目雷霆飞机(代码改进)
C语言/C++实战项目雷霆飞机(代码改进)
|
10天前
|
存储 关系型数据库 MySQL
经典C语言/C++项目,雷霆战机
经典C语言/C++项目,雷霆战机
|
22天前
|
存储 C++
C++ 操作重载与类型转换(二)
C++ 操作重载与类型转换(二)
31 2
|
22天前
|
自然语言处理 安全 C++
C++ 操作重载与类型转换(一)
C++ 操作重载与类型转换(一)
45 3
|
22天前
|
存储 C语言 C++
没学C++,如何从C语言丝滑过度到python【python基础万字详解】
没学C++,如何从C语言丝滑过度到python【python基础万字详解】
|
29天前
|
C++
C++——类和对象(初始化列表、匿名对象、static成员、类的隐式类型转换和explicit关键字、内部类)
C++——类和对象(初始化列表、匿名对象、static成员、类的隐式类型转换和explicit关键字、内部类)
|
1月前
|
C++
C++不同类型转换--2
C++不同类型转换--2
|
1月前
|
C++
C++不同类型转换--1
C++不同类型转换--1