前言

了解C++程序内存分配，有助于深刻理解变量的初始化值以及其生存周期。另外，变量类型修饰符也会影响到变量的初始化值及其生存周期。掌握了不同类型变量的初始化值及其生存周期，能够让我们设计程序时定义变量时更准确。

内存分配

1.     C++程序的内存布局

现代电脑都是遵循冯诺依曼体系结构，所以C++程序的内存布局也是遵循该体系的。主要包括5个部分，即代码段、数据段、BSS段、堆和栈、。

1.     代码段

代码段（code segment/text segment），通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。另外关于字符串常量存储的位置，也与编译器有一定的关系，也有可能放在数据段。

2.     数据段

数据段（data segment），通常是指用来存放程序中已初始化的全局变量/静态变量的一块内存区域。数据段属于静态内存分配。

3.     BSS段

BSS段（BSS segment），通常是指用来存放程序中未初始化的全局变量/静态变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。

4.     堆

堆（Heap），是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc/new等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free/delete等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）。

5.     栈

栈（stack），栈也称堆栈，是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进后出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。压栈出栈，后压入栈的处在栈顶，所以最先出栈。也即后进先出（last-in，first-out，LIFO）。

2.     变量内存存储

按申请内存的方式不同，主要分为静态存储区和动态存储区。

1.     静态存储区

静态存储区内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。静态存储区主要包括只读存储区、已经初始化的全局变量/静态变量存储区和未初始化的全局变量/静态变量存储区。

2.     动态存储区

动态存储区内存是在程序运行的时候，根据需要动态分配的。动态存储区主要包括堆和栈。

int g_idx = 10;   // 已初始化的全局变量

int* g_pArr;       // 未初始化的全局变量,其默认值为0

int _tmain(int argc, _TCHAR* argv[])

{

    // nCnt存储在栈区

    int nCnt = 100;

    // pPath存储在栈上,"c:\work"是字符串常量存放在常量区

    // pPath指向这个字符串常量,所以不能修改pPath指向的内容

    char* pPath = "c:\work";

    // 00411475  mov   dword ptr [pPath],offset string "c:\work" (415754h)

    // 已经初始化的静态变量

    static int nCurCnt = 1;

    // pCnt存储在栈上,但pCnt指向的内存是在堆上分配的个int

    char* pNewPath = new char[10];

    memset(pNewPath, 0, 10);

    // 通过上下两段汇编代码可以看出,"c:\work"被编译器优化成了同一个常量

    strcpy_s(pNewPath, 10, "c:\work");

    //  004114A5  mov         esi,esp

    //  004114A7  push        offset string "c:\work" (415754h)

    delete[] pNewPath;

    pNewPath = NULL;

    return 0;

}

变量类型修饰符

1.     const

概念：指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能更新的。

语法形式：

限定非指针类型：下面两种形式作用一样，即变量为常量，不能修改。

int const MAX_DEVICE_CNT = 32;

const int MIN_DEVICE_CNT = 16;

限定指针类型：靠近谁就限定谁，可以理解为就近原则。

int nValue = 10;

const int* pPtr =& nValue;  // 限定pPtr指向的值，但不限定pPtr本身

int* const pValue =& nValue;    // 限定pValue本身,但不限定pValue指针的值

const int* const pV= &nValue;   // 指针和值都限定

初始化：

                         i.              类的成员变量，初始化必须在构造函数初始化列表中完成。

                       ii.              其他情况，声明必须和定义在一起，即声明的同时进行定义。

作用域：

                      iii.              在函数体{}内，作用域为局部作用域。

                      iv.              作为类成员变量，作用域即为当前类。

                       v.              和static一起声明在类声明中，作用域为全局，通过类名访问。

                      vi.              在类/函数体外，作用域为文件作用域，即只能被当前文件所使用。

                    vii.              和static组合时，作用域不变，依然为文件作用域。

                   viii.              和extern组合时，那么此变量的作用域改变为全局的。

const extern int MIN_DEVICE_CNT = 16; // 声明定义

extern const int MIN_DEVICE_CNT = 16; // 声明定义

const extern int MIN_DEVICE_CNT;   // 外部文件使用时声明

extern const int MIN_DEVICE_CNT; // 外部文件使用时声明

注：当前两个变量的访问形式相同，且作用域重叠，链接时，会报重复定义的错误。如果当前常量只想在当前文件内使用，请定义申明在当前CPP文件最前面。如果只想在当前类中使用，可以定义在类声明中。

2.     static

概念：改变声明变量的生存周期为全局。

语法形式：Static不能和extern共用，且与const，类型(int等)可以随意位置。

const static int MIN_DEVICE_CNT;

static const int MIN_DEVICE_CNT;

int const static MIN_DEVICE_CNT;

初始化：全局变量/静态变量都存在静态存储区，指明初始化值和未指明初始化值都是可以的。如果未指明初始化值其默认值为0.

static int MIN_DEVICE_CNT = 16; // 初始化值为16

static int MIN_DEVICE_CNT;      // 未初始化，默认内存值0

作用域：

                      ix.              在函数体{}内，作用域为局部作用域，只能为当前{}访问，但是生存期却为全局的，第2次访问时，不会再初始化，而是记住上次的值。

                       x.              作为类成员变量，作用域为全局，但是必须通过类名访问。

                      xi.              在类/函数体外，作用域为文件作用域，即只能被当前文件所使用。

注：如果1个变量只想在当前文件内使用，最好定义在CPP文件中。如果定义在头文件里，那么包含此头文件的CPP文件都会生成一个当前文件作用域的同名变量，不仅容易引起歧义，也浪费空间。

3.     extern

概念：声明当前变量已经在外部文件有定义。

语法形式： extern不能和static共用，且与const，类型(int等)可以随意位置。定义时加与不加extern均可，但声明的时候必须添加，否则会造成作用域重叠链接错误。另外extern与const的组合使用，见const条款。

int MAX_DEVICE_CNT = 32;        // 文件A.cpp中的声明定义

extern int MAX_DEVICE_CNT = 32; // 文件A.cpp中的声明定义

extern int MAX_DEVICE_CNT;     // 文件B.cpp中的声明定义

初始化：必须先有定义，也即需要初始化值，然后才能外部声明。

作用域：改变const的作用域，将const的文件作用域改为全局作用域。

注：全局数组变量的外部声明不能声明成指针，必须声明为数组类型。如：

int nArr[4] ={1, 2, 3, 4}; // 文件A.cpp中的声明定义

extern int nArr[4]   ;       // ok: 文件B.cpp中的声明定义

extern int nArr[];           // ok: 文件B.cpp中的声明定义

4.     volatile

概念：告诉编译器限定的变量是易变的，不能被优化。

语法形式：volatile在语法形式上基本和const一样，可以和extern、const、static一起共用。在限定指针时，也分限定指针本身和指针指向的值。

       int* volatile vip; // vip is a volatile pointer to int

volatile int* ivp; // ivp is a pointer to volatile int

volatile int* volatile ivp; // ivp is a volatile pointer to volatile int

初始化：volatile限定不能被去掉，也即用取地址时也必须限定指针指向的值为volatile,否则编译错误。指针的取地址同样.

volatile int nValue = 4;

int* pInt =& nValue;             // error:不能更改nValue的volatile属性

volatile int* pValue = &nValue; // ok:限定pValue指向的值,即没有改变nValue

作用域：不改变作用域。

注：什么时候使用volatile呢？这需要弄明白，什么时候不用volatile会出错。如：

void Square(int* pValue)

{

          int nA = (*pValue);

// 004114FE  mov         eax,dword ptr [pValue]

// 00411501  mov         ecx,dword ptr [eax]

// 00411503  mov         dword ptr [nA],ecx

          int nB = (*pValue);

// 00411506  mov         eax,dword ptr [pValue]

// 00411509  mov         ecx,dword ptr [eax]

// 0041150B  mov         dword ptr [nB],ecx

 }

上面这是未优化的代码，分别从指向的内存取值。如果是优化过的代码，那么第二次取值就可能直接从寄存器中取值了，而不会再从内存里去取值了。如果在两次赋值之间，另外一个线程更改了pValue指向的值的时候，nB如果依然从寄存器中取值，实际上取得的是错误的值。这个时候，就需要限定pValue指向的值了。需要volatile int* pValue作为参数。这样，无论是nA，还是nB取得的值都真实的。所以，当有多个线程改变同一个变量时，这个变量就需要考虑使用volatile限定了。当然不加volatile也并不能保证当前线程里多次访问全局变量的值不被其他线程改变，要达到这样的效果，需要使用Critical Section、Mutex等线程锁手段来解决。

最后

以上就是小巧玫瑰为你收集整理的C++变量内存分配及类型修饰符前言内存分配变量类型修饰符的全部内容，希望文章能够帮你解决C++变量内存分配及类型修饰符前言内存分配变量类型修饰符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。