C++中的强制类型转换

原文转自：https://blog.csdn.net/qq_29996285/article/details/86508684

关于本文主题还有下面这篇博客可以参考：https://www.geek-share.com/detail/2726573606.html

tip——string转char*的库函数方法：

string.c_str();

[/code]

 

类型转换

 

静态转换(static_cast)

 

使用方式：

static_cast<目标类型>(原始对象)

用法：

1. 用于父类和子类之间指针或引用的转换。
2. 用于基本数据类型之间的转换，如把int转换成char，把char转换成int。这种转换的安全性也要开发人员来保证。
3. 没有父子关系的自定义类型不可以转换

补充：

• 进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；

• 进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。

 

基本数据类型转换的例子：

1. void test01(){
2. char a = 'a';
3. double d = static_cast<double>(a);
4. cout << "d = " << d <<endl;
5. }

[/code]

 

继承关系指针互相转换

1. class Base{};
2. class Child :public Base{};
3. class Other{};
4. void test02(){
5. Base * base = NULL;
6. Child * child = NULL;
8. //把base转为 Child*类型 向下 不安全
9. Child * child2 = static_cast<Child*>(base);
11. //把child 转为 Base* 向上 安全
12. Base * base2 = static_cast<Base*>(child);
14. //转other类型 转换无效
15. //Other * other = static_cast<Other*>(base);
16. }

[/code]

 

继承关系引用相互转换

1. class Animal{};
2. class Dog : public Animal{};
3. class Other{};
5. void test03(){
7. Animal ani_ref;
8. Dog dog_ref;
9. //继承关系指针转换
10. Animal& animal01 = ani_ref;
11. Dog& dog01 = dog_ref;
12. //子类指针转成父类指针,安全
13. Animal& animal02 = static_cast<Animal&>(dog01);
14. //父类指针转成子类指针，不安全
15. Dog& dog02 = static_cast<Dog&>(animal01);
16. }

[/code]

 

 

 

动态转换(dynamic_cast)——十分严格

 

使用方式：

dynamic_cast<目标类型>(原始对象)

用法：

1. 基础类型不可以转换
2. dynamic_cast主要用于类层次间的上行转换和下行转换；
3. 在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
4. 在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全；
5. 发生多态，则允许发生向上转换和向下转换。


dynamic_cast 如果发生了多态，那么可以让基类转为派生类 ，向下转换

原因：

创建空间大小的时候，是按照子类的大小进行创建的。

使用样例：

1. class Animal {
2. public:
3. virtual void ShowName() = 0;
4. };
5. class Dog : public Animal{
6. virtual void ShowName(){
7. cout << "I am a dog!" << endl;
8. }
9. };
10. class Other {
11. public:
12. void PrintSomething(){
13. cout << "我是其他类!" << endl;
14. }
15. };
17. //普通类型转换
18. void test01(){
20. //不支持基础数据类型
21. int a = 10;
22. //double a = dynamic_cast<double>(a);
23. }
25. //继承关系指针
26. void test02(){
28. Animal* animal01 = NULL;
29. Dog* dog01 = new Dog;
31. //子类指针转换成父类指针 可以
32. Animal* animal02 = dynamic_cast<Animal*>(dog01);
33. animal02->ShowName();
34. //父类指针转换成子类指针 不可以
35. //Dog* dog02 = dynamic_cast<Dog*>(animal01);
36. }
38. //继承关系引用
39. void test03(){
41. Dog dog_ref;
42. Dog& dog01 = dog_ref;
44. //子类引用转换成父类引用 可以
45. Animal& animal02 = dynamic_cast<Animal&>(dog01);
46. animal02.ShowName();
47. }
49. //无继承关系指针转换
50. void test04(){
52. Animal* animal01 = NULL;
53. Other* other = NULL;
55. //不可以
56. //Animal* animal02 = dynamic_cast<Animal*>(other);
57. }

[/code]

 

 

 

 

常量转换(const_cast)

 

该运算符用来修改类型的const属性。

 

使用方式：

1. 加上const： const int * newP2  =  const_cast<const int *>(p2);
2. 去掉const：            int * newp    =  const_cast<int *>(p);

用法：

1. 常量引用被转换成非常量引用，并且仍然指向原来的对象；
2. 常量指针被转化成非常量指针，并且仍然指向原来的对象；
3. 不能直接对非指针和非引用的变量使用const_cast操作符去直接移除它的const.

1. //常量指针转换成非常量指针
2. void test01(){
4. const int* p = NULL;
5. int* np = const_cast<int*>(p);
7. int* pp = NULL;
8. const int* npp = const_cast<const int*>(pp);
10. const int a = 10; //不能对非指针或非引用进行转换
11. //int b = const_cast<int>(a); }
13. //常量引用转换成非常量引用
14. void test02(){
16. int num = 10;
17. int & refNum = num;
19. const int& refNum2 = const_cast<const int&>(refNum);
21. }

[/code]

 

 

 

重新解释转换(reinterpret_cast)——最不安全，不推荐

 

主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针.

1. void test06(){
2. int a = 10;
3. int * p = reinterpret_cast<int *>(a);
5. Base * base = NULL;
6. Other * other = reinterpret_cast<Other*>(base);
8. //最不安全 ，不推荐
9. }

[/code]