C++强制类型转换

C++强制类型转换：static_cast、dynamic_cast、const_cast、reinterpret_cast

C强制转换

　　C语言中的强制转换主要用于普通数据类型、指针的强制转换，没有类型检查，转换不安全，语法为：

(type-id)expression//转换格式1
type-id(expression)//转换格式2

　　C++除了能使用c语言的强制类型转换外，还新增了四种强制类型转换：static_cast、dynamic_cast、const_cast、reinterpret_cast，主要运用于继承关系类间的强制转化，语法为：

//静态转换
static_cast<new_type>      (expression)
//动态转换
dynamic_cast<new_type>     (expression) 
//常量转换
const_cast<new_type>       (expression) 
//重新解释转换
reinterpret_cast<new_type> (expression)

　　其中new type为转换后的新类型，expression为旧类型

C++强制类型转换

1. static_cast 静态转换（编译时检查）

　　static_cast静态转换相当于C语言中的强制转换，但不能实现普通指针数据（空指针除外）的强制转换，一般用于父类和子类指针、引用间的相互转换。

　　①用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。不管是否发生多态，父子之间互转时，编译器都不会报错。

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

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

　　②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。

　　③把空指针转换成目标类型的空指针。

　　④把任何指针类型转换成空指针类型。

　　⑤可以对普通数据的const和non_const进行转换，但不能对普通数据取地址后的指针进行const添加和消去。

　　⑥无继承关系的自定义类型，不可转换，不支持类间交叉转换。

　　注意：static_cast不能转换掉expression的const、volatile、或者__unaligned属性

class Person{

};

class Son :public Person{

};

class My{};

void test02(){
    char a = 'c';
    int b = static_cast<int> (a);
    cout << b << endl;

    const char a0 = 'c';
    char b0 = static_cast<char> (a0);
    cout << b0 << endl;

    char a1 = 'c';
    const char b1 = static_cast<const char> (a1);
    cout << b1 << endl;

    //static无法丢掉常量或其他类型限定符，只限于对常量地址的指针去const
    //const char a2 = 'c';
    //char *b2 = static_cast<char*> (&a2);
    //cout << b2 << endl;

    
    //父类指针转为子类
    Person *p = NULL;
    Son *s = static_cast<Son*>(p);

    //子类指针转为父类
    Son *s0 = NULL;
    Person *p0 = static_cast<Person*>(s0);

    //My* my= static_cast<My*>(p); 无继承关系的自定义数据类型不能相互转换

    //父类对象无法转为子类对象
    //Person p1;
    //Son s1 = static_cast<Son>(p1);
    
    //子类对象可以赋值，初始化父类对象
    Son s2;
    Person p2 = static_cast<Person>(s2);

    //父类引用转为子类
    Person p_ ;
    Person &p3 = p_;
    Son &s3 = static_cast<Son&>(p3);

    //子类引用转为父类
    Son s_;
    Son &s4 = s_;
    Person &p4 = static_cast<Person&>(s4);

    //空指针转化为目标类型的指针
    void *pPtr = NULL;
    int *iPtr = static_cast<int*>(pPtr);

    //任何指针转化为空指针类型
    int *aInt = NULL;
    void *aVoid = static_cast<void*>(aInt);

    //static_cast不能进行出void外的指针强制互转
    char *tmp = "abc";
    cout << tmp << endl;

    //cout << static_cast<int*>(tmp) << endl;不能将char*型的数据转换为int*，但C语言强转可以
    cout << static_cast<void*>(tmp) << endl;

    int *tmp_ = (int*)(tmp); 
    cout << static_cast<int*>(tmp_) << endl;

    int *tmpInt = 0;
    cout << tmpInt << endl;
    cout << static_cast<void*>(tmpInt) << endl;
    cout << static_cast<int*>(tmpInt) << endl;//转为自身可以
}

2.dynamic_cast 动态转换（运行时检查）

　　动态转换的类型和操作数必须是完整类类型或空指针、空引用，说人话就是说，只能用于类间转换，支持类间交叉转换，不能操作普通数据。

　　主要用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换，

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

　　　　②进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的，不允许转化，编译器会报错；

　　　　③发生多态时，允许互相转换。

　　　　④无继承关系的类之间也可以相互转换，类之间的交叉转换。

　　　　⑤如果dynamic_cast语句的转换目标是指针类型并且失败了，则结果为0。如果转换目标是引用类型并且失败了，则dynamic_cast运算符将抛出一个std::bad_cast异常

3. const_cast 常量转换

　　const_cast，用于修改类型的const或volatile属性，不能对非指针或非引用的变量添加或移除const。

const int g = 20;
//int h = const_cast<int>(g); //不允许对普通数据进行操作
int *h = const_cast<int*>(&g);//去掉const常量const属性

const int g0 = 20;
const int &g2 = g0;
int &h = const_cast<int &>(g0);//去掉const引用const属性
int &h2 = const_cast<int &>(g2);//去掉const引用const属性

const char *g1 = "hello";
char *h = const_cast<char *>(g1);//去掉const指针const属性

4.reinterpret_cast 重新解释转换

　　最鸡肋的转换函数，可以将任意类型转换为任意类型，因此非常不安全。只有将转换后的类型值转换回到其原始类型，这样才是正确使用reinterpret_cast方式。

　　另外，static_cast和reinterpret_cast的区别主要在于多重继承，比如

class A {
    public:
    int m_a;
};
 
class B {
    public:
    int m_b;
};
 
class C : public A, public B {};

void test(){
    C c;
    printf("%p, %p, %p", &c, reinterpret_cast<B*>(&c), static_cast <B*>(&c));
}

　　前两个的输出值是相同的，最后一个则会在原基础上偏移4个字节，这是因为static_cast计算了父子类指针转换的偏移量，并将之转换到正确的地址（c里面有m_a,m_b，转换为B*指针后指到m_b处），而reinterpret_cast却不会做这一层转换