C++ 常量区堆区栈区

本文主要是介绍C++ 常量区堆区栈区，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

C++中类的变量可以通过static、const、static const来修饰，不同的修饰在不同的情况下表示不同的含义。下面7少带大家一块详细解读一下他们的用处。

首先我们需要先了解程序运行期间的内存分区：

1.代码区：存放CPU指令码。

2.常量区：存放只读常量，该区只读，不可写。

3.静态区：存放静态变量。该区在程序编译完成后就决定了其大小，程序运行期间该区的大小不会变。该区可读写。

4.动态区：又分为堆区和栈区，程序运行期间其大小处于动态变化中。处于该区的变量也会时而被创建时而被销毁。

static关键字：

经过static修饰的变量会作为类的属性而不是实体属性存在。

static修饰的变量作为程序运行时的静态变量，存在于内存的静态区，静态区的数据初始化工作由操作系统在加载完程序后执行main函数前进行。操作系统在加载完程序后，将常量区中存放的变量初值复制给静态变量，完成其初始化。

static修饰的变量通过int ClassName::value=1这种方式进行初始化。此时不再需要static 关键字。程序运行期间也可以对变量进行赋值操作。

const关键字：

经过const修饰的属性，顾名思义是指常量。

const修饰的属性仍然属于实体属性，所以其初始化工作，需要由构造函数的初始化列表中完成。而且也只能在构造函数的初始化列表中初始化，运行期间将不能再对const属性进行修改。值得注意的是，虽然经过const修饰，但是因为变量属于实体属性，而实体对象存在于动态区，所以const属性也属于动态区，所以可以通过取址直接操作指向的内存的值，以绕过编译器对其只读的限制检查。

static const关键字：

static const 和 const static 含义相同。

static const有两种用法，一种是作为预编译声明，一种是作为类的静态常量属性。

当作为预编译声明时，static const 属性必须在声明时即指定值，而且类型仅限基本数据类型。用法如下：

class A

{

static const int a =1;

}

此时相当于C语言中的 #define a 1 宏定义了一个宏变量a，但是C++的这种方式比C的#define的优势在于，可以对类型进行检查和限制，减少了编译期间因为类型隐士转换而造成的潜在风险。

此时的 const static常量既不存在于动态区也不存在与静态区（应该是存在于常量区或代码区。。。），而是由编译器在编译期间就直接进行了值替换。也因为这个原因不可以对其进行取地址操作，因为他根本没有地址。

另一种用法是作为类的静态常量属性，此时，不能在类的声明处进行初始化。而需要通过 int ClassName::value = 1;的方式进行初始化赋值。

const static常量存在于内存的常量区，有操作系统加载程序时，加载到内存的常量区。所以可以对其取址，但是不能对该区的内存进行写操作，因为这个区从操作系统级进行了只读限定，任何对该内存区的写操作会导致程序崩溃。

总结：

static const 作为预编译声明使用时，相当于C的#define，但是需要编译器进行类型检查，保证了程序的健壮性。此时其只能用基本数据类型。

static const 作为类的常量属性，因为常量区是在程序真正执行代码前进行初始化，所以其也必须是基本数据类型。

static const 和const的区别是：

const声明的只读变量，在程序运行期间不能对其进行写操作，写操作将无法通过编译，也就是说它是通过编译器控制的只读，所以如果想下面这样：

A a;

int * pa = (int*)&a.a;

*pa = 2;

则可以绕过编译器修改他的值。

但是 static const属性虽然也可以取址，但是对其写操作将会导致程序崩溃。因为static const 存在于常量区，而const存在于动态区。

static const 和 static的区别是，static 存在于静态区，该区可以进行写操作，其初始化的值也会存在常量区，程序启动后由操作系统从常量区取值赋值给static变量。

最后，欢迎吐槽和讨论。

最后转两个例子：

第一个：

#include<iostream.h>

void main()
{
char a[]="abc";栈
char b[]="abc";栈
char* c="abc";abc在常量区，c在栈上。
char* d="abc"; 编译器可能会将它与c所指向的"abc"优化成一个地方。
const char e[]="abc";栈
const char f[]="abc";栈

cout << a << " " << b << " " << c << " " <<d << " " <<e << " " <<f <<endl;
cout<<(a==b?1:0)<<endl<<(c==d?1:0)<<endl<<(e==f?1:0)<<endl;
}
以上程序的输出结果为
abc abc abc abc abc abc
0
1
0

第二个：

//main.cpp

#include<iostream.h>
#include<string.h>
//#include<malloc.h> //malloc的头文件可以为#include<malloc.h>也可以为#include<stdlib.h>
#include<stdlib.h>
int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{

const char* m = "123456";
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"优化成一个地方。

cout<<(m == p3?1:0)<<endl;//结果为1
cout<<(p1 == p3?1:0)<<endl;//结果为0
cout<<p1<<" "<<p3<<" "<<endl;//结果为123456 123456
}