创建时刻

程序代码

可执行文件

内存

备注

编译时刻

已初始化的全局变量，静态变量

.data段

全局区（初始化）

可读，可写

未初始化的全局变量，静态变量

.bss段

全局区（未初始化）

可读，可写

文字常量

.rdata段

文字常量区

只读

全局符号常量

.rdata段

文字常量区

只读

运行时刻

局部自动变量，符号常量

栈区

属于线程

New操作符分配的变量，常量

堆区

属于进程

Int a = 10;//10为整型文字常量。在编译时，数值类型文字常量被当作立即数处理。从汇编指令中可以看到这个情况

int a = 10;

001F153D  mov         dword ptr [ebp-14h],A  //10被当立即数处理。直接出现在指令中

Double pi = 3.1415;//3.1415为浮点型文字常量。

Char b = ‘a’；//a为字符型文字常量。在初始化的时候，从文字常量区将a拷贝到变量b所在的内存地址处。

Char* strName = “wolf”；//wolf为字符串型文字常量。指针strName指向文字常量区中字符串wolf的首地址。

Char[] arrName = “wolf”;//wolf为字符串型文字常量。数组初始化的时候，从文字常量区将wolf拷贝到数组所在的地址中。如果arrName在局部定义，那么就拷贝到栈中，如果在全局作用域定义，那么就拷贝到内存的全局区。

//wolf在文字常量区只有一份拷贝。

Const常量的数据类型 符号常量名 = 文字常量;

举例：

Const double PI = 3.14;//定义double类型的符号常量。PI是符号常量，3.14是文字常量

Const char* strName = “wolf”;

#define 符号常量名文字常量。

#define PI 3.14   //定义符号常量PI，从这个语句中区分不出数据类型。

#define strName“wolf”

----------------------------------------------A.h-------------------------------------------------------

Extern const int fa;//声明符号常量。该符号常量具有全局作用域

--------------------------------A.cpp---------------------------------------

#include"A.h"

constint fa = 3;//定义符号常量。

--------------------------------------------main.cpp-------------------------------------------------

#include<iostream>

#include"A.h"//在main.cpp文件中，只知道符号常量fa的声明，不知道它的定义

usingnamespace std;

int main()

{

constint a = 10;//定义局部常量。在栈中为该符号常量分配了内存。

int b = a + 2;//符号常量定义可见，在编译时刻执行了常量折叠。

int c = fa + 2;//符号常量不可见，没有执行常量折叠。

constint * pa = &a;//执行取常量地址操作。该符号常量的常量性由编译器在编译阶段保证。

*(const_cast<int*>(pa)) = 100;//取消指针的常量性，改变常量的值。可以这么干，完全没有问题

//也可以采用下面的方式更改常量的值。

//int* c = (int*)pa;

//*c = 100;

cout << *pa <<endl;

cout << a <<endl;//符号常量定义可见，在编译时刻执行了常量折叠。

cout << b <<endl;

int k;

cin >> k;

}

----------------------------------------汇编代码------------------------------------

const int a = 10;

002C13EE  mov         dword ptr [a],0Ah     //在栈中为a分配了内存，并将10存储在该内存处

int b = a + 2;//符号常量定义可见，在编译时刻执行了常量折叠，已经计算出10+2的值。因此下面汇编代码中，只给出了立即数0Ch，也就是十进制的数值12。

002C13F5  mov         dword ptr [b],0Ch

int c = fa + 2;//没有进行常量折叠，只能在运行时计算结果。

002C13FC  mov         eax,dword ptr [a (2C5800h)]

002C1401  add         eax,2

002C1404  mov         dword ptr [c],eax

//在现实中，一般很少出现定义了符号常量，然后又改变其值的蛋疼操作。这里只是说明问题而已。将常量值的改变与常量折叠进行对比，更能深入理解常量折叠这个操作。

------------------------------A.h------------------------------------

Const double PI = 3.14;//定义符号常量，虽然该符号常量被定义在全局作用域中，但它默认只具有文件作用域。在其他文件中是无法访问该符号常量的。

----------------------------B.cpp------------------------------------

#include “A.h”//引入头文件，在编译阶段，头文件A.h和源文件B.cpp被合并为一个文件，在头文件A.h中定义的符号常量PI，相当于在新合并后的源文件中被定义。

Double GetMJ(double r)

{

Return r * r * PI;//使用常量，因为符号常量的定义在当前文件可见，所以编译器用3.14替换符号常量PI。具体的代码就变成了“return r*r*3.14;”。这个替换的过程叫常量折叠。

}

----------------------------C.cpp------------------------------------------

#include “A.h”//引入头文件，相当于在C.cpp源文件中又定义了一次符号常量PI。但是符号常量默认具有文件作用域，B.cpp源文件中的符号常量PI与C.cpp源文件中的PI互不影响。

Double GetZC(double r)

{

Return 2 * PI * r;//编译时执行常量折叠。

}

-----------------------------------A.h----------------------------------

externconstint a;//在全局作用域中声明符号常量，使用了关键字extern，所以该符号常量具有全局作用域

-------------------------A.cpp------------------------

#include"A.h"

constint a = 10;//在此处定义符号常量，并初始化其值为10.编译器为该符号常量分配内存。

------------------------main.cpp------------------------

#include<iostream>

usingnamespace std;

#include"A.h"//引用了头文件，相当于声明了一次符号常量，符号常量的真正定义在A.cpp中。Main.cpp不知道该符号常量的定义。

int main()

{

int b = 5 * a;//这里没有进行常量折叠。在运行时，从符号常量a的内存地址处取得其值。具体情况见汇编代码。

Int c = 5*10;

cout << a <<endl;

cout << b <<endl;

int k;

cin >> k;

}

--------------------------汇编代码--------------------------

int b = 5 * a;

0104360E  mov         eax,dword ptr [a (1045800h)]      //将a值从内存地址1045800h出取出，放到eax中。

01043613  imul        eax,eax,5                        //执行乘法操作。如果执行常量折叠的话，这里根本不会执行乘法操作。

01043616  mov         dword ptr [b],eax               //将乘法结果放到b中。

int c = 5*10;

00AF3619  mov         dword ptr [c],32h               // 编译阶段已经计算完毕，这里直接给出立即数

---------------------------------------A.h---------------------------------------

#ifndef _MyClass_H

#define _MyClass_H

class MyClass

{

public:

MyClass(int Para);

private:

constint m_conVal;//定义常量

};

#endif

--------------------------------A.cpp------------------------------

#include"B.h"

MyClass::MyClass(int Para):m_conVal(Para)//初始化常量

{

}

Class myClass

{

Enum { size1 = 100,size2 = 200,size3 = 300};

Int arr1[size1];

Int arr2[size2];

};

---------------------------------main.cpp------------------------------------------

#include<iostream>

usingnamespace std;

int main()

{

constint a = 10;

int b = 10;

int c = a * 5;

int d = b * 5;

int k;

cin >> k;

}

-----------------------------------汇编代码-------------------------------------

00D713EC  rep stos    dword ptr es:[edi]

const int a = 10;  //为a分配了内存

00D713EE  mov         dword ptr [a],0Ah

int b = 10;       //为b分配了内存

00D713F5  mov         dword ptr [b],0Ah

int c = a * 5;    //执行了常量折叠，汇编代码中只给出了立即数32h，也就是十进制的50

00D713FC  mov         dword ptr [c],32h

int d = b * 5;  //对于变量，执行了计算操作。

00D71403  mov         eax,dword ptr [b]

00D71406  imul        eax,eax,5

00D71409  mov         dword ptr [d],eax