C语言_8 内存管理

最新推荐文章于 2023-01-08 10:51:51 发布

从入门到放弃系列

最新推荐文章于 2023-01-08 10:51:51 发布

阅读量261

点赞数

分类专栏： C语言

本文链接：https://blog.csdn.net/qq_33726677/article/details/105297937

版权

C语言专栏收录该内容

10 篇文章 1 订阅

订阅专栏

8 内存管理

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

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

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

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

#include<stdio.h>
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<stdio.h>
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<stdio.h>
//全局变量 在函数外部定义的变量 存在数据区
//作用域 整个项目中所有文件 如果在其他文件中使用需要声明 
	//在文件头 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<stdio.h>
//静态全局变量 
//作用域 可以在本文件中使用 不可以在其它文件中使用
//生命周期 从程序创建到程序销毁 存储在数据区
static int c=10;
void fun05()
{
	c=20;
	printf("%d\n",c);
}
int main04()
{
	printf("%d\n",c);//10
	fun05();//20
	return 0;
}

在这里插入图片描述
未初始化数据

#include<stdio.h>
//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<stdio.h>
//函数可以调用自己 称为递归函数
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<stdio.h>
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<stdio.h>
//栈区存储模型 先存高地址后存低地址
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<string.h>
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<string.h>
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<string.h>
void *memcmp(const void *s1,const void *s2,size_t n);

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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
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<stdlib.h>
void *malloc(size_t size);

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

#include<stdlib.h>
void free(void *ptr);

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

#include<stdio.h>
#include<stdlib.h>
//堆空间开辟和使用
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<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
#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<stdio.h>
#include<stdlib.h>
#include<string.h>
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<stdio.h>
#include<stdlib.h>
#include<string.h>
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）值传递

从入门到放弃系列

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C语言_8 内存管理

8 内存管理8.1 作用域C语言变量的作用域分为：代码块作用域（代码块是{}之间的一段代码）函数作用域文件作用域8.1.1 局部变量局部变量也叫auto自动变量（auto可写可不写），一般情况下代码块{}内部定义的变量都是自动变量，它有如下特点：在一个函数内定义，只在函数范围内有效在复合语句中定义，只在复合语句中有效随着函数调用的结束或复合语句的结束局部变量的声明周期也结...
复制链接

扫一扫