【数据结构】函数与内存分区

最新推荐文章于 2024-08-21 21:40:52 发布

祥云飘飘CJL

最新推荐文章于 2024-08-21 21:40:52 发布

阅读量228

点赞数 1

文章标签：数据结构 java 算法

本文链接：https://blog.csdn.net/kyl_posible/article/details/132050048

版权

每日学习

一、思维导图
c的内存

二、练习题

值传递和值接受、地址传递和地址接收。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/**值传递**/
void swap(int m,int n)
{
	int temp;
	temp=m;
	m=n;
	n=temp;
	
	printf("m=%d,n=%d\n",m,n);
}
/**值传递**/
void fun(int *p,int *q)
{
	int *temp;
	temp=p;
	p=q;
	q=temp;
	printf("*p=%d,*q=%d\n",*p,*q);
}
/**地址传递**/
void swapfun(int *p,int *q)
{
	int temp;
	temp=*p;
	*p=*q;
	*q=temp;
	printf("*p=%d,*q=%d\n",*p,*q);
}
/**值返回**/
int hun()
{
	int value=666;
	return value;
}
/**地址返回**/
int *iun()
{
	static int value=999; 		//静态变量虽然在函数体内定义，但不占函数空间
	return &value; 				//返回静态局部变量的地址
}
int main(int argc, const char *argv[])
{
	int num = 520;
	int key = 1314;

	//调用swap函数交换两数
	swap(num,key);
	printf("调用swap后，主函数中的num=%d，key=%d\n",num,key);
	fun(&num,&key);
	printf("调用fun后，主函数中的num=%d，key=%d\n",num,key);
	swapfun(&num,&key);
	printf("调用swapfun后，主函数中的num=%d，key=%d\n",num,key);
	//调用hun函数
	//hun()=999;
	//3+5=8;
	int ret = hun(); 			//值返回的函数函数值只能是右值
	printf("hun()=%d\n",hun()); //666
	//调用inu函数 
	int *ptr=iun(); 		//地址的返回结可以作为右值
	*iun()=555; 			//地址的返回结可以作为左值
	
	printf("*iun()=%d\n",*iun()); 	//555
	printf("ptr=%d\n",*ptr); 		//555


	return 0;
}

linux@linux:~/study/cde$ gcc 01test.c 
linux@linux:~/study/cde$ ./a.out 
m=1314,n=520
调用swap后，主函数中的num=520，key=1314
*p=1314,*q=520
调用fun后，主函数中的num=520，key=1314
*p=1314,*q=520
调用swapfun后，主函数中的num=1314，key=520
hun()=666
*iun()=555
ptr=555

变量的定义和初始化以及所占的内存空间

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int m; 				//未初始化的全局变量，在全局区的.bss段
int n=520; 			//已初始化的全局变量，在全局区的.data段
static int k;//未初始化的静态变量，在全局区的.bss段
static int l=666;//已初始化的静态变量，在全局区的.data段

char arr[100]="hello world"; 	//arr数组在全局区的.data段，而"hello world"在.ro段
char *p="hello";   //指针在.data段，而"hello"在.ro段

int main(int argc, const char *argv[])
{
	int a;      //局部变量，在战区申请，初始值为随机值
	double b=999;  //局部变量在战区申请
	printf("&a=%p,&b=%p\n",&a,&b);
	static int c; 	 //静态局部变量，在全局区的.bss段申请
	static int d=520;//静态局部变量，在全局区的.data段
	char *q="nihao";//q在战区申请的8字节，但是"nihao"在全局区的.ro段

	int *ptr=(int *)malloc(sizeof(int));//ptr是在战区，而申请的空间在堆区

	return 0;
}

linux@linux:~/study/cde$ gcc 02memory.c 
linux@linux:~/study/cde$ ./a.out 
&a=0x7ffe8f400c0c,&b=0x7ffe8f400c10

申请堆区内存和释放

#include<stdio.h>
#include<stdlib.h> 			//malloc所在的头文件
#include<string.h>
int main(int argc, const char *argv[])
{
	//在堆区申请一个int类型的空间大小
	int *p1=(int *)malloc(4); 	//申请4字节的大小
	printf("*p1=%d\n",*p1); 	//随机值

	int *p2=(int *)malloc(sizeof(int)); 	//申请一个int类型的大小
	*p2=520;
	printf("*p2=%d\n",*p2);//520 

	//连续申请5个int类型的大小
	int *p3=(int *)malloc(sizeof(int)*5);
	//输出默认值
	for(int i=0;i<5;i++)
	{
		printf("%d\t",p3[i]);
		printf("%d\t",*(p3+i));
	}
	putchar(10);

	//释放堆区空间
	free(p1);
	p1=NULL;
	free(p2);
	p2=NULL;
	free(p3);
	p3=NULL;
	return 0;
}

linux@linux:~/study/cde$ gcc 03malloc.c 
linux@linux:~/study/cde$ ./a.out 
*p1=0
*p2=520
0	0	0	0	0	0	0	0	0	0

类型重定义

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

typedef unsigned short int unint16;//将无符号短整型重命名为unint16
typedef int * Ptr_i; 			//将int*类型重命名为Ptr_i
typedef char String[10]; 		//将char[10]类型重命名为String

int main(int argc, const char *argv[])
{
	unint16 num =520;//等价于unsigned short int num = 520
	printf("sizeof num = %ld\n",sizeof(num));//2
	printf("num=%d\n",num);//520

	Ptr_i p1=NULL;//此时p1是指针变量 int *p1；
	printf("sizeof p1=%ld\n",sizeof(p1));//8

	String s1;//此时是定义的长度为10的字符数组
	strcpy(s1,"hello");//hello
	printf("s1=%s\n",s1);//hello
	printf("sizeof s1=%ld\n",sizeof(s1));//10
	return 0;
}

linux@linux:~/study/cde$ gcc 05typedef.c 
linux@linux:~/study/cde$ ./a.out 
sizeof num = 2
num=520
sizeof p1=8
s1=hello
sizeof s1=10

类型重定义

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

typedef int *Ptr_i,int32;//int32是一个int类型的重命名
//Ptr_i是int*类型的重命名

int main(int argc, const char *argv[])
{
	int32 num;//num是一个普通类型
	Ptr_i p;//p是一个int*类型的变量

	printf("sizeof num = %ld\n",sizeof(num)); //4
	printf("sizeof p = %ld\n",sizeof(p)); 	//8
	
	return 0;
}

类型重定义和宏定义的区别

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ptr_i int* 			//会将unit32替换成int
typedef int * pptr_i; 		//类型重定义
int main(int argc, const char *argv[])
{
	ptr_i a,b;//a是指针类型，吧是普通int类型 	int *a,b；
	pptr_i m,n;//m和n都是指针类型

	printf("sizeof a=%ld\n",sizeof(a));//8
	printf("sizeof b=%ld\n",sizeof(b));//4
	printf("sizeof m=%ld\n",sizeof(m));//8
	printf("sizeof n=%ld\n",sizeof(n));//8

	return 0;
}

7.结构体的定义、赋值和调用

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//申明一个英雄结构体类型
struct Hero
{
	char name[20];
	int Hp;
	double speed;
	int kill;
}h3={"牙膏盖",3500,500,5};
//定义一个商品类型，成员属性：商品名称（name）、产地（position）、单价（prince）、重量（weight）
struct          //无名结构体
{
	char name[35];//名称
	char position[50];//产地
	double prince;//单价
	double weight;//重量
}g1={"水牛奶","China",350,1000};

int main(int argc, const char *argv[])
{
	//使用英雄类型定义一个英雄变量
	struct Hero h1={"牙刷",650,350,0};
	//定义英雄变量，指定某个成员进行赋值
	struct Hero h2={.Hp=2000,.speed=1000};
	//输出英雄变量h1中的所有内容
	printf("h1.name=%s\n",h1.name);
	printf("h1.Hp=%d\n",h1.Hp);
	printf("h1.speed=%lf\n",h1.speed);
	printf("h1.kill=%d\n",h1.kill);
	//在堆区申请一个英雄类型，完成初始化并输出相应的属性
	struct Hero *ptr=(struct Hero*)malloc(sizeof(struct Hero));
	//给英雄名字赋值
	strcpy(ptr->name,"牙刷毛");//给姓名赋值
	ptr->Hp=3000;//给Hp赋值
	ptr->speed=350;
	ptr->kill=3;
	//输出英雄指针指向堆区空间中的内容
	printf("英雄信息为：%s %d %.2lf %d\n",ptr->name,ptr->Hp,ptr->speed,ptr->kill);


	//使用商品结构体定义一个商品变量，不用初始化，使用scanf将每个属性进行输入
	//输入完该变量后，再将该变量的所有信息输出
	scanf("%s %s %lf %lf",g1.name,g1.position,&(g1.prince),&(g1.weight));//输入信息
	printf("%s %s %lf %lf",g1.name,g1.position,g1.prince,g1.weight);//输出信息
	putchar(10);//换行
	return 0;
}

linux@linux:~/study/cde$ gcc 08struct.c 
linux@linux:~/study/cde$ ./a.out 
h1.name=牙刷
h1.Hp=650
h1.speed=350.000000
h1.kill=0
英雄信息为：牙刷毛 3000 350.00 3
薯片 中国上海 15 25
薯片 中国上海 15.000000 25.000000