【c++中的四种类型转换，应用场景】

c++中的四种类型转换

1.静态转换 ： static_cast

用法：static_cast(val)

1.基本类型间的转换

enum Day { Mon = 1, Tues = 2, Wed = 3, Thu = 4, Fir = 5, Sat = 6, Sun = 7 };

int main()
{
 int a = 10;
 char ch = 't';
 double dx = 21.65;
 a = static_cast(ch);
 a = static_cast(dx);
 Day x = Mon;
 a = x;
 x = static_cast(a);
 return 0;
}

2.指针转换

 int main()
 {
    int a = 10;
    char b = 'a';
    int* pa = &a;
    char* pb = &b;
    const int* pc = &a;
    pa = (int*)pb;  //c语言的强转，不安全
    pa = static_cast(pb);//error  类型不符合
     
    pa = (int*)pc; //c语言的强转，不安全
    pa = static_cast(pc);//error  无法去除const属性 
    return 0;
 }

总结：

1.不可以改变指针类型(特例：void型）

2.无法去除指针的const属性

3.对于void类型的指针,可以进行类型转换（如下）

int main()
{
 int a = 10;
 int* ip = nullptr;
 double* dp = nullptr;
 void* vp = &a;
 ip = static_cast(vp);
 dp = static_cast(vp);
 return 0;
}

3.左值到右值转换

int main()
{

    int a = 10;
    int &x = a;
    int &&rx = a; // error;
    int &&rx = static_cast(a); 
    return 0;
}

4.自定义类型间的转换

class  Base
{
private:
    int  a;
public:
    Base(int x = 0) : a(x){}
};
class Obj : public Base
{
private:
	int val;
public:
	Obj(int x = 1) : val(x){}
};
class Int
{
    int val;
public:
    Int(int x = 2) : val(x){}
};

1. 不同类型间转换

int main()
{
    Base a;
    Int  b;
    Base* pa = &a;
    Int* pb = nullptr;
    pb = (Int*)pa; //c语言的强转，不安全
    pb = static_cast (pa); //error  类型不一样
    
    return 0;
}

和内置类型一样,不行

2.上行转换

int main()
{
    Base a;
    Obj  b;
    Base* pa = &a;
    Obj* pb = &b;
    pa = pb; //隐式转换，(赋值兼容规则)
    pa = static_cast(pb);
    
    a = b;   //隐式转换，(赋值兼容规则)
    a = static_cast(b);
    return 0;
}

注意：

隐式执行任何类型转换都可由static_cast显示完成。

static_cast不能转换掉val的const属性。

3.下行转换

int main()
{
    Base a;
    Obj  b;
    Base* pa = &a;
    Obj* pb = &b;
    pb = pa; //error ,不满足赋值兼容规则
    pb = static_cast(pa);
       //  pb->val 为随机值
    return 0;
}

会发生越界问题

2.去除常性转换 const_cast

用法：const_cast (val)

特点：

1) 用于去除变量的只读属性

2) 强制转换的目标类型必须是指针或引用

1.内置类型

int main()
{
    const int a = 22; 
    const int* pb = &a;
    const int& b = a;
 
    int* pc = const_cast (pb);
    *pc  = 100;
    cout<<"a = "<
 
  
出现这种情况是因为 源程序 形成 可执行程序时需要经历4个步骤，分别是 预编译 ， 编译 ，汇编， 链接 ;
 
  
其中 预编译阶段
 
  
a) 删除所有的“#define”，并且展开所有的宏定义;所有的const内置类型在预编译阶段就已经做了类似于宏替换的工作
 
  
b) 处理所有的条件预编译指令，“#if”、“#ifdef”、“#endif”等;
 
  
c) 处理“#include”预编译指令，将被包含的文件插入到该预编译指令的位置;
 
  
d) 删除所有的注释;
 
  
e) 添加行号和文件名标识，以便于编译器产生调试用的符号信息及编译时产生编译错 误和警告时显示行号；
 
  
f) 保留所有的#pragma 编译器指令，因为编译器需要使用它们。
 
  
2.自定义类型
 
  
class Int
{
    int value;
public:
    Int(int x = 0) : value(x) {}
    ~Int() {}
    void SetValue(int x) { value = x; }
    int GetValue() const { return value; }
};

int main()
{
    const Int a(10);
    cout <<"a: " << a.GetValue() << endl;
    Int *ip = const_cast(&a);
    Int &b = const_cast(a);
    ip->SetValue(100);
    cout <<"a : " << a.GetValue() << endl;
    b.SetValue(200);
    cout <<"a : " << a.GetValue() << endl;
    system("pause");
}
 
  
运行结果：
 
  
 
  
结论：
 
  
 
   
对于自定义类型常量，不会进行类似宏替换操作。
 
   
常量指针被转化成非常量的指针，并且仍然指向原来的对象；
 
   
常量引用被转换成非常量的引用，并且仍然引用原来的对象；
 
  
 
  
3. 重新解释转换 reinterpret_cast
 
  
用法：reinterpret_cast (val)
 
  
说明：
 
  
type_name必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换
 成一个整数，也可以把一个整数转换成一个指针。类似C语言的强转。
 
  
用途：
 
  
1.用于指针类型间的强制转换 （无法去除const)
 
  
 
   
基本类型
 
  
 
  
int main()
{
 int a = 0x61626364; // a b c d

 char* p = reinterpret_cast(&a);
 cout << *p << endl;
 p += 1;
 cout << *p << endl;
 p += 1;
 cout << *p << endl;
 p += 1;
 cout << *p << endl; 
}
 
  
内存分布图：
 
 
  
运行结果：
 
  
 
  
 
   
自定义类型
 
  
 
  
class Object
{
private:
 int value;
public:
Object(int x = 0) :value(x) {}
 ~Object() {}
 int& Value() { return value; }
 const int& Value() const { return value; }
};

int main()
{
 Object obj(10);
 int* p = reinterpret_cast(&obj);
 int& a = reinterpret_cast(obj);
 cout << obj.Value() << endl;
 *p = 100;
 cout << obj.Value() << endl;
 a += 100;
 cout << obj.Value() << endl;
 return 0;
}

 
  
运行结果： 
 
  
注：对于自定义的类型尽量不要进行此类转换，如虚基类（含有虚基类指针），有函数虚函数的类（含有虚表指针），它们的地址空间中的成员信息分布计算容易出错，导致错误访问。
 
  
2.用于整数和指针类型间的强制转换
 
  
void fun(void* p)
{
    int a = reinterpret_cast(p);  //指针到整数
    cout<(a)); //整数到指针
    
    return 0;
}
 
  
运行结果：
 
  
 
  
4.动态转换 dynamic_cast
 
  
原理：RTTI
 
  
博客链接：点击跳转（建议先了解）
 
  
用法： dynamic_cast (val)
 
  
说明：必须是公有继承，基类要有虚函数。
 
  
允许在运行时刻进行类型转换 ,从而使程序能够在一个类层次结构中安全地转换类型, 把基类指针转换成派生类指针,或把指向基类的左值转换成派生类的引用。
 
  
type_name 只能是自定义类型的指针或引用。
 
  
特点：
 
  
 
   
与C++支持的其他强制转换不同的是， dynamic_cast 是在运行时执行的类型转换。
 
   
如果针对指针类型的 dynamic_cast 失败, 则dynamic_cast 的结果是 nullptr。
 
   
如果针对引用类型的 dynamic_cast 失败， 则 dynamic_cast 会抛出一个异常。
 
   
在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的。
 
   
在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。
 
  
 
  
我们主要来看下行转换
 
  
class Object
{
private:
 int value;
public:
 Object(int x = 0) :value(x) {}
 virtual void func() { cout << "value: " << value << endl; }
};
class Base : public Object
{
private:
 int num;
public:
 Base(int x = 0) :Object(x + 10), num(x) {}
 void func() { cout << "num: " << num << endl; }
};
 
  
1.正确的下行转换
 
  
int main()
{
 Base base;
 Object* pobj = &base;  
 Base* pa = dynamic_cast(pobj); //动态转换
}
 
  
图解：
 
  

 运行时检查
 
  
 
  
2.错误的下行转换
 
  
int main()
{
 Base base;
 Object* pobj = nullptr;
 Object obj;
 pobj = &obj;
 Base* pa = dynamic_cast(pobj); // 动态转换   pa = nullptr
 if(pa == nullptr) {cout << "hello world!" << endl;}
 Base* pb = static_cast(pobj);  //不安全
}
 
  
图解：
 
  

 运行时检查
 
  
 
  
运行结果：
 
  
 
  
3.引用
 
  
int main()
{
	Base base(22); 
	Object obja(11);
	Object& obj = obja;
	try 
	{
		Base& a = dynamic_cast(obj); // 动态转换 
		a.func();
	}
	catch (std::bad_cast& e)
	{
		cout << e.what()<(obj1); // 动态转换 
	b.func();
}
 
  
图解：
 
  
 
  
运行结果：
 
  
 
  
结论：
 
  
使用异常给程序增加了相应的运行开销 ，所以dynamic_cast尽可能使用指针。
 
  
 
   
和void型指针结合问题
 
  
 
  
int main()
{
    Base b;
    Object& obj = b;
    void* pobj = &obj;  //正确，void型指针可以指向任意类型
    Base* pb = dynamic_cast (pobj);  //error,pobj的类型是void(无类型信息)
}
 
  
结论：
 
  
dynamic_cast 的操作数必须是指向完整类型的指针。