[C++] C++风格的强制类型转换探讨

C++风格的强制类型转换：const_cast，static_cast，dynamic_cast，reinterpret_cast。

使用：xxx_cast<type-id> (expression)

const_cast

• 说明：该运算符用来修改类型的const或volatile属性。

class TestA
{
public:
    TestA() { }
public:
    int m_data;
};

void foo()
{
    const TestA ta;
    //ta1.m_data = 100;    //编译错误

    TestA *pTa = const_cast<TestA*>(&ta);
    pTa->m_data = 200;     //OK
    
    TestA &taTmp = const_cast<TestA&>(ta);
    taTmp.m_data = 300;    //OK
}

int main( int argc, char * argv[] )
{
    foo();
    return 0;
}

 

static_cast

• 说明：无条件强制转换，没有在运行时进行类型检查来保证转换的安全性，static_cast也不能去掉类型的const、volitale属性。
• 场景：

1. 基类和子类之间转换：进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。
2. 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等。
3. 把空指针转换成目标类型的空指针。
4. 把任何类型的表达式转换成void类型。

void foo()
{
    int n = 6;
    char c = static_cast<char>(n);          // 基本类型转换
    double d = static_cast<double>(n);
    float f = static_cast<float>(n);
    
    int *pn = &n;
    //double *d = static_cast<double*>(&n)  //无关类型指针转换，编译错误
    void *p = static_cast<void*>(pn);       //任意类型转换成void类型
}

int main( int argc, char * argv[] )
{
    foo();
    return 0;
}

dynamic_cast

• 说明：type-id必须是类的指针、类的引用或者void*，运行时会进行类型安全检查(转换失败返回NULL)。
• 场景：

1. 基类和子类之间转换，上行和下行转换都是安全的。
2. 基类必须要有虚函数。
3. 交叉转换（相同基类的不同子类之间的转换），但结果是NULL。

#include <string.h>
#include <iostream>

using namespace std;

class BaseClass 
{
public:
    int m_data;
    virtual void btest(){}; //基类必须有虚函数
};

class DerivedClass : public BaseClass 
{
public:
    char m_arr[100];
    void dtest(){};
};

void foo()
{
    BaseClass* pb = new DerivedClass();
    DerivedClass *pd1 = static_cast<DerivedClass *>(pb);   //子类->父类，静态类型转换，正确但不推荐
    DerivedClass *pd2 = dynamic_cast<DerivedClass *>(pb);  //子类->父类，动态类型转换，正确

    BaseClass* pb2 = new BaseClass();
    DerivedClass *pd3 = static_cast<DerivedClass *>(pb2);  //父类->子类，静态类型转换，危险！
    //strcpy(pd3->m_arr, "0123456789");                    //访问子类m_arr成员越界，造成运行时错误。

    DerivedClass *pd4 = dynamic_cast<DerivedClass *>(pb2); //父类->子类，动态类型转换，安全。结果为NULL。
    if (NULL == pd4)
    {
        cout << "null == pd4" << endl;
    }
}

int main( int argc, char * argv[] )
{
    foo();
    return 0;
}

reinterpret_cast

• 说明：仅仅重新解释类型，但没有做字节对齐。
• 场景：最普通的用途就是在函数指针类型之间进行转换，但是很难保证移植性。

#include<iostream>

using namespace std;

class TestA
{
public:
    int m_a;
};

class TestB 
{
public:
    int m_b;
};

class TestC : public TestA, public TestB 
{};

void foo()
{
    TestC tc;

    cout << "&tc = 0x" << &tc << endl;
    cout << "reinterpret_cast<TestB*>(&tc) = 0x" << reinterpret_cast<TestB*>(&tc) << endl;
    cout << "static_cast<TestB*>(&tc) = 0x" << static_cast<TestB*>(&tc) << endl;
}

int main( int argc, char * argv[] )
{
    foo();
    return 0;
}

结果：

static_cast转换之后结果 - reinterpret_cast转换之后的结果 = 4（即该测试类中的字节对齐长度）。

说明：static_cast在进行上行转换是安全的，static_cast计算了父子类指针转换的偏移量，并将之转换到正确的地址，而reinterpret_cast则不会做这层转换。

总结

• const_cast：去const或volatile属性时用到。
• static_cast：基本类型转换（不包括指针类型）时用到。
• daynamic_cast：基类与子类的指针（或引用）互相转换时用到。
• reinterpret_cast：不同类型的指针类型转换（如：函数指针类型之间进行转换），慎用。

参考

• http://baike.baidu.com/view/1745221.htm
  
• http://baike.baidu.com/view/1745207.htm
• http://baike.baidu.com/view/1745213.htm
• http://baike.baidu.com/view/1263731.htm
• http://www.cnblogs.com/goodhacker/archive/2011/07/20/2111996.html

（完）