感谢，Thanks！

                                         四 堆栈与函数调用

一 C++程序内存分配

1) 在栈上创建。在执行函数时，函数内局部变量的存储单元都在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，一般使用寄存器来存取，效率很高，但是分配的内存容量有限。
2) 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete来释放内存。动态内存的生存期由程序员自己决定，使用非常灵活。
3) 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
4) 文字常量分配在文字常量区，程序结束后由系统释放。
5）程序代码区。

经典实例：（代码来自网络高手，没有找到原作者）

Code
#include <string>

int a=0;    //全局初始化区
char *p1;   //全局未初始化区
 void main()
{
    int b;//栈
    char s[]="abc";   //栈
    char *p2;         //栈
    char *p3="123456";   //123456"0在常量区，p3在栈上。
    static int c=0;   //全局（静态）初始化区
    p1 = (char*)malloc(10);
    p2 = (char*)malloc(20);   //分配得来得10和20字节的区域就在堆区。
    strcpy(p1,"123456");   //123456"0放在常量区，编译器可能会将它与p3所向"123456"0"优化成一个地方。
}

二 三种内存对象的比较
栈对象的优势是在适当的时候自动生成，又在适当的时候自动销毁，不需要程序员操心；而且栈对象的创建速度一般 较堆对象快，因为分配堆对象时，会调用operator new操作，operator new会采用某种内存空间搜索算法，而该搜索过程可能是很费时间的，产生栈对象则没有这么麻烦，它仅仅需要移动栈顶指针就可以了。但是要注意的是，通常栈 空间容量比较小，一般是1MB～2MB，所以体积比较大的对象不适合在栈中分配。特别要注意递归函数中最好不要使用栈对象，因为随着递归调用深度的增加， 所需的栈空间也会线性增加，当所需栈空间不够时，便会导致栈溢出，这样就会产生运行时错误。
堆对象创建和销毁都要由程序员负责，所以，如果 处理不好，就会发生内存问题。如果分配了堆对象，却忘记了释放，就会产生内存泄漏；而如 果已释放了对象，却没有将相应的指针置为NULL，该指针就是所谓的“悬挂指针”，再度使用此指针时，就会出现非法访问，严重时就导致程序崩溃。但是高效 的使用堆对象也可以大大的提高代码质量。比如，我们需要创建一个大对象，且需要被多个函数所访问，那么这个时候创建一个堆对象无疑是良好的选择，因为我们 通过在各个函数之间传递这个堆对象的指针，便可以实现对该对象的共享，相比整个对象的传递，大大的降低了对象的拷贝时间。另外，相比于栈空间，堆的容量要 大得多。实际上，当物理内存不够时，如果这时还需要生成新的堆对象，通常不会产生运行时错误，而是系统会使用虚拟内存来扩展实际的物理内存。
静态存储区。所有的静态对象、全局对象都于静态存储区分配。关于全局对象，是在main()函数执行前就分配好了的。其实，在main()函数中的显示代 码执行之前，会调用一个由编译器生成的_main()函数，而_main()函数会进行所有全局对象的的构造及初始化工作。而在main()函数结束之 前，会调用由编译器生成的exit函数，来释放所有的全局对象。比如下面的代码：

实际上，被转化成这样：

　　除了全局静态对象，还有局部静态对象通和class的静态成员，局部静态对象是在函数中定义的，就像栈对象一样，只不过，其前面多了个 static关键字。局部静态对象的生命期是从其所在函数第一次被调用，更确切地说，是当第一次执行到该静态对象的声明代码时，产生该静态局部对象，直到 整个程序结束时，才销毁该对象。class的静态成员的生命周期是该class的第一次调用到程序的结束。

三 函数调用与堆栈

1)编译器一般使用栈来存放函数的参数，局部变量等来实现函数调用。有时候函数有嵌套调用，这个时候栈中会有多个函数的信息，每个函数占用一个连续的区域。一个函数占用的区域被称作帧（frame）。同时栈是线程独立的，每个线程都有自己的栈。例如下面简单的函数调用：

另外函数堆栈的清理方式决定了当函数调用结束时由调用函数或被调用函数来清理函数帧，在VC中对函数栈的清理方式由两种：

2) 有了上面的知识为铺垫，我们下面细看一个函数的调用时堆栈的变化：

代码如下：

Code
int Add(int x, int y)
{
    return x + y;
}

void main()
{
    int *pi = new int(10);
    int *pj = new int(20);
    int result = 0;
    result = Add(*pi,*pj);
    delete pi;
    delete pj;
}

对上面的代码，我们分为四步，当然我们只画出了我们的代码对堆栈的影响，其他的我们假设它们不存在，哈哈!

第一，int *pi = new int(10);   int *pj = new int(20);   int result = 0; 堆栈变化如下：

第二，Add(*pi,*pj);堆栈如下：

第三，将Add的结果给result，堆栈如下：

第四，delete pi;    delete pj; 堆栈如下：

第五，当main()退出后，堆栈如下，等同于main执行前，哈哈！

四 完！

                                      五 sizeof与内存布局

有了前面几节的铺垫，本节开始摸索C++的对象的内存布局，平台为windows32位+VS2008。

一 内置类型的size

内置类型，直接上代码，帮助大家加深记忆：

Code
void TestBasicSizeOf()
{
    cout << __FUNCTION__ << endl;

    cout << "  sizeof(char)= " << sizeof ( char ) << endl;
    cout << "  sizeof(int)= " << sizeof ( int ) << endl;
    cout << "  sizeof(float)= " << sizeof ( float ) << endl;
    cout << "  sizeof(double)= " << sizeof ( double ) << endl;

    cout << "  sizeof('$')=" << sizeof ( '$' ) << endl;
    cout << "  sizeof(1)= " << sizeof ( 1 ) << endl;
    cout << "  sizeof(1.5f)= " << sizeof ( 1.5f ) << endl;
    cout << "  sizeof(1.5)= " << sizeof ( 1.5 ) << endl;

    cout << "  sizeof(Good!)= " << sizeof ( "Good!" ) << endl ;

    char  str[] = "CharArray!";
    int  a[10]; 
    double  xy[10];
    cout << "  char str[] = ""CharArray!""," << " sizeof(str)= " << sizeof (str) << endl;
    cout << "  int a[10]," << " sizeof(a)= " << sizeof (a) << endl;
    cout << "  double xy[10]," << " sizeof(xy)= " <<   sizeof (xy) << endl;

    cout << "  sizeof(void*)= " << sizeof(void*) << endl;
}

运行结果如下：

二 struct/class的大小

在C++中我们知道struct和class的唯一区别就是默认的访问级别不同，struct默认为public，而class的默认为 private。所以考虑对象的大小，我们均以struct为例。对于struct的大小对于初学者来说还确实是个难回答的问题，我们就通过下面的一个 struct定义加逐步的变化来引出相关的知识。

代码如下：

Code
struct st1
{
    short number;
    float math_grade;
    float Chinese_grade;
    float sum_grade;
    char  level;
}; //20

struct st2
{
    char  level;
    short number;
    float math_grade;
    float Chinese_grade;
    float sum_grade;
};//16

#pragma pack(1)
struct st3
{
    char  level;
    short number;
    float math_grade;
    float Chinese_grade;
    float sum_grade;
}; //15
#pragma pack() 

void TestStructSizeOf()
{
    cout << __FUNCTION__ << endl;

    cout << "  sizeof(st1)= " << sizeof (st1) << endl;
    cout << "  offsetof(st1,number) " << offsetof(st1,number) << endl;
    cout << "  offsetof(st1,math_grade) " << offsetof(st1,math_grade) << endl;
    cout << "  offsetof(st1,Chinese_grade) " << offsetof(st1,Chinese_grade) << endl;
    cout << "  offsetof(st1,sum_grade) " << offsetof(st1,sum_grade) << endl;
    cout << "  offsetof(st1,level) " << offsetof(st1,level) << endl;

    cout << "  sizeof(st2)= " << sizeof (st2) << endl;
    cout << "  offsetof(st2,level) " << offsetof(st2,level) << endl;
    cout << "  offsetof(st2,number) " << offsetof(st2,number) << endl;
    cout << "  offsetof(st2,math_grade) " << offsetof(st2,math_grade) << endl;
    cout << "  offsetof(st2,Chinese_grade) " << offsetof(st2,Chinese_grade) << endl;
    cout << "  offsetof(st2,sum_grade) " << offsetof(st2,sum_grade) << endl;


    cout << "  sizeof(st3)= " << sizeof (st3) << endl;
    cout << "  offsetof(st3,level) " << offsetof(st3,level) << endl;
    cout << "  offsetof(st3,number) " << offsetof(st3,number) << endl;
    cout << "  offsetof(st3,math_grade) " << offsetof(st3,math_grade) << endl;
    cout << "  offsetof(st3,Chinese_grade) " << offsetof(st3,Chinese_grade) << endl;
    cout << "  offsetof(st3,sum_grade) " << offsetof(st3,sum_grade) << endl;
}

运行结果如下;

基于上面的对struct的测试，我们是不是有些惊呆哦，对于C++的初学者更是情不自禁的说：“我靠！原来顺序不同所占空间都不同啊，还有那个 pack是啥东东啊？”，其实这里蕴含了一个内存对齐的问题，在计算机的底层进行内存的读写的时候，如果内存对齐的话可以提高读写效率，下面是VC的默认 规则：

1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍， 如有需要编译器会在成员之间加上填充字节（internal adding）；
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。

当然VC提供了工程选项/Zp[1|2|4|8|16]可以修改对齐方式，当然我们也可以在代码中对部分类型实行特殊的内存对齐方式，修改方式为#pragma pack( n )，n为字节对齐
数，其取值为1、2、4、8、16，默认是8，取消修改用#pragma pack(),如果结构体某成员的sizeof大于你设置的，则按你的设置来对齐。

三 struct的嵌套

1）实例：

Code
struct A
{
    int i;
    char c;
    double d;
    short s;
}; // 24

struct B
{
    char cc;
    A a;
    int ii;
}; // 40

布局：（使用VS的未发布的编译选项/d1 reportAllClassLayout 或 /d1 reportSingleClassLayout）

2）实例：

Code
#pragma pack(4)
struct A2
{
    int i;
    char c;
    double d;
    short s;
}; // 20
#pragma pack()

struct B2
{
    char cc;
    A2 a;
    int ii;
}; // 28

布局：（使用VS的未发布的编译选项/d1 reportAllClassLayout 或 /d1 reportSingleClassLayout）

总结：

　　由于结构体的成员可以是复合类型，比如另外一个结构体，所以在寻找最宽基本类型成员时，应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。

四 空struct/class和const，static成员

实例：

Code
struct empty{}; // 1
struct constAndStatic
{
    const int i;
    static char c;
    const double d;
    static void TestStatic(){}
    void TestNoStatic(){}
}; // 16

布局：（使用VS的未发布的编译选项/d1 reportAllClassLayout 或 /d1 reportSingleClassLayout）

上面的实例中empty的大小为1，而constAndStatic的大小为16。

总结：

因为static成员和函数其实是类层次的，不在对象中分配空间，而成员函数其实是被编译为全局函数了，所以也不在对象中。

五 本节完，下次探讨虚函数对内存布局的影响！

                                        六 单继承与虚函数表

一 单继承

1) 代码：

Code
#include <iostream>
using namespace std;

class A
{
public:
    void f1(){cout << "A::f1" << endl;}
    void f2(){cout << "A::f2" << endl;}
    virtual void v1(){cout << "A::v1" << endl;}
    virtual void v2(){cout << "A::v2" << endl;}
    int x;
};

class B : public A
{
public:
    void f2(){cout << "B::f2" << endl;} // 覆盖
    void v2(){cout << "B::v2" << endl;} // 重写

    void f3(){cout << "B::f3" << endl;} 
    virtual void v3(){cout << "B::v3" << endl;}
    int y;
};

class C : public B
{
public:
    void f3(){cout << "C::f3" << endl;} // 覆盖
    void v1(){cout << "C::v1" << endl;} // 重写
    void v3(){cout << "C::v3" << endl;} // 重写
    int z;
};

2）类图：

3）VS2008的编译选项查看布局：

4）可视化表示：

5）代码验证：

Code
typedef void (*Fun)();

void PrintVTable(A *pA)
{
    int *pVT = (int*)*(int*)(pA);
    Fun* pF = (Fun*)(pVT + 0);
    int iLength = 0;
    while(*pF != NULL)
    {
        (*pF)();
        ++iLength;
        pF = (Fun*)(pVT + iLength);
    }
}
void PrintMembers(A *pA)
{
    int *p = (int*)(pA);
    int i = 1;
    while(i <= 3)
    {
        cout << *(p+i) << endl;
        i++;
    }
}
void TestVT()
{
    A *pA = new C();
    C *pC = dynamic_cast<C*>(pA);
    pC->x = 10;
    pC->y = 20;
    pC->z = 30;
    PrintVTable(pA);
    PrintMembers(pA);
    delete pA;
}

6）验证代码运行结果：

7）总结：

单继承的对象的布局，第一个为虚函数表指针vtbl，其后为成员且先基类后子类，虚函数表里包含了所有的虚函数的地址，以NULL结束。虚函数如果子类有重写，就由子类的重新的代替。

二 单继承运行时类型转化

1）代码验证：

Code
void TestDynamicCast()
{
    A *pA = new C();
    cout << "A:" << pA << endl;
    B *pB = dynamic_cast<B*>(pA);
    cout << "B:" << pB << endl;
    C *pC = dynamic_cast<C*>(pA);
    cout << "C:" << pC << endl;
}

2）验证代码运行结果：

3）总结：

我们上面看了单继承的内存布局，而这样的内存布局也就决定了当dynamic_cast的时候，都还是同一地址，不需要做指针的移动。只是类型的改变即所能访问的范围的改变。

三 完！

                                     七 多继承与虚函数表

一 多重继承

1) 代码：

Code
#include <iostream>
using namespace std;

class B1
{
public:
    int x;
    virtual void v1(){ cout << "B1::v1" << endl; }
    void f1(){cout << "B1::f1" << endl; }
};

class B2
{
public:
    int y;
    virtual void v2(){ cout << "B2::v2" << endl; }
    void f2(){ cout << "B2::f2" << endl; }
};

class B3
{
public:
    int z;
    virtual void v3(){ cout << "B3::v3" << endl; }
    void f3(){ cout << "B3::f3" << endl; }
};

class D : public B1, public B2, public B3
{
public:
    int a;
    void v3(){ cout << "D::v3" << endl; }
    virtual void vD(){ cout << "D::vD" << endl; }
};

2）类图：

3）VS2008的编译选项查看布局：

4）可视化表示：

5）代码验证：

Code
typedef void (*Fun)();

void PrintMember(int *pI)
{
    cout << *pI << endl;
}
void PrintVT(int *pVT)
{
    while(*pVT != NULL)
    {
        (*(Fun*)(pVT))();
        pVT++;
    }
}

void PrintVTAndMember(B1 *pD)
{
    int *pRoot = (int*)pD;
    int *pVTB1 = (int*)*(pRoot + 0);PrintVT(pVTB1);
    int *pMB1 = pRoot +1; PrintMember(pMB1);
    int *pVTB2 = (int*)*(pRoot + 2);PrintVT(pVTB2);
    int *pMB2 = pRoot +3; PrintMember(pMB2);
    int *pVTB3 = (int*)*(pRoot + 4);PrintVT(pVTB3);
    int *pMB3 = pRoot +5; PrintMember(pMB3);
}

void TestVT()
{
    B1 *pB1 = new D();
    D *pD = dynamic_cast<D*>(pB1);
    pD->x = 10;
    pD->y = 20;
    pD->z = 30;
    pD->a = 40;
    PrintVTAndMember(pD);
    delete pD;
}

6) 验证代码运行结果：

7）总结：

与单继承相同的是所有的虚函数都包含在虚函数表中，所不同的多重继承有多个虚函数表，当子类对父类的虚函数有重写时，子类的函数覆盖父类的函数在对应的虚函数位置，当子类有新的虚函数时，这些虚函数被加在第一个虚函数表的后面。

二 多重继承运行时类型转化

1）代码验证：

Code
void TestDynamicCast()
{
    B1 *pB1 = new D();
    cout << "B1:" << pB1 << endl;
    D *pD = dynamic_cast<D*>(pB1);
    cout << "D:"<< pD << endl;
    B2 *pB2 = dynamic_cast<B2*>(pB1);
    cout << "B2:" << pB2 << endl;
    B3 *pB3 = dynamic_cast<B3*>(pB1);
    cout << "B3:" << pB3 << endl;
    delete pD;
}

2）验证代码的运行结果：

3）总结：

从多重继承的内存布局，我们可以看到子类新加入的虚函数被加到了第一个基类的虚函数表，所以当dynamic_cast的时候，子类和第一个基类的地址相同，不需要移动指针，但是当dynamic_cast到其他的父类的时候，需要做相应的指针的移动。

三 完！

感谢，Thanks！

                                         八 虚继承与虚函数表

一 虚继承

1) 代码：

Code
#include <iostream>
using namespace std;

class B
{
public:
    int i;
    virtual void vB(){ cout << "B::vB" << endl; }
    void fB(){ cout << "B::fB" << endl;}
};

class D1 : virtual public B
{
public:
    int x;
    virtual void vD1(){ cout << "D1::vD1" << endl; }
    void fD1(){ cout << "D1::fD1" << endl;}
};

class D2 : virtual public B
{
public:
    int y;
    void vB(){ cout << "D2::vB" << endl;}
    virtual void vD2(){ cout << "D2::vD2" << endl;}
    void fD2(){ cout << "D2::fD2" << endl;}
};

class GD :  public D1, public D2
{
public:
    int a;
    void vB(){ cout << "GD::vB" << endl;}
    void vD1(){cout << "GD::vD1" << endl;}
    virtual void vGD(){cout << "GD::vGD" << endl;}
    void fGD(){cout << "GD::fGD" << endl;}
};

2）类图：

3）VS2008的编译选项查看布局：

4）可视化表示：

5）代码验证：（此时的虚函数表不是以NULL结尾，为什么？）

Code
typedef void (*Fun)();

void PrintMember(int *pI)
{
    cout << *pI << endl << endl;
}
void PrintVT(int *pVT)
{
    while(*pVT != NULL)
    {
        (*(Fun*)(pVT))();
        pVT++;
    }
}

void PrintMemberAndVT(GD *pGD)
{
    int *pRoot = (int*)pGD;

    int *pD1VT = (int*)*(pRoot + 0); 
    (*(Fun*)(pD1VT))(); (*(Fun*)(pD1VT +1))();
    int *pVB = (int*)*(pRoot +1);  cout << "vbtable's adress:" << *pVB << endl;
    int *pX = (pRoot + 2); PrintMember(pX);

    int *pD2VT = (int*)*(pRoot + 3); 
    (*(Fun*)(pD2VT))();
    int *pVB2 = (int*)*(pRoot +4); cout << "vbtable's adress:" << *pVB2 << endl;
    int *pY = (pRoot + 5); PrintMember(pY);

    int *pA = (pRoot + 6); PrintMember(pA);

    int *pBVT = (int*)*(pRoot + 7); 
    (*(Fun*)(pBVT))();
    int *pI = (pRoot + 8); PrintMember(pI);
}

void TestVT()
{
    B *pB = new GD();
    GD *pGD = dynamic_cast<GD*>(pB);
    pGD->i = 10;
    pGD->x = 20;
    pGD->y = 30;
    pGD->a = 40;
    PrintMemberAndVT(pGD);
    delete pGD;
}

6）验证代码结果：

7）总结：

虚继承，使公共的基类在子类中只有一份，我们看到虚继承在多重继承的基础上多了vbtable来存储到公共基类的偏移。

二 虚继承运行时类型转化

1）代码验证：

Code
void TestDynamicCast()
{
    B *pB = new GD();
    GD *pGD = dynamic_cast<GD*>(pB);
    cout << "GD:" << pGD << endl;
    D1 *pD1 = dynamic_cast<D1*>(pB);
    cout << "D1:" << pD1 << endl;
    D2 *pD2 = dynamic_cast<D2*>(pB);
    cout << "D2:" << pD2 << endl;
    cout << "B:" << pB << endl;
}

2）验证代码结果：

3）总结：

还是从内存布局来看dynamic_cast时地址的变化，第一个基类的地址与子类相同，其他的基类和虚基类需要做偏移。

三 完！

感谢，Thanks！

                                      九 类型转换

一 typeid与dynamic_cast

1）RTTI, Runtime Type Identification (RTTI) or Run-time type information (RTTI)，表示在运行时动态决定变量的类型，来调用正确的虚函数。 RTTI在VS2008中默认为关闭，可以通过修改编译选项Enable Run-Time Type Info 为 Yes，来启用RTTI，只有当启动RTTI时，用来RTTI功能的typeid和dynamic_cast才能正常工作。

2）type_info，用来描述类型信息。type_info存储了它所描述的类型的名字。RTTI就是使用type_info来实现的。type_info的定义如下：

Code
class type_info {
public:
  virtual ~type_info();
  bool operator== (const type_info& rhs) const;
  bool operator!= (const type_info& rhs) const;
  bool before (const type_info& rhs) const;
  const char* name() const;
private:
  type_info (const type_info& rhs);
  type_info& operator= (const type_info& rhs);
};

问题：RTTI怎么实现那？对象，type_info，虚函数怎么关联那？《深入C++对象模型》中说在虚函数表的开始存储了类型信息，但是实际的VS2008中好像并没有此信息，请高人指点哦！

3）typeid，在运行时获得对象的类型，typeid()返回的是const type_info&，而 type_info包含了对象真实类型的名字。typeid能被用来获取一个引用对象或指针指向的对象的运行时的真实类型。当然如果对象为null或编译 时没有使用/GR的话，typeid的会抛出异常bad_typeid exception或__non_rtti_object。实例代码：

Code
class Base 
{
public:
    virtual void f(){ }
};
 
class Derived : public Base 
{ 
public:
    void f2() {}
}; 

void main ()
{
    Base *pB = new Derived();
    const type_info& t = typeid(*pB);cout <<t.name() << endl;
    delete pB;

    Derived d;
    Base& b = d;
    cout << typeid(b).name() << endl;
}

运行结果：

4）dynamic_cast，用来运行时的类型转化，需要/GR来正确运行。
适用：
第一，用于所有的父子和兄弟间指针和引用的转化，有类型安全检查； 
第二，对指针类型，如果不成功，返回NULL，对引用类型，如果不成功，则抛出异常； 
第三，类型必须要有虚函数，且打开/GR编译选项，否则不能使用dynamic_cast。
实例代码：

Code
class AA 
{
public:
    virtual void do_sth(){ std::cout<<"AA"n"; }
};
class BB 
{
public:
    virtual void do_sth(){ std::cout<<"BB"n"; }
};
class CC : public AA, public BB
{
public:
    virtual void do_sth(){ std::cout<<"CC"n"; } 
};

void DynamicCastTest()
{
    AA *pA = new CC;
    BB *pB = dynamic_cast<BB*>(pA);
    if(pB != NULL)
        cout << "cast successful!" << endl;
    CC *pC = dynamic_cast<CC*>(pA);
    if(pC != NULL)
     cout << "cast successful!" << endl;
}

二 其他cast

1）隐式转化，不需要任何操作符，转化被自动执行，当一个值被赋值到它所兼容的类型时。
适用：
第一，内置基本类型的兼容转化；
第二， 子类指针，引用向父类的转化；

实例：

Code
class A
{
public:
    virtual ~A(){}
};
class B : public A
{
};

void ImplicitCast()
{
    short a = 2000;
    int b;
    b = a;

    double d = 10.05;
    int i;
    i = d;

    int j = 75;
    char c;
    c = j;

    A* pA = new B();
}

2）强制类型转化，即我们常说的C风格的类型转化，基本上可以用于所有的转化，但是没有意义的转化除外，但是父子类，兄弟间的转化没有类型检查可能导致运行是错误。
适用：
第一，基本类型转化；
第二，void*到其他指针的转化；
第三，去除const；
第五，函数指针的转化；
第六，父子类转化，但是多重继承和兄弟转化，可能有运行时错误，没有类型检查；
第七，任何两个类，但是没有实际意义，运行可能出错；
第八，不能用于没有意义的转化，严厉禁止，例如，你不能用static_cast象用C风格的类型转换一样把struct转换成int类型，或者把double类型转换成指针类型；
第九，在C++一般更推荐新加的static_cast，const_cast，dynamic_cast和reinterpret_cast转化方式；

实例：

Code
class CDummy 
{
public:
    CDummy(float x, float y)
    {
        i = x;
        j = y;
    }
private:
    float i,j;
};

class CAddition 
{
public:
    CAddition (int a, int b) { x=a; y=b; }
    int result() { return x+y;}
private:
    int x,y;
};

int Testing()
{
    std::cout << "Testing" << std::endl;
    return 10;
}

void ExplicitCast()
{
    double r = (double)1 / 3;

    int *pi = new int(10);
    void *pV;
    pV = pi;
    int *pj = (int*)pV; // 或 int *pj = int*(pV);

    const int* pa = new int(20);
    int *pb;
    pb = (int*)pa;
    *pb = 30;
    std::cout << *pa << std::endl;

    typedef void (*Fun)();

    Fun f = (Fun)Testing;
    f();

    // 多重继承或将兄弟间的转化可能会出错

    // 虽然可以正确的编译，但是运行有问题，所以我们不做没有意义的转化
    //CDummy d(10,30);
    //CAddition * padd;
    //padd = (CAddition*) &d;
    //std::cout << padd->result();

    // 不做没有意义的转化
    //// error
    //struct st{int i; double d;};
    //st s;
    //int x = (int)s; //c2440

    //double y = 10.0;
    //int *p = (int*)y; // c2440
}

3）static_cast在功能上基本上与C风格的类型转换一样强大，含义也一样。
它也有功能上限制：
第一，不能兄弟间转化，父子间转化没有类型安全检查，有可能会导致运行时错误，父子兄弟的动态转化应该适用dynamic_cast；
第二，不能去除const，适用专用的const_cast；
第三，不能用于两个没有继承关系的类，当然实际上这样的转化也是没有意义的；
第四，当然也不支持没有意义的转化，例如，你不能用static_cast象用C风格的类型转换一样把struct转换成int类型，或者把double类型转换成指针类型；

4）const_cast，用来修改类型的const或volatile属性。

适用：
第一，常量指针被转化成非常量指针，并且仍然指向原来的对象；
第二，常量引用被转换成非常量引用，并且仍然指向原来的对象；
第三，常量对象被转换成非常量对象；

实例：

Code
void ConstCastTest()
{
    const int* pa = new int(20);
    int *pb;
    pb = const_cast<int*>(pa);
    *pb = 30;
    std::cout << *pa << std::endl;
}

5）reinterpret_cast，此转型操作符的结果取决于编译器，用于修改操作数类型，非类型安全的转换符。
适用：
一般不推荐使用，但是一般用来对函数指针的转化。
实例：

Code
// 不可以移植，不推荐使用
int ReinterpretTest()
{
    struct dat { short a; short b;};
    long value = 0x00100020;
    dat * pd = reinterpret_cast<dat *> (&value);
    std::cout << pd->a << std::endl; // 0x0020
    std::cout << pd->b << std::endl; // 0x0010
    return 0;
}

typedef void (*Fun)();

int Testing()
{
    std::cout << "Testing" << std::endl;
    return 10;
}

void ReinterpretTest2()
{
    //Fun f = (Fun)Testing;
    //f();
    Fun f = reinterpret_cast<Fun>(Testing);
    f();
}

三 总结

在C++一般更推荐新加的static_cast，const_cast，dynamic_cast和reinterpret_cast转化方式；

感谢，Thanks！