【C++】static_cast，const_cast，dynamic_cast，reinterpert_cast

本文介绍C++中四个类型转换符：static_cast、dynamic_cast、const_cast和reinterpret_cast。

1. static_cast

static_cast应用于以下三种场景：
（1）基本数据类型之间的转换

int main()
{
    float pi = 3.1415;
    int a = static_cast<int>(pi);

    cout << pi << " " << a << endl;
}

(2) void*与目标类型的指针间的转换

int main()
{
    int n = 10;
    void *pv = &n;
    int *p = static_cast<int*>(pv);

    cout << n << " " << *p;
}

int main()
{
    int n = 10;
    int *pn = &n;
    void *pv = static_cast<void*>(pn);
    int *p = static_cast<int*>(pv);

    cout << n << " " << *p;
}

【注】static_cast不能转换掉变量的const、volatile和__unaligned属性

（3）基类与派生类指针或引用类型之间的转换
此时不做运行时检测，不如dynamic_cast安全。

• 当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
• 当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的；

class Base {
public:
    Base() { cout << "Base Constructor\n"; }
    virtual ~Base() { cout << "Base Destructor\n"; }
    virtual void print() {
        cout << "print in Base\n";
    }
};

class Derived : public Base {
public:
    Derived() { cout << "Derived Constructor\n"; }
    virtual ~Derived() { cout << "Derived Destructor\n"; }

    virtual void print() {
        cout << "print in Derived\n";
    }

    virtual void func() {
        cout << "csdn blog\n";
    }

private:
    int x;
};

int main()
{
    // 基类指针转为派生类指针，且该基类指针指向基类对象
    Base *pb1 = new Base;
    Derived *pd1 = static_cast<Derived*>(pb1);
    // pd1->func(); // run time error

    // 基类指针转为派生类指针，且该基类指针指向派生类对象
    Base *pb2 = new Derived;
    Derived *pd2 = static_cast<Derived*>(pb2);
    pd2->func(); // right

    // 派生类指针转为基类指针
    Derived *pd3 = new Derived;
    Base *pb3 = static_cast<Base*>(pd3);
    pb3->print(); // right
}

2. const_cast

const_cast用来将变量的const、volatile和__unaligned属性移除。常量指针被转换成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然引用原来的对象

class CSDN
{
public:
    CSDN() : v(10){};

    int v;
};

int main()
{
    const CSDN *pa = new CSDN;
    // pa->v = 100; // error
    CSDN *pb = const_cast<CSDN*>(pa);
    pb->v = 100;

    // pa、pb指向同一个对象
    cout << pa->v << "\n" << pb->v << endl;

    const CSDN &refa = *pa;
    // refa.v = 200; // error
    CSDN &refb = const_cast<CSDN&>(refa);
    refb.v = 200;

    // refa、refb引用同一个对象
    cout << refa.v << "\n" << refb.v << endl;
}

3. reinterpret_cast

处理无关类型之间的转换；它会产生一个新的值，这个值会有与原始参数（expressoin）有完全相同的比特位。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针，在实际开发中，先把一个指针转换成一个整数，再把该整数转换成原类型的指针，还可以得到原来的指针值；特别是开辟了系统全局的内存空间，需要在多个应用程序之间使用时，需要彼此共享，传递这个内存空间的指针时，就可以将指针转换成整数值，得到以后，再将整数值转换成指针，进行对应的操作。

void printInt(void* a) {
    int n = reinterpret_cast<int>(a);

    cout << n << endl;
}

int main()
{
    int n = 10;
    void *a = reinterpret_cast<void*>(n);
    printInt(a);
}

4. dynamic_cast

参考

[1] http://www.jb51.net/article/55885.htm
[2] http://www.cnblogs.com/QG-whz/p/4517336.html
[3] http://blog.csdn.net/wenpinglaoyao/article/details/50497169