C++学习之类型转换

1. 隐式类型转换
   char c = ‘a’;
   int i = c;//隐式
    
   void func(int i){}
   func(c);//隐式
    
   int func(void){
   char c = ‘a’;
   return c;//隐式
   }

2. 显式类型转换
   2.1
   C++兼容C语言的强制转换
   int i = (int)c;//C风格强制转换
   int i = int(c);//C++风格强制转换
    
   2.2
   C++增加了四种操作符形式的类型转换
   1）静态类型转换：static_cast
   语法：
   目标变量 = static_cast<目标类型>(源类型变量);
   适用场景：
   主要用于将void*转换为其它类型的指针，或者基类指针合理转化为子类指针

   #include <iostream>
   using namespace std;
   
   int main(void){
       int* pi = NULL;
       //char c = (int)pi;//C风格强制转换
       char c = int(pi);//C++风格强制转换
       
       //静态类型转换
       //char c2 = static_cast<int>(pi);//不合理 
       void* pv = pi;
       pi = static_cast<int*>(pv);//合理
   
   
       return 0;
   }
   

    
   2）动态类型转换：dynamic_cast
   语法：
   目标变量 = dynamic_cast<目标类型>(源类型变量);
   适用场景：主要用于具有多态继承关系的父子类指针或引用之间的显式类型转换。在转换过程中，会检查目标对象和期望转换的类型是否一致，如果一致则转换成功，否则失败。如果转换的是指针，返回空表示失败，如果转换的是引用，抛出bad_cast的异常表示失败。
    

   #include <iostream>
   using namespace std;
   class A{ virtual void foo(void){} };
   class B:public A{ void foo(void){} };
   class C:public A{ void foo(void){} };
   int main(void){
       B b;
       A* pa = &b;
       //B* pb = static_cast<B*>(pa);//合理,编译过
       //C* pc = static_cast<C*>(pa);//不合理，编译过
       B* pb = dynamic_cast<B*>(pa);//合理
       C* pc = dynamic_cast<C*>(pa);//不合理
       cout << "pa=" << pa << endl;
       cout << "pb=" << pb << endl;
       cout << "pc=" << pc << endl;//0,表示失败
       
       A& ra = b;
       C& rc = dynamic_cast<C&>(ra);//不合理
   
   
       return 0;
   }
   

   3）去常类型转转：const_cast
   语法：
   目标变量 = const_cast<目标类型>(源类型变量);
   适用场景：
   主要用于去除指针或引用的const属性

   #include <iostream>
   using namespace std;
   int main(void){
       /* volatile修饰变量表示易变的,告诉编译器每次
        * 使用该变量都要内存中重新读取,而不是取寄存
        * 器中副本,防止编译器优化引发的错误结果.
        * 如果不加volatile，打印ci为100，打印*pci为200
        * */
       volatile const int ci = 100;
       int* pci = const_cast<int*>(&ci);
       *pci = 200;
       cout << "ci=" << ci << endl;//200
       cout << "*pci=" << *pci << endl;//200
       cout << "&ci=" << (void*)&ci << endl;
       cout << "pci=" << (void*)pci << endl;
   
       return 0;
   }
   

    
   4）重解释类型转换：reinterpret_cast
   语法：
   目标变量 = reinterpret_cast<目标类型>(源类型变量);
   适用场景：
   –》任意类型指针或引用之间的显式转换
   –》在指针和整型数之间的显式转换
    
   eg:已知物理内存地址0x12345678,向存放数据100？
   int* paddr = reinterpret_cast<int*>(0x12345678);
   *paddr = 100;

   #include <iostream>
   using namespace std;
   
   int main(void){
       //"\000"出现在字符串中，意为转义字符，默认后跟3位八进制数，表示一个ascii码
       //但是如果想用十六进制，可以"\x00" \x后跟两个数字即可代表8个bit，但是默认并不是\x后边跟两个数字
       //而是无限个，所以为了达到目的应写成如下,用双引号进行限定。
       //char buf[] = "0001""\x00""12345678""\x00""123456""\x00"
       char buf[] = "0001\00012345678\000123456\000";
       struct Http{
           char type[5];
           char id[9];
           char passwd[7];
       };
       Http* ph = reinterpret_cast<Http*>(buf);
       cout << ph->type << endl;//0001
       cout << ph->id << endl;//12345678
       cout << ph->passwd << endl;//123456
       return 0;
   }