C++的显式转换

我们应该小心的使用转换,这无疑就是告诉编译器”忘记类型检查,把它看作是其它的类型”,这就是在C++的类型系统中引入了一个漏洞,并阻止编译器报告在类型检查上出错了,所有的出错都必须由程序员自己来解决.并且这些转换都很难查找出来(难以定位),他们通常就是一个括号,因此在标准的C++中引入了一个显式的转换语法,使用我们很容易的对其定位:

static_cast 用于”良性”和”适度良性”的转换,如自动转换

const_cast 对”const”和”volatile”进行转换

reinterpret_cast 最危险的

dynamic_cast 用于类型安全的向下转换

静态转换(static_cast)

static_cast用于明确定义的变换,包括编译器允许我们做而不用强制的转换,和不太安全但清楚定义的变换(如窄化),void*转换.我们看代码:

void castTest()
{
    int i=0x7fff;
    long l;
    float f;
    //类型的无损转换,也就是我们常说的自动向下
    l=i;
    f=i;
    //下面的同样有效,标准C++显式转换语法
    l=static_cast<long>(i);
    f=static_cast<float>(i);

    //“窄化”,有信息丢失
    i=l;
    i=f;
    //...
    i=static_cast<int>(l);
    i=static_cast<int>(f);
    char c=static_cast<char>(i);

    //void指针强转
    void* vp=&i;
    float* fp=(float*)vp;
    fp=static_cast<float*>(vp);
}

常量转换(const_cast)

这个唯一的功能就是把const转换到non-const或者volatile到non-volatile

//const_cast.cpp

int main(){

int a=32;
const int* cp=&a;
int* p=(int*)cp;
p=const_cast<int*>(cp);

}

重解释转换(reinterpret_cast)

这是最不安全的一种转换了,就像它的名字一样,是对类型的重解释

#include "stdafx.h"
#include "Cast2.h"
#include <cstdlib>
using namespace std;

extern const int sz;
struct X
{
    int a[sz];
public:
    //X(){memset(a,0,sz*sizeof(int));}
};

void print(X* x)
{
    for(int i=0;i<sz;i++)
    {
        cout<<i<<" : "<<x->a[i]<<endl;
    }
}

void castTest2()
{
    X x;
    print(&x);
    int* xp=reinterpret_cast<int*>(&x);
    for(int* i=xp;i<xp+sz;i++)
        *i=0;
    print(reinterpret_cast<X*>(xp));
}