C语言_8 内存管理

8 内存管理

8.1 作用域
C语言变量的作用域分为：

• 代码块作用域（代码块是{}之间的一段代码）
• 函数作用域
• 文件作用域

8.1.1 局部变量
局部变量也叫auto自动变量（auto可写可不写），一般情况下代码块{}内部定义的变量都是自动变量，它有如下特点：

• 在一个函数内定义，只在函数范围内有效
• 在复合语句中定义，只在复合语句中有效
• 随着函数调用的结束或复合语句的结束局部变量的声明周期也结束
• 如果没有赋初值，内容为随机

#include
void fun01(int a)
{
     
	int b=20;
}
int main01()
{
     
	//定义变量 局部变量 在函数内部定义的变量 使用auto修饰
	//作用域 在函数内部
	//声明周期 从创建到函数结束
	int a=10;
	print("%d\n",a);
	
	int i;
	for(i=0;i<10;i++)
	{
     
	}
	print("%d\n",i);
	return 0;
}

8.1.2 静态(static)局部变量

• static局部变量的作用域也是在定义的函数内有效
• static局部变量的声明周期和程序运行周期一样，同时static局部变量的值只初始化一次，但可以赋值多次
• static局部变量若未赋以初值，则有系统自动赋值：数值型变量自动赋初值0，字符型变量赋空字符

#include
void fun04()
{
     
	//printf("%d\n",b);//打印不了
	static int b=10;//加static打印11-20 不加打印10个11
	//静态局部变量只会初始化一次，可以多次赋值
	//在数据区进行存储 地址唯一
	//作用域 只能在函数内部使用
	//生命周期 从函数创建到程序销毁
	b++;
	printf("%d\n",b);
}
int main03()
{
     
	//static int b=10;//静态局部变量
	//printf("%d\n",b);
	
	for(int i=0;i<10;i++)
	{
     
		fun04();
	}
	return 0;
}

8.1.3 全局变量

• 在函数外定义，可被本文件及其它文件中的函数所用，若其它文件中的函数调用此变量，须用extern声明
• 全局变量的声明周期和程序运行周期一样
• 不同文件的全局变量不可重复，可以和局部变量重名

#include
//全局变量 在函数外部定义的变量 存在数据区
//作用域 整个项目中所有文件 如果在其他文件中使用需要声明 
	//在文件头 extern int a;或 int a;
//声明周期 从程序创建到程序销毁
//全局变量可以和局部变量重名 采用就近原则
int a=10;
void fun02()
{
     
	a=100;
	printf("%d\n",a);
}
int main02()
{
     
	printf("%d\n",a);//10
	int a=120;
	printf("%d\n",a);//120 数据在操作时采用就近原则
	fun02();//100
	{
     //匿名内部函数
		int a=456;
		printf("%d\n",a);//456
	}
	printf("%d\n",a);//120
	{
     
		a=456;//在外部定义a，此处改变了a的值
		printf("%d\n",a);//456
	}
	printf("%d\n",a);//456
	return 0;
}

8.1.4 静态(static)全局变量

• 在函数外定义，作用范围被限制在所定义的文件中
• 不同文件静态全局变量可以重名，但作用域不冲突
• static全局变量的声明周期和程序周期一样，同时static全局变量的值只初始化一次

#include
//静态全局变量 
//作用域 可以在本文件中使用 不可以在其它文件中使用
//生命周期 从程序创建到程序销毁 存储在数据区
static int c=10;
void fun05()
{
     
	c=20;
	printf("%d\n",c);
}
int main04()
{
     
	printf("%d\n",c);//10
	fun05();//20
	return 0;
}

未初始化数据

#include
//int abc;//全局变量未初始化 值为0
static int abc;//静态全局变量未初始化 值为0
int main05()
{
     
	//int abc;//局部变量未初始化 值为乱码
	static int abc;//静态局部变量未初始化 值为0
	printf("%d\n",abc);
	return 0;
}

8.1.5 extern全局变量声明
extern int a; 声明一个变量，这个全局变量在别的文件中已经定义了，这里只是声明，而不是定义。

8.1.6 全局函数和静态函数
在C语言中函数默认都是全局的，使用关键字static可以将函数声明为静态，函数定义为static就意味着这个函数只能在定义这个函数的文件中使用，在其他文件中不能调用，即使在其他文件中声明这个函数都没有用。
对于不同文件中static函数名字可以相同。

注意：

• 允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰。
• 同一源文件中，允许全局变量和局部变量同名，在局部变量的作用域内，全局变量不起作用。
• 所有的函数默认都是全局的，意味着所有的函数都不能重名，但如果是static函数，那么作用域是文件级的，所以不同的文件static函数名是可以相同的。

#include
//函数可以调用自己 称为递归函数
void BubbleSort(int *,int);//函数声明 不作声明也能调用函数 但是右键 转到定义 转不过去
int main06()
{
     
	int arr[]={
     9,1,5,6,8,2,7,10,4,3};
	//全局函数的名字是作用域中唯一的
	//作用域 在整个项目中所有文件中使用
	BubbleSort(arr,10);
	for(int i=0;i<10;i++)
	{
     
		printf("%d\n",arr[i]);
	}
	return 0;
}
//静态函数 静态函数可以和全局函数重名 调用就近原则
//作用域 当前文件中
//声明周期 从程序创建到程序销毁
static void fun07()
{
     
	printf("hello world\n");
	//fun07();//递归调用
}
//void fun07();// 声明 若把fun07拿到别的文件中，无法调用
int main07()
{
     
	fun07();//hello world
	return 0;
}

8.1.7 总结

//atl+上/下键 移动到上/下一行
#include
const int abc=123;//安全的常量 存储
int a1;//未初始化全局变量
int b1=10;//初始化全局变量
static int c1;//未初始化静态全局变量
static int d1=10;//初始化静态全局变量
int main08()
{
     
	int e1=10;//局部变量
	static int f1;//未初始化静态局部变量
	static int h1=10;//初始化静态局部变量
	
	char *p="hello world";//字符串常量
	int arr[]={
     1,2,3,4};//数组
	int  *pp=arr;//指针
	
	printf("未初始化全局变量：%p\n",&a1);
	printf("初始化全局变量：%p\n",&b1);
	printf("未初始化静态全局变量：%p\n",&a1);
	printf("初始化静态全局变量：%p\n",&b1);
	
	printf("局部变量：%p\n",&e1);
	
	printf("未初始化静态局部变量：%p\n",&f1);
	printf("初始化静态局部变量：%p\n",&h1);
	
	printf("字符串常量：%p\n",&p);
	printf("数组：%p\n",arr);
	printf("指针变量：%p\n",pp);
	printf("指针地址：%p\n",&pp);
	return 0;
}

8.2 内存布局

8.2.1 内存分区
C语言经过预处理、编译、汇编、链接4步后生成一个可执行程序。
在Windows下，程序是一个普通的可执行文件，以下列出一个而进行可执行文件的基本情况：

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

• 代码区
  存放CPU执行的机器指令。通常代码区是可共享的（即另外的执行程序性可以调用它），使其共享的目睹是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。
• 全局初始化数据区/静态数据区(data段)
  该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）
• 未初始化数据区(又叫bdd区)
  存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为0或者空(NULL)。

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

• 代码区(text segment)
  加载的是可执行文件代码段，所欲的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。
• 未初始化数据区(BSS)
  加载的是可执行文件BSS段，位置可以分开亦可以紧靠数据段，存储于数据段的数据（全局未初始化。静态未初始化数据）的生存周期为整个程序运行过程。
• 全局初始化数据区/静态数据区(data segment)
  加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量（只读））的数据的生存周期为整个程序运行过程。
• 栈区(stack)
  栈是一种先进后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实际加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间。
• 堆区(heap)
  堆是一个大容器，它的容量要远远大于栈，但没有栈那样先进后厨的顺序。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统收回。
  

#include
//栈区存储模型 先存高地址后存低地址
void swap(int a,int b)
{
     
	printf("a=%p\n",&a);//a=010FFC18
	printf("b=%p\n",&b);//b=010FFC10
	int temp=a;
	a=b;
	b=temp;
}
int main09()
{
     
	int a=10;
	int b=20;
	printf("a=%p\n",&a);//a=010FFCFC
	printf("b=%p\n",&b);//b=010FFCF0
	swap(a,b);
	printf("a=%d\n",a);//10
	printf("b=%d\n",b);//20
	return 0;
}

8.2.2 存储类型总结

8.2.3 内存操作函数
（1）memser()

#include
void *memser(void *s,int c,size_t n);

功能：将s的内存区域的前n个字节以参数c填入
参数：s：需要操作内存s的首地址
c：填充的字符，c虽然参数为int，但必须是unsigned char，范围为0~255
n：指定需要设置的大小
返回值：s的首地址
（2）memcpy()

#include
void *memcpy(void *dest,const void *src,size_t n);

功能：拷贝src所指的内存内容的前n个字节到dest所指的内存地址上
参数：dest：目的内存地址
src：源内存首地址，注意：dest和src所指的内存空间不可重叠，可能会导致程序报错
n：需要拷贝的字节数
返回值：dest的首地址
（3）memmove()
memmove()功能用法和memcpy()一样，区别在于：dest和sre所指的内存空间重叠时，memmove()仍然能处理，不过执行效率比memcpy()低些。
（4）memcmp()

#include
void *memcmp(const void *s1,const void *s2,size_t n);

功能：比较s1和s2所指向内存区域的前n个字节
参数：s1：内存首地址1
s2：内存首地址2
n：需比较的前n个字节
返回值：相等：=0 大于：>0 小于：<0

#include
#include
#include
int main13()
{
     
	int *p=(int *)malloc(sizeof(int)*10);
	//memset()重置内存空间的值，单位 字节
	memset(p,0,sizeof(int)*10);//0 0 0 0 0 0 0 0 0 0 
	for(int i=0;i<10;i++)
	{
     
		printf("%d\n",p[i]);
	}
	free(p);

	char ch[10];
	memset(ch,'A',sizeof(char)*10);
	printf("%s\n",ch);//字符串重置 无\0乱码
	free(ch);
	
	memset(ch,0,sizeof(char)*10);
	printf("%s\n",ch);//0
	free(ch);

	int a=10;
	memset(&a,0,sizeof(int));
	printf("%d\n",a);//0 对一个重置无意义，一般不这么写
	free(a);
	return 0;
}
int main13()
{
     
	int arr[]={
     1,2,3,4,5,6,7,8,9,10};
	int *p=(int *)malloc(sizeof(int)*10);
	//memcpy()内存拷贝 strcpy()字符串拷贝
	memcpy(p,arr,sizeof(int)*10);
	for(int i=0;i<10;i++)
	{
     
		printf("%d\n",p[i]);
	}
	free(p);

	char ch[]="hello\0 world";
	char str[100];
	//strcpy(str,ch);//字符串拷贝遇到\0停止 hello
	//printf("%s\n",str);
	memcpy(str,ch,13);
	for(int i=0;i<13;i++)
	{
     
		printf("%c\n",str[i]);//内存拷贝的内容与字节有关 hello world
	}
	
	int arr[]={
     1,2,3,4,5,6,7,8,9,10};
	//如果拷贝的目标和源发生重叠 可能报错
	memcpy(&arr[5],&arr[3],20);
	for(int i=0;i<10;i++)
	{
     
		printf("%d\n",arr[i]);//1 2 3 4 5 4 5 6 7 8 
	}
	return 0;
}
int main14()
{
     
	int arr[]={
     1,2,3,4,5,6,7,8,9,10};
	//memcpy(&arr[5],&arr[3],20);
	memmove(&arr[5],&arr[3],20);//内存拷贝
	for(int i=0;i<10;i++)
	{
     
		printf("%d\n",arr[i]);//1 2 3 4 5 4 5 6 7 8 
	}
	return 0;
}
int main15()
{
     
	int arr1[]={
     1,2,3,4,5,6,7,8,9,10};
	int arr2[]={
     1,2,3,4,5};
	int value=memcmp(arr1,arr2,20);//内存比较 20=sizeof(int)*5 1个字节1个字节比较
	printf("%d\n",value);

	int arr1[]="hello\0 world";
	int arr2[]="hello\0 world";
	int value=memcmp(arr1,arr2,13);//比较的和内存有关，与内容无关 可以比较\0之后的内容，strcmp()字符串比较 遇到\0停止比较 只能比较\0之前内容
	printf("%d\n",value);
	return 0;
}

memcpy()：

8.2.4 栈区内存分配和释放
（1）malloc()

#include
void *malloc(size_t size);

功能：在内存的动态存储区（堆区）中分配一块长度为size字节的连续区域，用来存放类型说明符指定的类型。分配的内存空间不确定，一般使用memset初始化。
参数：size：需要分配内存大小（单位：字节）
返回值：成功：分配空间的起始地址 失败：NULL
（2）free()

#include
void free(void *ptr);

功能：释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，指向被释放区域的首地址。对同一内存空间多次释放会出错。
参数：ptr：需要释放空间的首地址，被释放区应是由malloc函数所分配的区域。
返回值：无

#include
#include
//堆空间开辟和使用
int main10()
{
     
	//栈区大小1M
	int arr[210000]={
     0};
	//开辟堆空间存储数据
	//int *p=(int *)malloc(sizeof(int)*1340);//这样写别人一看就知道存多少数据
	int *p=(int *)malloc(sizeof(int));
	printf("%p\n",p);//00D16E70
	//使用堆空间
	*p=123;
	printf("%d\n",*p);//123
	//释放堆空间
	free(p);//p变成野指针
	p=NULL;
	printf("%p\n",p);//00D16E70
	*p=456;
	printf("%d\n",*p);//456
	return 0;
}
int main11()
{
     
	//int *p=(int *)malloc(sizeof(int)*8200000);//没有那么大的存储空间会返回00000000 下面通过if判断
	//printf("%p\n",p);
	//free(p);
	
	int *p=(int *)malloc(sizeof(int)*10);
	if(p==NULL)//!p
	{
     
		printf("程序异常\n");
		return -1;
	}
	
	int *p=(int *)malloc(sizeof(int)*10);
	for(int i=0;i<10;i++)
	{
     
		p[i]=i;
	}
	for(int i=0;i<10;i++)
	{
     
		printf("%d\n",*(p+i));//0 1 2 3 4 5 6 7 8 9 10
	}
	free(p);
	return 0;
}

#include
#include
#include
#include
#define MAX
void BubbleSort(int *src,int len);
int main12()
{
     
	srand((size_t)time(NULL));
	int *p=(int *)malloc(sizeof(int)*MAX);
	for(int i=0;i<MAX;i++)
	{
     
		p[i]=ranf()%100;
		printf("%d\n",p[i]);//88 47 69 92 5 96 46 68 12 84
	}
	printf("\n");
	BubbleSort(p,MAX);
	for(int i=0;i<MAX;i++)
	{
     
		printf("%d\n",*(p+i));//5 12 46 47 68 69 84 88 92 96
		
		//printf("%d\n",*p);
		//p++;//p地址改变，free(p)会发生错误。若在之前p-=10;不会报错
	}
	free(p);
	return 0;
}

内存常见问题：

#include
#include
#include
int main16()
{
     
	//char ch[11]="hello world";//数组下标越界
	char *p=(char *)malloc(sizeof(char)*11);
	strcpy(p,"hello world");
	printf("%s\n",p);
	free(p);//开辟11个空间，释放12个空间 报错
	return 0;
}
int main17()
{
     
	//野指针
	int *p=(int *)malloc(0);
	printf("%p\n",p);
	*p=100;
	printf("%d\n",*p);
	free(p);//err
	//开辟空间和类型对应，不要越界
	int *p=(int *)malloc(10);
	p[0]=123;
	p[1]=456;
	p[2]=789;
	printf("%p\n",p);
	printf("%d\n",*p);
	printf("%d\n",*(p+1));
	printf("%d\n",*(p+2));//在打印p[2]err，指针越界
	return 0;
}
int main18()
{
     
	int *p=(int *)malloc(sizeof(int)=10);
	free(p);
	//free(p);//堆空间不允许多次释放，第二次释放的是野指针
	
	p=NULL;//空指针允许多次释放
	free(p);
	free(p);
	free(p);
	return 0;
}
int main19()
{
     
	int *p=(int *)malloc(sizeof(int)=10);
	//int *temp=p;//保留指针，在最后释放时不会报错
	for(int i=0;i<10;i++)
	{
     
		//*p++=i;
		*p=i;
		i++;
	}
	free(p);//err 指针叠加 不断改变指针方向 释放会报错
	return 0;
}
///
void fun08(int *p)
{
     
	p=(int *)malloc(sizeof(int)*10);
}
int main20()
{
     
	int *p=NULL;
	//值传递
	fun08(p);//err 这两句话为同级指针，最后会报错 并没有将地址传递到函数中，改为fun09 main21
	for(int i=0;i<10;i++)
	{
     
		p[i]=i;
	}
	free(p);
	return 0;
}
//
void fun08(int *p)
{
     
	p=(int *)malloc(sizeof(int)*10);
	printf("形参：%p\n",p);//两个地址不一样
}
int main20()
{
     
	int *p=NULL;
	fun08(p);
	printf("实参：%p\n",p);//两个地址不一样
	free(p);
	return 0;
}
///
void fun09(int **p)
{
     
	*p=(int *)malloc(sizeof(int)*10);
	printf("形参：%p\n",p);//两个地址一样
}
int main21()
{
     
	int *p=NULL;
	//地址传递
	fun09(&p);
	printf("实参：%p\n",p);//两个地址一样
	for(int i=0;i<10;i++)
	{
     
		p[i]=i;
	}
	free(p);
	return 0;
}
/
//返回值
int fun10()
{
     
	int *p=(int *)malloc(sizeof(int)*10);
	reurn p;
}
int main22()
{
     
	int *p=NULL;
	//返回值
	p=fun10();
	for(int i=0;i<10;i++)
	{
     
		p[i]=i;
	}
	for(int i=0;i<10;i++)
	{
     
		printf("%d\n",p[i]);
	}
	free(p);
	return 0;
}

地址传递：
值传递 形参不能改变实参的值
地址传递 形参可以改变实参的值

二级指针对应的堆空间：

#include
#include
#include
int main23()
{
     
	//int arr[5][3]
	int **p=(int **)malloc(sizeof(int*)*5);//开辟二级指针对应的堆空间
	for(int i=0;i<5;i++)
	{
     
		p[i]=(int *)malloc(sizeof(int)*3);//开辟一级指针对应的堆空间
	}
	for(int i=0;i<5;i++)//输入
	{
     
		for(int j=0;j<5;j++)
		{
     
			scanf("%d",&p[i][j]);//*(p[i]+j)  *(*(p+i)+j)
		}
	}
	for(int i=0;i<5;i++)//打印
	{
     
		for(int j=0;j<5;j++)
		{
     
			printf("%d",&p[i][j]);
		}
		printf("\n");
	}
	for(int i=0;i<5;i++)//释放 先释放内层后释放外层
	{
     
		free(p[i]);
	}
	free(p);
	return 0;
}

8.3 内存分区代码分析
（1）返回栈区地址
（2）返回data区地址
（3）值传递