八、内存分区模型
8.1 作用域
| 类型 | 作用域 | 生命周期 | 存储位置 |
|---|---|---|---|
| auto变量 | 一对{}内 | 当前函数 | 栈区 |
| static局部变量 | 一对{}内 | 整个程序运行期 | 初始化在data段，未初始化在BSS段 |
| static全局变量 | 当前文件 | 整个程序运行期 | 初始化在data段，未初始化在BSS段 |
| extern变量 | 整个程序 | 整个程序运行期 | 初始化在data段，未初始化在BSS段 |
| extern函数 | 整个程序 | 整个程序运行期 | 代码区 |
| static函数 | 当前文件 | 整个程序运行期 | 代码区 |
| register变量 | 一对{}内 | 当前函数 | 运行时存储在CPU寄存器 |
| 字符串常量 | 当前文件 | 整个程序运行期 | data段 |
8.1.1 局部变量
局部变量也叫auto自动变量(auto可写可不写)，函数内部或者复合语句内部定义(例如for循环内部直接定义i)的变量都是自动变量，它有如下特点：
①作用域：函数内部或者复合语句内部；
②生命周期：局部变量随着函数调用的结束或复合语句的结束而结束(栈区)
③如果没有赋初值，内容为随机，VS会报错。
//printf("%d\n", a);//error，先定义后使用
auto int a = 10;// 函数内部定义的变量，auto可以省略
for (size_t i = 0; i < 2; i++){
printf("%d\n", a);
}
//printf("%d\n", i);//error,复合语句内部定义的变量
8.1.2 静态(static)局部变量
①作用域：函数内部；
②生命周期：从程序创建到程序销毁，存储在数据区；
③staitc局部变量的值只初始化一次，但可以赋值多次；
④static局部变量若未赋于初值，则由系统自动赋值：数值型变量自动赋初值0，字符型变量赋空字符。
#include<stdio.h>
static int a = 5;
void fun01(){
int a =1;
a++;
printf("%d ", a);
}
void fun02(){
static int a = 1;//只执行1次，在数据区存储
a++;
printf("%d ", a);
}
void fun03(){
static int a; //不赋值默认为0
a++;
printf("%d ", a);
}
void fun04(){
//printf("%d ", a++); //5
printf("%d\n", ++a); //6
}
int main(){
for (size_t i = 0; i < 5; i++) fun01(); //2 2 2 2 2
for (size_t i = 0; i < 5; i++) fun02(); //2 3 4 5 6
for (size_t i = 0; i < 5; i++) fun03(); //1 2 3 4 5
fun04();
return 0;
}
8.1.3 全局变量
①在函数外定义，可被本文件及其它文件中的函数所共用，若其它文件中的函数调用此变量，须用extern声明（存在数据区，因为栈区会销毁）；
②作用域：整个项目中的所有文件；
③生命周期：从程序创建到程序销毁；
④未初始化：数值型变量自动赋初值0，字符型变量赋空字符。
int a = 0;
int main(){//函数内部定义的变量
printf("before modified:%d\n", a);//0
{//匿名内部函数：没有名字的函数，实现功能后会销毁，节省空间
int a = 1;//内部定义一个变量，销毁后不再使用
printf("Anonymous function int a(inside):%d\n", a);//1
}
printf("Anonymous function int a(outside):%d\n", a);//0
{
a = 1;//内部没有定义变量，销毁后可以继续使用
printf("Anonymous function a(inside):%d\n", a);//1
}
printf("Anonymous function a(outside):%d\n", a);//1
auto int a = 2;//全局变量名和局部变量名可以重合，操作数据时采用就近原则
printf("after modified:%d\n", a);//在函数内部修改全局变量的值，仅在此函数中为修改过的值2
8.1.4 静态(static)全局变量
①作用域：本文件，所以不同文件静态全局变量可以重名，但作用域不冲突；
②生命周期：从程序创建到程序销毁，存储在数据区；
③未初始化：数值型变量自动赋初值0，字符型变量赋空字符。
8.1.5 全局函数和静态函数
在C语言中函数默认都是全局的(所以函数名不可以重名，不像C++一样支持多态，也就是C不支持同一函数名不同参数)，使用关键字static可以将函数声明为静态，函数定义为static就意味着这个函数只能在定义这个函数的文件中使用，在其他文件中不能调用，即使在其他文件中声明这个函数都没用。
对于不同文件中的staitc函数名字可以相同。
递归函数：函数调用本身
①允许在不同函数中使用相同的变量名，它们代表不同的对象；
②同一源文件中，允许全局变量和局部变量同名，在局部变量的作用域内，全局变量不起作用；
③所有函数默认都是全局的，所以所有的函数都不能重名，但如果是staitc函数，那么作用域是文件级的，所以不同的文件static函数名是可以相同的。
8.2 内存布局
在Windows下程序是一个普通的可执行文件，在CMD输入size + 文件名后，得出下列的一个二进制可执行文件的基本情况：
如图可得，在没有运行程序前，也就是说程序没有加载到内存前，可执行程序内部已经分好3段信息，分别为代码区(text）、初始化数据区(data）和未初始化数据区(bss）3个部分，也有直接把data和bss合起来叫做数据区。text、data和bss的大小就是固定的，程序运行期间不能改变。运行可执行程序后，系统把程序加载到内存，除了根据可执行程序的信息分出代码区、数据区和未初始化数据区之外，还额外增加栈区、堆区。
int a;//未初始化全局变量 00588498 未初始化数据区 ②
int b = 2;//初始化全局变量 00588000 初始化数据区 ③
static int c;//未初始化静态全局变量 0058816C 未初始化数据区 ②
static int d = 4;//初始化静态全局变量 00588004 初始化数据区 ③
int main(){
int e;//未初始化局部变量 00B9FAAC 栈区 ①
int f = 6;//初始化局部变量 00B9FAA0 栈区 ①
static int g;//未初始化静态局部变量 00588170 未初始化数据区 ②
static int h = 8;//初始化静态局部变量 00588008 初始化数据区 ③
char* p1 = "hello world";//字符串常量 00585858 文字常量区 ④
int arr[] = { 1, 2, 3, 4 };//整型数组 00B9FA7C 栈区 ①
int* p2 = arr;//00B9FA7C 00B9FA70 栈区 ①
printf("%p %p %p %p\n", &a, &b, &c, &d); // 地址高低
printf("%p %p %p %p\n", &e, &f, &g, &h);
printf("%p %p %p %p\n", p1, arr, p2, &p2);
代码区text：存放CPU执行的机器指令。①代码区是共享的，即另外的执行程序可以调用它，共享目的是对被频繁执行的程序(printf函数)只需要在内存中有一份代码即可。代码区是只读的，只读原因是共享，防止其他程序运行因某个共享程序修改而无法运行。
初始化数据区data：存放初始化全局变量、初始化静态变量和常量数据(如字符串常量)。
未初始化数据区bss：存放未初始化全局变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为0或者NULL，位置可以分开也可以紧靠数据段。存储于数据段的数据的生命周期为整个程序运行过程。
栈区stack：存放函数的局部变量、数组、参数值、返回值等。是一种先进后出的内存结构，大小为1M，由编译器自动分配临时空间，使用完后释放。因此，存储在栈区的数据的生存周期为申请到释放该段栈空间。
int a[300000]={0};//调试出现错误stack overflow，300000*sizeof(int)/1024/1024>1MB
堆区heap：是一个大容器，容量要远大于栈，没有栈那样先进后出的顺序，大小跟电脑运行内存有关。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。
int* p1 = (int*)malloc(sizeof(int)*350000000);//地址为0,说明在堆区中无法开辟出sizeof(int)*400000000字节的连续空间
8.3 内存操作函数
8.3.1 memset()
| 函数名 | void *memset(void *s, int c, size_t n); |
|---|---|
| 头文件 | #include <string.h> |
| 参数 | s：需要操作内存s的首地址 c：填充的字符，c虽然参数为int，但必须是unsigned char , 范围为0~255 n：指定需要设置的大小 |
| 功能 | 将s的内存区域的前n个字节以参数c填入 |
| 返回值 | 成功：s的首地址 失败：NULL |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
int* p1 = (int*)malloc(sizeof(int)* 10);
memset(p1, 0, sizeof(int)* 10);//重置堆区内存空间的值
for (size_t i = 0; i < 10; i++){
printf("%d ",p1[i]);
}
memset(p1, 1, sizeof(int)* 10);
for (size_t i = 0; i < 10; i++){
printf("%d ", p1[i]);
}
free(p1);
char ch[10];//对于栈区也可以重置，字符数组上可以用memset初始化
memset(ch, 'A', sizeof(char)* 10);//没遇到\0，会出现乱码
//memset(ch, 0, sizeof(char)* 10);//遇到\0停止输出字符串
printf("%s ", ch);
int a = 10;
memset(&a, 0, sizeof(int));
printf("a=%d", a);//可以改变1个变量的值，大材小用，一般改一堆
return 0;
}
使用memset( ) 重置堆区内存空间的值，不需要再使用循环将每个值重置为0，malloc(p,0, sizeof(int)*10)可以把一堆内存空间的值重置为0，但不能重置为其他数值，例如malloc(p,1, sizeof(int))则把每个字节对应的内存空间的值改成0x01，4个字节为01010101，然后%d输出，转化为十进制为16843009。
8.3.2 memcpy()
| 函数名 | void *memcpy(void *dest, const void *src, size_t n); |
|---|---|
| 头文件 | #include <string.h> |
| 参数 | dest：目的内存首地址 src：源内存首地址，dest和src所指的内存空间不可重叠，可能会导致程序报错 n：需要拷贝的字节数 |
| 功能 | 拷贝src所指的内存内容的前n个字节到dest所值的内存地址上 |
| 返回值 | 成功：dest的首地址 失败：NULL |
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() {
char ch2[] = "Hello\0World";
char ch3[20];
char ch4[20];
strcpy(ch3, ch2);//遇到0停止打印
printf("%s\n", ch3);//Hello
memcpy(ch4, ch2, sizeof(char) * 20);//拷贝内容跟字节有关，与内容(\0)无关
printf("%s\n", ch4);//Hello
for (size_t i = 0; i < sizeof(ch2); i++)//i大于等于12会乱码
printf("%c", ch4[i]);//HelloWorld
//memcpy(ch2[2], ch2, 10); //error, 内存重叠
return 0;
}
8.3.3 memmove()
memmove()功能用法和memcpy()一样，区别在于：dest和src所指的内存空间重叠时，memmove()仍然能处理，不过执行效率比memcpy()低些。
8.3.4 memcmp()
| 函数名 | int memcmp(const void *s1, const void *s2, size_t n); |
|---|---|
| 头文件 | #include <string.h> |
| 参数 | s1：内存首地址1 s2：内存首地址2 n：n：需比较的前n个字节 |
| 功能 | 比较s1和s2所指向内存区域的前n个字节，可比较任何类型的变量，而strcmp只能比较字符串 |
| 返回值 | 相等：=0 大于：>0 小于：<0 |
#include<stdio.h>
#include<string.h>
int main() {
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10] = { 1, 2, 3, 4, 5 };
printf("%d\n", memcmp(a, b, sizeof(a))); //>0
return 0;
}
8.4 堆区内存分配和释放
8.4.1 malloc()
| 函数名 | void *malloc(size_t size); |
|---|---|
| 头文件 | #include <stdlib.h> |
| 参数 | size：需要分配内存大小，单位是字节 |
| 功能 | 在内存的动态存储区(堆区)中分配一块长度为size字节的连续区域，用来存放类型说明符指定的类型。分配的内存空间内容不确定，一般使用memset初始化 |
| 返回值 | 成功：分配空间的起始地址 失败：NULL |
8.4.2 free()
| 函数名 | void free(void *ptr); |
|---|---|
| 头文件 | #include <stdlib.h> |
| 参数 | ptr：释放由malloc函数所分配的区域空间的首地址，释放后ptr变成野指针，可以在释放后令ptr = NULL |
| 功能 | 释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，指向被释放区域的首地址。对同一内存空间多次释放会出错（不能释放不存在的、不是用malloc开辟的堆空间，否则可能会因为内存找不到而电脑死机） |
| 返回值 | 无 |
8.5 内存分区代码分析
以下代码案例根据第六章函数值传递内容画图理解。
8.5.1 返回栈区地址
int* fun() {
int a = 10;
return &a;//函数调用完毕，a释放
}
int main() {
int* p = fun();
*p = 100; //error，操作野指针指向的内存，
printf("*p = %d\n", *p); //第一次能正常打印100，因为编译器第一次做了保留，已经非法操作内存
printf("*p = %d\n", *p); //第二次打印乱码，因为编译器已经释放
return 0;
}
8.5.2 返回data区地址
int *fun(){
static int a = 10;
return &a; //函数调用完毕，a不释放
}
int main(){
int *p = fun();
*p = 100;
printf("*p = %d\n", *p);//*p=100
return 0;
}
8.5.3 返回堆区地址
#include <stdio.h>
#include <stdlib.h>
int* fun() {
int* tmp = (int*)malloc(sizeof(int));
*tmp = 100;
return tmp;//返回堆区地址，函数调用完毕，不释放
}
int main() {
int* p = fun();
printf("*p = %d\n", *p);//*p=100
free(p);
//p = NULL; //释放后p变成野指针，可以在释放后令p = NULL，但是程序快结束了，写不写都没什么意义
return 0;
}
8.5.4 值传递1
#include <stdio.h>
#include <stdlib.h>
void fun(int* tmp) {
tmp = (int*)malloc(sizeof(int));
printf("address(tmp) = %p\n", tmp); //非空指针地址
}//栈区开辟堆空间存放函数信息，并在堆空间给tmp赋值，函数结束后形参销毁，堆空间不销毁，导致形参的值没有给实参
int main() {
int* p = NULL;
fun(p); //值传递，形参修改不会影响实参
printf("address(p) = %p\n", p);//p还是空，操作空指针指向的内存报错
return 0;
}
8.5.5 值传递2
#include <stdio.h>
#include <stdlib.h>
void fun(int* tmp) {
*tmp = 100;
}
int main() {
int* p = (int*)malloc(sizeof(int));
fun(p); //值传递
printf("*p = %d\n", *p); //ok，*p=100
free(p);
return 0;
}
8.5.6 返回值或地址传递
#include <stdio.h>
#include <stdlib.h>
void fun01(int** pointer){
*pointer = (int*)malloc(sizeof(int)* 10);
printf("address(*pointer)=%p\n", *pointer);
}
int fun02(){
int* p = (int*)malloc(sizeof(int)* 10);
return p;
}
int main(){
int* p = NULL;
fun01(&p);//地址传递，执行过后p不是空指针
//p = fun02();//通过返回值进行值传递
printf("address(p)=%p\n",p);
for (size_t i = 0; i < 10; i++){
p[i] = i;
printf("%d ", p[i]);//0 1 2 3 4 5 6 7 8 9
}
free(p);
return 0;
}
8.5.7 数组下标越界
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main() {//以下代码最好不要去运行，尤其是注释的代码，否则内存进行重新梳理而卡掉
char ch[11] = "hello world";//数组下标越界,用11个字节空间存12个字符
char* p1 = (char*)malloc(sizeof(char) * 11);
strcpy(p1, "hello world");
printf("%s\n", p1);//不加free能正常打印
//free(p1);//error,不加free不报错,因为开辟11个空间，但拷贝使用12个字节空间，最后释放4个字节空间而报错
int* p2 = (int*)malloc(0);//开辟0字节大小的空间，相当于野指针
printf("%p\n", p2);//能打印出地址
*p2 = 10;
printf("%d\n", *p2);//不加free能打印10
//free(p2);//error,不加free不报错,因为开辟0个空间，但使用4个字节空间，最后释放4个字节空间而报错
int* p3 = (int*)malloc(5);//开辟5字节大小的空间
printf("%p\n", p3);//能打印出地址
*p3 = 10;
printf("%d\n", *p3);//能打印10
//free(p3);//right,没有下标越界
*(p3 + 1) = 20;//若加了此行代码
printf("%d\n", *(p3 + 1));//能打印20
//free(p3);//error,下标越界
int* p4 = (int*)malloc(sizeof(int) * 10);
free(p4);//第一次释放是非野指针
//free(p4);//多次释放是野指针,释放野指针一定报错
p4 = NULL;
free(p4);//释放空指针不会报错，多次释放也行
int* p5 = (int*)malloc(sizeof(int) * 10);
for (size_t i = 0; i < 10; i++) {
*p5 = i;
p5++;//释放堆区尽量不要修改指针，除非做个备份
}//int* temp = p5，用temp取修改
//free(p5);//指针的位置已经改变，释放指针会报错
return 0;
}
码字不易，如果大家觉得有用，请高抬贵手给一个赞让文章上推荐让更多的人看到吧，也可以评论提出意见让后面的文章内容越来越生动丰富。
扫一扫
945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
