IT评测·应用市场-qidao123.com技术社区

标题: 【C++ 第二十二章】C++的类型转换 [打印本页]
作者: 惊雷无声    时间: 2024-9-12 23:17
标题: 【C++ 第二十二章】C++的类型转换




1.C语言中的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形到场实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中统共有两种形式的类型转换：隐式类型转换和显式类型转换。
  2. void Test()
  3. {
  4.         int i = 1;
  5.         // 隐式类型转换
  6.         double d = i;
  7.         printf("%d, %.2f\n", i, d);
  8.         int* p = &i;
  9.         // 显示的强制类型转换
  10.         int address = (int)p;
  11.         printf("%x, %d\n", p, address);
  12. }
复制代码



C风格的转换格式很简单，但是有不少缺点的：



2.C++逼迫类型转换

标准C++为了增强类型转换的可视性，引入了四种定名的逼迫类型转换操作符：
static_cast、reinterpret_cast、const_cast、dynamic_cast
先列个提要：
（1）内置类型 = 内置类型：隐式类型转换 或 逼迫类型转换 使用 static_cast、reinterpret_cast
（2）内置类型 = 自界说类型：自界说类型内部重载 operator int() 这样的函数（int x = A.operator int();）
（3）自界说类型 = 内置类型：隐式类型转换（string s = “hehe”;）
（4）自界说类型 = 自界说类型：自界说类型内部重载构造函数

2.1 static_cast 与 reinterpret_cast

  1. // static_cast：这个就代表 隐式类型转换，目的是为了规范化，提示别人这里存在隐式类型转换
  2. int a1 = 10;
  3. double b1 = static_cast<double>(a1);
  5. // reinterpret_cast：reinterpret 表示重新解释，这里就是 强制类型转换
  6. int a2 = 10;
  7. double* p1 = reinterpret_cast<double*>(a2);
复制代码

2.2 const_cast

这段代码有点诡异！！
  1. int main() {
  2.         // const_cast：将常变量去除常性，使其可以修改
  3.         const int a3 = 5;
  4.         int* p2 = const_cast<int*>(&a3);
  5.         *p2 = 6;
  7.         cout << a3 << '\n';
  8.         cout << *p2 << '\n';
  9.         return 0;
  10. }
复制代码




我们明明通过逼迫类型转换，通过 a3 的地址修改了 a3，但是打印效果：a3 居然还是 5？？？
甚至我们通过调试窗口查看 a3 的变化：a3 也是变成了 6
为什么打印出来还是 5 ？
这里实在是编译器的优化手段，将 a3 界说成常量后，编译器将 a3 这个符号直接类似界说宏，直接宏替换成 5，之后程序碰到 a3 的地方会直接替换成 5


解决办法：加上 volatile 关键字，意思是去掉编译器这个优化
  1. volatile const int a3 = 5;
复制代码

小结：因此说 const_cast 的修改是有一定风险的，涉及这种直接去掉常性，修改常变量的，一定要加上 volatile


2.3 dynamic_cast

dynamic_cast 用于将一个父类对象的指针/引用 转换 子类对象的指针或引用(动态转换)
注意是父子类指针或引用之间的转换，不是父子类对象之间的转换
（子类对象可以直接赋值给父类对象，父类对象不可以赋值给子类对象）


看表明理解：
  1. class A
  2. {
  3. public:
  4.         //virtual void func() {};
  5.         int _a = 2;
  6. };
  8. class B : public A
  9. {
  10. public:
  11.         int _b = 3;
  12. };
  14. void Func(A* pa) {
  15.         // 父类指针 pa 指向 子类对象，下面将  子类指针转换成子类指针，没问题
  16.         // 父类指针 pa 指向 父类对象，下面将  父类指针转换成子类指针，则该指针就会存在越界访问的风险
  17.         //（比如你父类对象大小为5字节，子类对象大小为5字节， 而你将你父类指针强转为子类指针，那么就是本来只有5字节空间，你却可以访问10字节空间，这显然是有越界访问的风险的）
  19.         B* pb = reinterpret_cast<B*>(pa);
  21.         // 越界读数据：可能不报错
  22.         cout << "pa：" << pa->_a << '\n';
  23.         cout << "pb：" << pb->_b << '\n';
  24.         // 越界写数据：直接报错
  25.         pa->_a++;
  26.         pb->_b++;
  27.         cout << "pa：" << pa->_a << '\n';
  28.         cout << "pb：" << pb->_b << '\n';
  29. }
  31. int main() {
  32.         A a;
  33.         B b;
  34.         Func(&a);
  35.         Func(&b);
  36.         return 0;
  37. }
复制代码



由上面代码演示可知：父类指针转换为子类指针存在风险
因此需要使用 dynamic_cast 查抄是否可以转换成功，若转换失败会返回空指针，以此来防范这个风险



dynamic_cast 的使用要求：
1.dynamic_cast 只能用于父类含有虚函数的类：因此象征性的给父类A加一个 虚函数
2.dynamic_cast 会先查抄是否能转换成功，能成功则转换，不能则返回 0。



  1. class A
  2. {
  3. public:
  4.         virtual void func() {};
  5.         int _a = 2;
  6. };
  8. class B : public A
  9. {
  10. public:
  11.         int _b = 3;
  12. };
  14. void Func(A* pa) {
  15.         // 父类指针 pa 指向 子类对象，下面将  子类指针转换成子类指针，没问题
  16.         // 父类指针 pa 指向 父类对象，下面将  父类指针转换成子类指针，则该指针就会存在越界访问的风险
  17.         //（比如你父类对象大小为5字节，子类对象大小为5字节， 而你将你父类指针强转为子类指针，那么就是本来只有5字节空间，你却可以访问10字节空间，这显然是有越界访问的风险的）
  19.         B* pb = dynamic_cast<B*>(pa);
  21.         if (pb) {
  22.                 // 越界读数据：可能不报错
  23.                 cout << "pa：" << pa->_a << '\n';
  24.                 cout << "pb：" << pb->_b << '\n';
  25.                 // 越界写数据：直接报错
  26.                 pa->_a++;
  27.                 pb->_b++;
  28.                 cout << "pa：" << pa->_a << '\n';
  29.                 cout << "pb：" << pb->_b << '\n';
  30.         }
  31.         else cout << "转换失败" << '\n';
  32. }
  34. int main() {
  35.         A a;
  36.         B b;
  37.         cout << "Func(&a)：";
  38.         Func(&a);
  40.         cout << '\n';
  42.         cout << "Func(&b)：\n";
  43.         Func(&b);
  44.         return 0;
  45. }
复制代码



为什么只能用于父类含有虚函数的类？
由于 dynamic_cast 本质上是通过虚表来实现的，类似于判断虚表中的 父子类是否有某种标志，判断是否可以转换成功
（这里不重要，可以本身了解）



2.4 内置类型 = 自界说类型

这个实在是在 自界说类型中添加一个函数，若该自界说类型要转换为 int 类型的数据，则添加 operator int() 函数；同理，若要转换为 double类型，则添加 operator double()
  1. class A
  2. {
  3. public:
  4.         operator int() {
  5.                 // 里面写什么东西都是自定义的了
  6.                 return _a;
  7.         }
  8. private:
  9.         int _a = 10;
  10. };
  12. int main() {
  13.         A a;
  14.         int x = a;
  15.         cout << x << '\n';
  16.         return 0;
  17. }
复制代码

智能指针中也有使用相关重载函数：



2.5 自界说类型 = 内置类型

这个实在平时都有运用，本质上是隐式类型转换
  1. int main() {
  2.         // "hehehe" 是内置类型 char*，编译器底层将其隐式类型转换为 string 类型
  3.         string s = "hehehe";
  4.         return 0;
  5. }
复制代码



2.6 自界说类型 = 自界说类型

前面解说过，两个类型若要进行类型转换操作，则这两个对象必须具有某种特定接洽
但是通常，两个不同的自界说类型都不会有直接的接洽，因此不能容易的类型转换
需要在 左边的自界说类型 中重载参数为 右边自界说类型 的构造函数：
将自界说类型 A 的变量 拷贝给 自界说类型 B 的变量，需要在 类B 中重载新的构造函数:


  1. B(const A& a)
  2.         :_b(a.get())
  3. {}
复制代码

  1. #include"List.h"
  2. #include<list>
  3. // 和自定义类型相关的类型转换基本都和构造函数有关
  5. // 类型转换的两者一定要有一定的关联
  6. // 自定义类型的转换，一定要产生某种关联
  9. class A
  10. {
  11. public:
  12.         A(const int& x = 0, const int& y = 0)
  13.                 :_a1(x)
  14.                 , _a2(y)
  15.         {}
  17.          explicit ：该关键字是禁止掉 隐式类型转换，但是可以显式类型转换
  18.         //explicit operator int() {
  19.         //        return _a1 + _a2;
  20.         //}
  22.         int get() const {
  23.                 return _a1 + _a2;
  24.         }
  26.          这里写这个函数会报一堆奇怪的错：因为类 B 声明在下面，程序运行时向上查询就找不到类 B，导致报错
  27.         //A(const B& b)
  28.         //        :_a1(b.get())
  29.         //{}
  30. private:
  31.         int _a1;
  32.         int _a2;
  33. };
  35. class B
  36. {
  37. public:
  38.         B(const int& x = 0)
  39.                 :_b(x)
  40.         {}
  41.         // 这里加上 const，为什么 a.get() 不能使用（A类中的 get 没有 const 修饰）：这就设计到 const 权限放大的问题
  42.         //先理清一个概念：我们平时通过一个对象或对象指针去调用成员函数，因为成员函数隐含着第一个参数 this 指针，因此本质上都要传递一个this指针过去，
  43.         // 涉及到 this 指针的传参，就要注意 this 指针的权限问题（是否被 const 修饰）
  44.         // B(const A& a)  这里对象 a 的this指针类型：const A*，而 get 函数this指针类型：A* 当然会权限放大！！！
  45.         B(const A& a)
  46.                 :_b(a.get())
  47.         {}
  50.         // 这个也能匹配给 b1 = a1，但是会优先选择上面的构造 B(const A& a)  
  51.         operator int() {
  52.                 cout << "operator int()" << '\n';
  53.                 return _b;
  54.         }
  56. private:
  57.         int _b;
  58. };
  61. int main() {
  62.         B b1 = 10;
  63.         A a1 = 20;
  64.         b1 = a1;
  66.         return 0;
  67. }
复制代码

本质上，实在和自界说类型相关的类型转换基本都和构造函数有关 控制好自界说类型的构造函数，就可以通过不同类型的数据来构造一个自界说类型

【思考题】这里是 const 的权限缩小吗？

有人说，将非const类型的 iterator 赋值给 const 类型的迭代器 const_iterator 是一种 const 的权限缩小？？？
  1. list<int> lt1 = { 1, 2, 3, 4 };
  2. list<int>::const_iterator it = lt1.begin();  // 这个是 const 权限的缩小？
复制代码

要注意，迭代器是一种类，两个迭代器之间的拷贝赋值，是自界说类型之间的类型转换。 而 const 的权限问题只会出现在 内置类型之间 与 内置类型指针或引用之间



因此，我们直接在自界说类型 list 迭代器类 内部写一个新的构造函数即可
（我们这里的 list 是本身模仿实现的，现在就是演示添加类型转换功能给你看）
（C++STL库中的 list 的迭代器也可以类型转换（可以本身试一试））



由于迭代器类是模板，其中的构造函数参数固定写成 非const类型的迭代器 iterator
  1. // 迭代器就是将指向一个节点的指针 node 封装成一个类
  2. template<class T, class Ref, class Ptr>
  3. struct ListIterator
  4. {
  5.         typedef ListNode<T> Node;
  6.         typedef ListIterator<T, Ref, Ptr> Self;  // 自己这种类型
  7.         Node* _node;
  11.         // 类型转换的构造：这里参数固定写成 iterator
  12.         // 当该模板实例化为 iterator ：这里就是拷贝构造
  13.         // 当该模板实例化为 const_iterator ：这里就是普通构造（支持 iterator 转换成 const_iterator）
  14.         ListIterator(const ListIterator<T, T&, T*>& it)
  15.                 :_node(it._node)
  16.         {}
  19.         //......其他函数
  20. };
复制代码



测试一下：
  1. int main() {
  2.         // 这里是 const 的权限缩小吗？
  3.         // 不是，这里是 自定义之间类型转换，从 iterator类 转换为 const_iterator类，其本质是在const_iterator类中重载一个参数类型为 iterator 的构造函数
  4.         // 因此，自定义类型 可以转换成 自定义类型，内置类型也可以转换为自定义类型：本质都是自定义类型重载了相关联的构造函数
  5.         my::list<int> lt1 = { 1, 2, 3, 4 };
  6.         my::list<int>::const_iterator it = lt1.begin();
  7.         while (it != lt1.end()) {
  8.                 cout << *it << '\n';
  9.                 it++;
  10.         }
  11.         return 0;
  12. }
复制代码
效果：




2.7 注意事项

逼迫类型转换关闭或挂起了正常的类型查抄，每次使用逼迫类型转换前，程序员应该仔细思量是否另有其他不同的方法到达同一目的，如果非逼迫类型转换不可，则应限定逼迫转换值的作用域，以减少发生错误的机会。
猛烈建议：制止使用逼迫类型转换



3.RTTI（了解）

RTTI：Run-time Type identification的简称，即：运行时类型辨认。
这几个运算符为什么也是运行时辨认？
实在他们都是编译时就已经得出效果，这里的运行时辨认是语法语义上，在运行时判断类型或做选择，而底层实在就是编译时辨认



4. 常见口试题

这些问题上面文章都有解说了




免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/) Powered by Discuz! X3.4