C++的四种类型转换

C++语言级别提供了四种类型转换方式，分别是:
const_cast：去掉常量属性的一个类型转化
static_cast：提供编译器认为安全的类型转换，编译时期的类型转换
reinterpret_cast：类似于C风格的强制类型转换
dynamic_cast：主要用在继承结构中，可以支持RTTI类型识别的上下转换，属于运行时期的类型转换

const_cast例子：

int main()
{
    const int a = 10;
    int *p1 = (int *)&a;
    int *p2 = const_cast<int*>(&a);
    //const_cast<这里面必须是指针类型或引用类型>
    return 0;
}

运行没有任何问题，转到反汇编后发现，两种方式在汇编上没有区别，底层实现是一模一样的。

但是当我们使用const_cast将const int* 转成double* 后发现运行失败。

说明使用const_cast不能修改基础类型，只能调节类型限定符，也就是去掉常量属性。目的是防止通过C的低级别的类型强转，任意转换自身的类型，造成不可预计的错误。

static_cast：

int main()
{
 	 int a = 10;
    char b = static_cast<char>(a); 
    return 0;
}

这样使用没有任何问题。但是下面这种情况就会被编译器否决：

int main()
{
 	int *p = nullptr;
    double* b = static_cast<double*>(p); 
    return 0;
}

原因是没有任何联系的类型之间的转换就会被否决。也可以看出来，如果这样被转换成功了，那么这个double类型的指针就可以访问int类型指针所指向的地址，double有八个字节，实际上int只有四个字节，所以这样不安全。

reinterpret_cast：

这种转换也是不安全的，也会让一个double类型的指针指向int类型的内存空间。

int main()
{
 	int *p = nullptr;
    double* b = reinterpret_cast<double*>(p); 
    return 0;
}

dynamic：

例子如下：

class Base
{
public:
    virtual void func() = 0;
};
class Derive1:public Base
{
public:
    void func()
    {
        cout << "call Derivel:: func " << endl;
    }
};
class Derive2 :public Base
{
public:
    void func()
    {
        cout << "call Derive2:: func " << endl;
    }
    void func02()
    {
        cout << "call Derive2:: func02 " << endl;
    }
};

void showfunc(Base* p)
{
    //dynamic_cast会检查p指针是否是一个指向Derive2的类型对象？
    //如果是 dynamic_cast转换成功，返回Derive2的地址，否则返回nullptr
    Derive2 *pd2 = dynamic_cast<Derive2*>(p);
    if (pd2 != nullptr)
    {
        pd2->func02();
    }
    else
    {
        p->func();
    }
}
int main()
{
    Derive1 d1;
    Derive2 d2;

    showfunc(&d1);
    showfunc(&d2);

    return 0;
}

运行结果：