当前位置：网站首页>大话内存四区

大话内存四区

2022-06-21 16:03:00 【打酱油的；】

1.内存分区

运行之前

我们要想执行我们编写的c程序，那么第一步需要对这个程序进行编译。

预处理：宏定义展开、头文件展开、条件编译，这里并不会检查语法
编译：检查语法，将预处理后文件编译生成汇编文件
汇编：将汇编文件生成目标文件(二进制文件)
链接：将目标文件链接为可执行程序

当我们编译完成生成可执行文件之后，我们通过在linux下size命令可以查看一个可执行二进制文件基本情况：

通过上图可以得知，在没有运行程序前，也就是说程序没有加载到内存前，可执行程序内部已经分好3段信息，分别为代码区（text）、数据区（data）和未初始化数据区（bss）3 个部分（有些人直接把data和bss合起来叫做静态区或全局区）。

1.代码区

存放 CPU 执行的机器指令。通常代码区是可共享的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指t令。另外，代码区还规划了局部变量的相关信息。

2.全局初始化数据区/静态数据区（data段）（静态，全局，常）

该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和常量数据（如字符串常量）。

3.未初始化数据区（又叫 bss 区）

存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空（NULL）。

总体来讲说，程序源代码被编译之后主要分成两种段：程序指令(代码区)和程序数据（数据区）。代码段属于程序指令，而数据域段和.bss段属于程序数据。

那为什么把程序的指令和程序数据分开呢？

程序被load到内存中之后，可以将数据和代码分别映射到两个内存区域。由于数据区域对进程来说是可读可写的，而指令区域对程序来讲说是只读的，所以分区之后呢，可以将程序指令区域和数据区域分别设置成可读可写或只读。这样可以防止程序的指令有意或者无意被修改；
当系统中运行着多个同样的程序的时候，这些程序执行的指令都是一样的，所以只需要内存中保存一份程序的指令就可以了，只是每一个程序运行中数据不一样而已，这样可以节省大量的内存。比如说之前的Windows Internet Explorer 7.0运行起来之后，它需要占用112 844KB的内存，它的私有部分数据有大概15 944KB，也就是说有96 900KB空间是共享的，如果程序中运行了几百个这样的进程，可以想象共享的方法可以节省大量的内存。

运行之后

程序在加载到内存前，代码区和全局区(data和bss)的大小就是固定的，程序运行期间不能改变。然后，运行可执行程序，操作系统把物理硬盘程序load(加载)到内存，除了根据可执行程序的信息分出代码区（text）、数据区（data）和未初始化数据区（bss）之外，还额外增加了栈区、堆区。

1.代码区（text segment）

加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。

2.未初始化数据区（BSS）

加载的是可执行文件BSS段，位置可以分开亦可以紧靠数据段，存储于数据段的数据（全局未初始化，静态未初始化数据）的生存周期为整个程序运行过程。

3.全局初始化数据区/静态数据区（data segment）

加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量(只读)）的数据的生存周期为整个程序运行过程。

4.栈区（stack）例如 int a=1；

栈是一种先进后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间。函数执行完局部变量就释放了。

5.堆区（heap）

堆是一个大容器，它的容量要远远大于栈，但没有栈那样先进后出的顺序。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

相关数据类型及其存储位置:

static和extern重点记忆

类型	作用域	生命周期	存储位置
auto变量	一对{}内	当前函数	栈区
static局部变量	一对{}内	整个程序运行期	初始化在data段，未初始化在BSS段
extern变量	整个程序	整个程序运行期	初始化在data段，未初始化在BSS段
static全局变量	当前文件	整个程序运行期	初始化在data段，未初始化在BSS段
extern函数	整个程序	整个程序运行期	代码区
static函数	当前文件	整个程序运行期	代码区
register变量	一对{}内	当前函数	运行时存储在CPU寄存器
字符串常量	当前文件	整个程序运行期	data段

2.分区模型

栈区

由系统进行内存的管理。主要存放函数的参数以及局部变量。在函数完成执行，系统自行释放栈区内存，不需要用户管理。

注意事项：不要返回局部变量地址，局部变量在函数体执行完毕后会被释放，再次操作就是非法操作，结果未知。

#char* func(){//不要返回局部变量地址，局部变量在函数体执行完毕后会被释放，再次操作就是非法操作，结果未知。

char p[] = "hello world!"; //在栈区存储乱码

printf("%s\n", p);

return p;

}

void test(){

char* p = NULL;

p = func();

printf("%s\n",p);

}

堆区

由编程人员手动申请，手动释放，若不手动释放，程序结束后由系统回收，生命周期是整个程序运行期间。使用malloc或者new进行堆的申请。

malloc申请free释放再将指针指向空，避免野指针

注意事项：主调函数中指针为空，被调函数用同级指针修饰不成功的，没有改变p本身的，函数会新开辟空间传递进去，要使用更高级指针改变其地址进行修饰。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int * getSpace()
{
int * p = malloc(sizeof(int)* 5);

   if (p == NULL)
   {
       return NULL;
   }

   for (int i = 0; i < 5;i++)
   {
       p[i] = i + 100;
   }
   return p;

}

void test01()
{
int * p = getSpace();

   for (int i = 0; i < 5;i++)
   {
       printf("%d\n", p[i]);
   }

   //手动在堆区创建的数据，记得手动释放
   free(p);
   p = NULL;

}

//注意事项
//如果主调函数中没有给指针分配内存，被调函数用同级指针是修饰不到主调函数中的指针的
void allocateSpace( char * pp )
{
   char * temp = malloc(100);
   if (temp == NULL)
   {
       return;
   }
   memset(temp, 0, 100);
   strcpy(temp, "hello world");
   pp = temp;

}

void test02()
{
char * p = NULL;
allocateSpace(p);

printf("%s\n", p);
}

void allocateSpace2(char ** pp)
{
   char * temp = malloc(100);
   memset(temp, 0, 100);
   strcpy(temp, "hello world");
   *pp = temp;
}

void test03()
{
char * p = NULL;

allocateSpace2(&p);

printf("%s\n", p);

free(p);
p = NULL;

}

int main(){
   //test01();
   //test02();
   test03();
   system("pause");
   return EXIT_SUCCESS;
}

堆分配内存API：

#include <stdlib.h>

void *calloc(size_t nmemb, size_t size);

功能：

在内存动态存储区中分配nmemb块长度为size字节的连续区域。calloc自动将分配的内存置0。

参数：

nmemb：所需内存单元数量

size：每个内存单元的大小（单位：字节）

返回值：

成功：分配空间的起始地址

失败：NULL

#include <stdlib.h>

void *realloc(void *ptr, size_t size);

功能：

重新分配用malloc或者calloc函数在堆中分配内存空间的大小。

realloc不会自动清理增加的内存，需要手动清理，如果指定的地址后面有连续的空间，那么就会在已有地址基础上增加内存，如果指定的地址后面没有空间，那么realloc会重新分配新的连续内存，把旧内存的值拷贝到新内存，同时释放旧内存。

参数：

ptr：为之前用malloc或者calloc分配的内存地址，如果此参数等于NULL，那么和realloc与malloc功能一致

size：为重新分配内存的大小, 单位：字节

返回值：

成功：新分配的堆内存地址

失败：NULL

示例代码：

void test01(){

int* p1 = calloc(10,sizeof(int));

if (p1 == NULL){

return;

}

for (int i = 0; i < 10; i ++){

p1[i] = i + 1;

}

for (int i = 0; i < 10; i++){

printf("%d ",p1[i]);

}

printf("\n");

free(p1);

}

void test02(){

int* p1 = calloc(10, sizeof(int));

if (p1 == NULL){

return;

}

for (int i = 0; i < 10; i++){

p1[i] = i + 1;

}

int* p2 = realloc(p1, 15 * sizeof(int));

if (p2 == NULL){

return;

}

printf("%d\n", p1);

printf("%d\n", p2);

//打印

for (int i = 0; i < 15; i++){

printf("%d ", p2[i]);

}

printf("\n");

//重新赋值

for (int i = 0; i < 15; i++){

p2[i] = i + 1;

}

//再次打印

for (int i = 0; i < 15; i++){

printf("%d ", p2[i]);

}

printf("\n");

free(p2);

}

全局/静态区（数据区）

全局静态区内的变量在编译阶段已经分配好内存空间并初始化。这块内存在程序运行期间一直存在,它主要存储全局变量、静态变量和常量。

静态：static

注意事项：

程序运行前分配内存
生命周期在文件运行前死亡
属于内部链接属性，在当前文件中使用（正常都是在当前文件使用）

全局变量：extern

注意事项：

默认全局变量加extern
属于外部链接属性，告诉编译器其他文件可以使用（无法解析的外部命令，链接阶段出错）

静态变量和全局变量

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

//1、静态变量
static int a = 10;//全局作用域

//特点：只初始化一次，在编译阶段就分配内存，属于内部链接属性，只能在当前文件中使用

void test01()
{
static int b = 20; //局部静态变量,作用域只能在当前test01中

//a 和 b的生命周期是一样的
}

//2、全局变量

extern int g_a = 100; //在C语言下全局变量前都隐藏加了关键字 extern，属于外部链接属性

void test02()
{
extern int g_b;//告诉编译器 g_b是外部链接属性变量，下面在使用这个变量时候不要报错

printf("g_b = %d\n", g_b);

}

int main(){
test02();

system("pause");
return EXIT_SUCCESS;
}

常量：

a. const修饰的常量

注意事项：

const修饰的全局变量,分配到常量区（只读）中 //直接/间接修改都失败
const修饰的局部变量 //分配到栈上，没有受到常量区保护（也称为伪常量）/直接修改失败的 //间接修改成功 //C语言下称为伪常量
//伪常量是不可以初始化数组的

const常量：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//1、const修饰的全局变量,即使语法通过，但是运行时候受到常量区的保护，运行失败
const int a = 10; //放在常量区
void test01()
{
   //a = 100; //直接/间接修改都失败
   int * p = &a;
   *p = 100;
   printf("%d\n", a);
}
//2、const修饰的局部变量
void test02()
{
   const int b = 10; //分配到栈上，没有受到常量区保护（也称为伪常量）
   //b = 100; //直接修改失败的

   //间接修改成功
   //C语言下称为伪常量
   int * p = &b;
   *p = 100;
   printf("b = %d\n", b);
   //int a[b];//伪常量是不可以初始化数组的
}

注意：

（1）这里不区分初始化和未初始化的数据区，是因为静态存储区内的变量若不显示初始化，则编译器会自动以默认的方式进行初始化，即静态存储区内不存在未初始化的变量。

（2）全局静态存储区内的常量分为常变量和字符串常量，一经初始化，不可修改。静态存储内的常变量是全局变量，与局部常变量不同，区别在于局部常变量存放于栈，实际可间接通过指针或者引用进行修改，而全局常变量存放于静态常量区则不可以间接修改。

（3）字符串常量存储在全局/静态存储区的常量区。

b.字符串常量

注意事项：

字符串常量存放在常量区，不允许修改字符串常量

对于不用编译器对于字符串常量优化不同

//3.字符串常量
void test03()
{
   char * p1 = "hello world";//三个都放在一个区
   char * p2 = "hello world";
   char * p3 = "hello world";
   printf("%d\n", p1);
   printf("%d\n", p2);
   printf("%d\n", p3);
   printf("%d\n", &"hello world");

   p1[0] = 'z'; //不允许修改字符串常量
   printf("%c\n", p1[0]);
}

int main(){
   //test01();
   //test02();
   test03();
   system("pause");
   return EXIT_SUCCESS;
}

加深理解：

char* func(){

static char arr[] = "hello world!"; //在静态区存储可读可写

arr[2] = 'c';

char* p = "hello world!"; //全局/静态区-字符串常量区

//p[2] = 'c'; //只读，不可修改

printf("%d\n",arr);

printf("%d\n",p);

printf("%s\n", arr);

return arr;

}

void test(){

char* p = func();

printf("%s\n",p);

}

字符串常量是否可修改？字符串常量优化：
ANSI C中规定：修改字符串常量，结果是未定义的。
ANSI C并没有规定编译器的实现者对字符串的处理，例如：
1.有些编译器可修改字符串常量，有些编译器则不可修改字符串常量。
2.有些编译器把多个相同的字符串常量看成一个（这种优化可能出现在字符串常量中，节省空间），有些则不进行此优化。如果进行优化，则可能导致修改一个字符串常量导致另外的字符串常量也发生变化，结果不可知。
所以尽量不要去修改字符串常量！
C99标准：
char *p = "abc"; defines p with type ‘‘pointer to char’’ and initializes it to point to an object with type ‘‘array of char’’ with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to modify the contents of the array, the behavior is undefined.
字符串常量地址是否相同？
tc2.0，同文件字符串常量地址不同。
Vs2013,字符串常量地址同文件和不同文件都相同。
Dev c++、QT同文件相同，不同文件不同。