C语言_8 内存管理

最新推荐文章于 2023-01-08 10:51:51 发布
最新推荐文章于 2023-01-08 10:51:51 发布
阅读量303 收藏
点赞数
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33726677/article/details/105297937
版权

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）值传递

从入门到放弃系列
关注
专栏目录
存储管理C语言实现 操作系统 数据结构
06-19
程序用C语言实现操做系统中的内存管理，内存分配算法包括FF,BF,WF三种
c语言8
weixin_30530339的博客
06-03 266
#include<stdio.h> int average(int a,int b,int c){ int x; x=(a+b+c)/3; return x;} int Q(int a,int b,int c,int d,int e){ int x; x=(a+b+c+d+e)/5; return x;} int m...
C语言入门----八
10-26 331
//1.编写函数： //unsigned int reverse_bit(unsigned int value); //这个函数的返回值value的二进制位模式从左到右翻转后的值。 // //如： //在32位机器上25这个值包含下列各位： //00000000000000000000000000011001 //翻转后：（2550136832） //10011000000000000000000...
C语言＞＞8 & 0xFF； & 0xFF；作用
最新发布
ahphong的博客
01-08 1676
1010 1010 0011 0011 & 1111 1111 = 0011 0011。 1010 1010 0011 0011 >> 8 & 1111 1111 = 1010 1010。
操作系统
Ukiyo-E的博客
05-19 595
操作系统整理 1.为何要有操作系统 由于现代的计算机系统主要是由一个或者多个处理器，主存，硬盘，键盘，鼠标，显示器，打印机，网络接口及其他输入输出设备组成。管理这些部件并加以优化使用，是一件极富挑战性的工作，于是，计算安装了一层软件（系统软件），称为操作系统。它的任务就是为用户程序提供一个更好、更简单、更清晰的计算机模型，并管理刚才提到的所有设备。 2.操作系统的
Linux内存管理模拟器.rar_Linux C语言_二级页表模拟_内存分页管理_内存管理模拟_数学建模
09-23
Linux下使用c语言实现的内存管理模拟器 假设有台计算机物理内存大小为4MB,每个内存页大小为4k。采用分页机制，使用二级页表，第一级为页目录，共有1024项，每个页目录项指向一个页表，每个页表项指向一个实际的物理...
存储引擎（C语言版本）_C语言内存管理_C语言内核编程_c语言数据结构_C语言存储引擎_
10-04
首先，我们要理解C语言内存管理。在C语言中，程序员需要手动分配和释放内存，使用`malloc()`和`free()`函数来动态地申请和释放内存块。这样的方式虽然需要更多的编程技巧，但也提供了更高的灵活性和对内存使用的精确...
会员信息管理系统_C语言_会员系统_信息管理系统_会员管理系统_
10-01
9. **性能优化**：C语言允许低级内存管理，通过合理分配和释放内存，可以提高系统的运行效率。此外，使用合适的数据结构（如链表、树等）和算法可以优化数据检索速度。 综上所述，会员信息管理系统是一个结合了...
成绩管理系统——c语言例题_C语言_学生成绩管理系统_
10-03
9. 内存管理： C语言允许程序员手动管理内存，使用malloc()和free()函数分配和释放内存。在处理大量学生数据时，合理地分配和释放内存至关重要，以避免内存泄漏。 10. 性能优化： C语言允许开发者直接控制计算机...
通讯录_C语言_通讯录管理系统_
10-02
【标题】：“通讯录_C语言_通讯录管理系统_”是一个基于C语言开发的简单通讯录管理系统，用于管理和操作个人联系人信息。 【描述】：该系统提供了基础的联系人管理功能，包括添加新联系人、查看所有联系人、查询...
操作系统课程设计 C语言 存储器管理
12-25
报告，代码直接用，C语言 struct VPage { int pfn;//存放在实页号 int time;//最近访问时间 }; typedef struct PageNode { int pn;//存放的虚页号 struct PageNode *next; }*PageLink;
C语言（八）文件操作（一）
时光若止-Dale
02-20 330
文件操作 文件是存在磁盘（或硬盘）中的，由操作系统管理的，打开文件会将文件加载到内存中，而内存掉电，数据会丢失，因此在对文件进行修改之后需要将内存中的数据写入到磁盘中去，即在对文件进行操作之后需要进行保存。在Linux中一切皆是文件，目录也是一种文件，是一种特殊文件(目录文件)。Linux中有7种文件类型： 文件类型标识 文件类型 - 普通文件 d 目录文件 l 符号链接文...
C语言笔记(8)C语言高级编程
qq_37363920的博客
06-28 272
结构体的嵌套
c语言之内存管理
橙子的博客
09-11 267
一、动态内存分配1、 c语言中动态内存分配的步骤：（1） 用mallocl类的函数分配内存；（2） 用这些内存支持应用程序；（3） 用free函数释放内存2、 内存泄露如果不再使用已分配的内存却没有将其释放，就会发生内存泄露，导致内存泄露的情况可能如下：（1） 丢失内存地址（2） 应该调用free函数却没有调用对于这种情况，尤其需要注意：指向结构
操作系统c语言模拟页面调度实验（存储管理实验）
11-12
c语言，运行成功，比较基础，模拟存储管理（页面调度），页面淘汰算法采用先进先出（FIFO）
jisuanqi.rar_c语言 成绩管理_学生成绩管理系统 j_成绩管理系统 C语言_输入成绩界面
09-21
C语言是一种结构化编程语言，其语法简洁明了，具有强大的内存管理和低级别的硬件控制能力。在这个系统中，开发者利用C语言的基本语法结构，如变量声明、条件判断（switch语句）、循环控制等，构建出程序的框架。 二...
Desktop_C语言_c语言_
10-04
6. **内存管理**：理解动态内存分配和释放，避免内存泄漏，掌握malloc、calloc、realloc和free等函数的使用。 7. **错误处理**：学会使用errno和perror等函数来检测和处理运行时错误。 在【源代码（1）.txt】、【源...
C语言之内存管理
Arithmetic-logic
03-22 309
C语言内存管理 一.系统中的堆、栈 和 数据结构堆、栈 系统中的堆、栈和数据结构堆、栈不是一个概念。可以说系统中的堆、栈是真实的内存物理区，数据结构中的堆、栈是抽象的数据存储结构。 数据结构堆、栈 1.栈：实际上就是满足后进先出的性质，是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。 2.堆：堆是一种完全二叉树或者近似完全二叉树，完全二叉树是效率很高的数据结...
C语言（八）（精华）：内存管理
热门推荐
Bamboo
10-06 1万+
8.内存管理 8.1 作用域 C语言变量的作用域分为： l代码块作用域(代码块是{}之间的一段代码) l函数作用域 l文件作用域 8.1.1局部变量 局部变量也叫auto自动变量(auto可写可不写)，一般情况下代码块{}内部定义的变量都是自动变量，它有如下特点： l在一个函数内定义，只在函数范围内有效 l在复合语句中定义，只在复合语句中有效 l随着函数调用的结束或复合语句的结束局部变量的声明声明周期也结束 l如果没有赋初值，内容为随机 #include<s...
C语言语句YPR[0]=(BUF[1]＜＜8|BUF[2]),以及 ＞＞ 8 &0xFF如何理解?
刘看山是山的博客
10-10 4214
C语言语句YPR[0]=(BUF[1]<<8|BUF[2])如何理解? 这是一个赋值语句，把等式右边的值赋给左边；先来看左边是怎么运算的， 由于移位运算符<<的优先级大于位运算符|，所以先计算BUF[1]左移八位，然后再或上BUF[2]， 或的操作可以理解为两个数相加；通俗理解的话可以举个列子， 假设BUF[1]的值为0000 0001b(为方便描述，故用二进制表示) ，左移八位后变成10000 0000b ,BUF[2]的值为1 ,然后两者相加变为10000 0001 b 这是算
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值