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

转载自： http://guoshan.blogchina.com/blog/4460907.html

关键词： 强制类型转换                                          

*   C++ 提供了四种新的类型强制：

static_cast
const_cast
reinterpret_cast
dynamic_cast

1)staic_cast 静态强制；

不能在无关的指针之间进行 static 类型强制
class   CAnimal
{
//...
public:
CAnimal(){}
};

class   CGiraffe:public   CAnimal
{
//...
public:
CGiraffe(){}
};

int   main(void)
{
CAnimal   an;
CGiraffe   jean;

an   =   static_cast(jean);// 将对象 jean 强制成 CAnimal 类型
return   0;
}

2 、 const_cast 类型强制

const_cast 类型强制将一个 const 变量变成一个非 const 的等价形式
int   main()
{
const   int   j   =   99;
int   *   k;

k   =   const_cast(&j);// 解除 const
return   0;
}

3 、 reinterpret_cast 运算符

reinterpret_cast 运算符用来将一个类型指针转变为另一种类型的指针，也用在将整开型量转为指针，或将指针转为整型量上；
int   main()
{
int   j   =   10;
int   *   ptr   =   &j;
char   *   cptr;

cptr   =   reinterpret_cast(ptr);// 将 int 指针类型转变为 char 的指针类型

return   0;
}

4 、 dynamic_cast 运算符

dynamic_cast 的主要目的是：

1 ）它返回派生类对象的地址；
2 ）它测试基类指针是否指向下一尖括号 <> 中所指定类型的对象

dynamic_cast 是一个运行时类型信息， dynamic_cast 运算符将指向派生对象的基类部分的基类指针转变为指向派生对象的派生类指针， dynamic_cast 必须严格地指定与派生对象相同的类，或者它返回 NULL 指针 ;
class   CAnimal
{
//...
};
class   CGiraffe:public   CAnimal
{
//...
};
class   CGoat:public   CAnimal
{
//...
};

int   main()
{
CGiraffe   gene;
CAnimal   *   aptr   =   &gene;
CGiraffe   *   ptr1,*   ptr2;

ptr1   =   dynamic_cast(aptr);
ptr2   =   dynamic_cast(aptr); //return   NULL

return   0;
}

C++   里最好杜绝使用   C   方式的强制转换 ,   换用以上   4   个 .
我们通常用的是   static_cast
在一类东西都可以转 ,   但是不是一类的就不能转 .
即 ,   语义上说不通的 ,   两个完全不同的数据类型   static_cast
是拒绝工作的 .    
比如你想把一个指针转成浮点数 ,
或者想把   class   A   *   转成     class   B   *   ,   但是   class   A   和   class   B
又没有任何关系 .   等等 ....

static_cast   在通过编译后 ,   空间和时间效率实际等价于   C   方式强制转换 .
都是编译时决定的 .

dynamic_cast   类似   static_cast,   但是在一颗类继承树上转换时 ,
将利用   RTTI   在运行时检查 .   我们一般用于   downcast

比如 ,
class   A   {};
class   B   :   public   A   {};

A*   a=new   B();

这个时候 ,   可以用   dynamic_cast   做   downcast,   把   a   转成   B*.
和   static_cast   不同 ,   dynamic_cast   会检查一下   a   到底是不是指向一个
B,   ( 利用了   RTTI)   如果转不了 ,   将返回一个   NULL.

reinterpret_cast   就比   static_cast   更接近   C   的强制转换了 .
它更进一步的 ,   实现一些看起来没关系的两种类型转换 .
比如我习惯干的 ,   把一个   void   *     转成   unsigned   ;)
当然它比   static_cast   危险 .

但是有   reinterpret_cast   干不了的 ,
比如你在一个   const   成员函数里企图修改一个非   mutable   的成员变量 .
编译器会对你咆哮 ,   " 不许动 ,   那玩意是我   const   住的 ,   把你的爪子
收回去 "   这个时候就要利用   const_cast   了 ,   呵呵 .

const_cast   就是可以解除   const   限制的 " 神 " 的武器  
但我认为 ,   这在很多情况下比   reinterpret_cast   更危险 ,   我还是老实做
人的好 .   让编译器来捍卫我的代码的安全 .