一、static_cast, dynamic_cast, const_cast

http://www.cnblogs.com/chio/archive/2007/07/18/822389.html

http://blog.csdn.net/deyili/article/details/5354242（很重要的）

dynamic_cast一般用在父类和子类指针或引用的互相转化;
static_cast一般是普通数据类型(如int m=static_cast<int>(3.14));
reinterpret_cast很像c的一般类型转换操作
const_cast是把cosnt或volatile属性去掉

void 指针无法直接复制给其他指针

#include<iostream>

void main()

{

    void *p=NULL;

    int *pp=p;

}

//ok

#include<iostream>

void main()

{

    int *pp=NULL;

    void *p=pp;

}

static_cast<>()的类型检查是什么意思

例子如下：

#include <iostream>

using namespace std;

class A

{

public:

    int m_a;

};

class B: public A

{

public:

    int m_b;

};

class C

{

public:

    int m_c;

};

void f(A &a)

{

    cout<<"f is called"<<endl;

}

void main()

{

    B b;

    C c;

    B *pc;

    f(static_cast<A &>(b));//static_cast的一大作用：子类对象b转化为父类对象，可以通过编译

//    f(static_cast<A &>(c));//进行了类型检查，类A和类C是毫无关系的，检查出错，不能通过编译

//f(static_cast<A *>(pc));//进行了类型检查，类A和类C是毫无关系的，检查出错，不能通过编译

}

static_cast和dynamic_cast的不同

例子如下：三个类的定义同上

void main()

{

    B b;

    C c;

    B & ref_b=reinterpret_cast<B &>(c);

    f(static_cast<A &>(ref_b));//成功欺骗编译器，编译通过，成功运行

    //f(dynamic_cast<A &(ref_b));//编译通过，但是运行时检查了ref_b的实际类型为B，所以运行失败

}

void main()

{

    B b;

    C c;

    A & ref_b=reinterpret_cast<A &>(c);

    f(ref_b);//成功欺骗编译器，编译通过，成功运行

}

dynamic_cast的作用

在应用多态编程时，当我们无法确定传过来的对象的实际类型时使用dynamic_cast：如我们并不能确定传入的ref_b到底是B类型还是C类型（c通过reinterpret_cast转换为b，编译器并不知情），这时就应该用dynamic_cast。
void main()

{

    B b;

    C c;

    B & ref_b=reinterpret_cast<B &>(c);

    f(static_cast<A &>(ref_b));//成功欺骗编译器，编译通过，成功运行

    //f(dynamic_cast<A &>(ref_b));//编译通过，但是运行时检查了ref_b的实际类型，所以运行失败

}

如果能保证对象的实际类型，用static_cast就可以了。至于reinterpret_cast，我很喜欢，很象c语言那样的暴力转换：）

例子：无关类之间的转换

#include<iostream>

class CBaseX

{

public:

    void foo() { printf("CBaseX::foo() x=%d/n", x); }

};

class CBaseY

{

public:

    void bar() { printf("CBaseY::bar()");

    }

};

void main()

{

    CBaseX* pX = new CBaseX();    // 两个无关类：CBaseX* 和 CBaseY*之间的转换

    // CBaseY* pY1 = static_cast<CBaseY*>(pX);   // 错误， 类型指向是无关的 (解释：指针变量PX是CBaseX类型，现在要将其转换为CBase类型)

    CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);       // 成功编译, 但是 pY2 不是CBaseX

    pY2->bar();//如果你尝试转换一个对象（pX）到另一个无关的类(pY2)static_cast<>将失败，而reinterpret_cast<>总是能成功“欺骗”编译器：认为被转换的那个对象(pX)就是要转换到的无关类（pY）。

}

例子：相关类之间的转换

#include<iostream>

class CBaseX

{

public:

    int x;

    CBaseX() { x = 10; }

    void foo() { printf("CBaseX::foo() x=%d/n", x); }

};

class CBaseY

{

public:

    int y;

    int* py;

    CBaseY() { y = 20; py = &y; }

    void bar() { printf("CBaseY::bar() y=%d, *py=%d/n", y, *py);

    }

};

class CDerived : public CBaseX, public CBaseY

{

public:

    int z;

};

void main()

{

    CDerived* pD = new CDerived();

    printf("CDerived* pD = %x\n", (int)pD);

    // static_cast<> CDerived* -> CBaseY* -> CDerived*

    //成功编译，隐式static_cast<>转换

    CBaseY* pY1 = pD;

    printf("CBaseY* pY1 = %x\n", (int)pY1);

    // 成功编译, 现在 pD1 = pD

    CDerived* pD1 = static_cast<CDerived*>(pY1);

    printf("CDerived* pD1 = %x\n", (int)pD1);

    // reinterpret_cast

    // 成功编译, 但是 pY2 不是 CBaseY*

    CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);

    printf("CBaseY* pY2 = %x\n", (int)pY2);

    // 无关的 static_cast<>

    CBaseY* pY3 = new CBaseY();

    printf("CBaseY* pY3 = %x\n", (int)pY3);

    // 成功编译,尽管 pY3 只是一个 "新 CBaseY()"

    CDerived* pD3 = static_cast<CDerived*>(pY3);

    printf("CDerived* pD3 = %x\n", (int)pD3);

}

如图所示，CDerived的内存布局包括两个对象，CBaseX 和 CBaseY，编译器也知道这一点。因此，当你将CDerived* 转换到 CBaseY*时，它给指针添加4个字节，同时当你将CBaseY*转换到CDerived*时，它给指针减去4。然而，甚至它即便不是一个CDerived你也可以这样做。

当然，这个问题只在如果你做了多继承时发生。在你将CDerived转换到 CBaseX时static_cast<> 和 reinterpret_cast<>是没有区别的。

例子3：void*之间的向前和向后转换

void main()

{

    CDerived* pD = new CDerived();

    printf("CDerived* pD = %x\n", (int)pD);// 打印的是派生类的地址

    CBaseY* pY = pD; // 成功编译, pY = pD + 4

    printf("CBaseY* pY = %x\n", (int)pY);// 打印的是基类pY的地址

    void* pV1 = pY; //成功编译, pV1 = pY  //打印的是基类pY的地址

    printf("void* pV1 = %x\n", (int)pV1);

    CDerived* pD2 = static_cast<CDerived*>(pV1);// pD2 = pV1=pY, 但是我们预期 pD2 = pY - 4

    printf("CDerived* pD2 = %x\n", (int)pD2);

    // 系统崩溃

    // pD2->bar();

}

一旦我们已经转换指针为void*，我们就不能轻易将其转换回原类。在上面的例子中，从一个void* 返回CDerived*的唯一方法是将其转换为CBaseY*然后再转换为CDerived*。
但是如果我们不能确定它是CBaseY* 还是 CDerived*，这时我们不得不用dynamic_cast<> 或typeid[2]。

注释：
1. 1. dynamic_cast<>，从另一方面来说，可以防止一个泛型CBaseY* 被转换到CDerived*。
2. 2. dynamic_cast<>需要类成为多态，即包括“虚”函数，并因此而不能成为void*。

巴特西

20140422 ALT+F8 四个强制类型转换

一、static_cast, dynamic_cast, const_cast

void 指针无法直接复制给其他指针

static_cast<>()的类型检查是什么意思

例子如下：

dynamic_cast的作用

例子：无关类之间的转换

例子：相关类之间的转换

例子3：void*之间的向前和向后转换

注释：

最新文章

热门文章