内存分配

最新推荐文章于 2023-01-29 22:48:43 发布

countryboy666

最新推荐文章于 2023-01-29 22:48:43 发布

阅读量81

点赞数

本文链接：https://blog.csdn.net/weixin_43785588/article/details/84887938

版权

/*重点：动态内存分配
堆内存
内存分配的方式：静态存储区分配（静态变量，全局变量）栈上分配（局部变量，参数），堆中分配动态分配:全局的（malloc ralloc ralloc free）
动态内存分配和释放函数
内存包括数据段（静态存储区（初始化区未初始化区），常量区）
内存分布（代码段，数据段，堆，栈）
void *malloc(size_t size)功能：分配连续的内存
size :所需字节数
返回的是void *指针

#include<stdio.h>
#include<malloc.h>
void out(int p, int n)
{
int i;
for(i=0;i<n;i++)
{
printf("%d\n",(p+i));
printf("--------------\n");

}

}
int main()
{
printf(“intput number:”);
int n;
scanf("%d",&n);
int *p=(int )malloc(nsizeof(int));//在堆内存是全局的声明周期是整个进程
if(p!=NULL)
{
out(p,n);
int i;
for(i=0;i<n;i++)

(p+i)=ii;
out(p,n);
free§;

}else{
printf(“error!”);
}

}

void *calloc(size_t num_element,size_t elsement_size);
做初始化
size_t num_element所需数量size_t elsement_size每个元素的字节数
size_t 无符号32位整形

#include<stdio.h>
#include<stdlib.h>
void out(int p, int n)
{
int i;
for(i=0;i<n;i++)
{
printf("%d\n",(p+i));
printf("--------------\n");

}

}
int main()
{
printf(“intput number:”);
int n;
scanf("%d",&n);
int *p=(int *)calloc(n,sizeof(int));//在堆内存是全局的声明周期是整个进程
if(p!=NULL)
{
out(p,n);
int i;
for(i=0;i<n;i++)

(p+i)=ii;
out(p,n);
free§;

}else{
printf(“error!”);
}

}

realloc函数
void *realloc(void *ptr,size_t new_size);
在molloc和calloc分配的基础上
返回指针新的首地址

#include<stdio.h>
#include<stdlib.h>
void out(int p, int n)
{
int i;
for(i=0;i<n;i++)
{
printf("%d\n",(p+i));
printf("--------------\n");

}

}
int main()
{
int *p=(int *)calloc(5,sizeof(int));
*p=1;
(p+1)=2;
p[2]=3;
p[3]=4;
(p+4)=5;
out(p,5);
printf("%p",p);
printf("------------\n");
p=(int)realloc(p,7sizeof(int));
if(p==NULL) exit(1);
*(p+5)=6;
*(p+6)=7;
out(p,7);
printf("%p",p);
free§;
p=NULL;

printf("*****after free*****");
//*(p+6)=77;
//out(p,7);
printf("%p",p);

}

void free(void *ptr)
释放动态内存
free§只能调用一次；

//教师管理管理的
#include<stdio.h>
//#include “teacher.h”
#include <stdlib.h>
#include <malloc.h>
//<element.h>
struct teacher
{
int id;
int age;
char *name;
float slary;

};
typedef struct teacher Element;
typedef struct teacher* Pelement;

//<teacher.h>
//#include
typedef unsigned int uint;

extern void create(uint size);
extern void destroy();
extern void add(Pelement p);
extern void insert(uint index,Pelement p);
extern void del(uint index);
extern Pelement get(uint index);
extern uint size();
extern void iterate();

//<teacher.c>
//#include"teacher.c"
//#include <stdio.h>
//#include<sdtlib.h>
//#include <malloc.h>

static Pelement list; //结构体指针
static uint list_size;//默认初始化，本文件使用

static uint counter;

static uint is_full();
static uint is_empty();

static void resize(uint increment);

void create(uint size)
{
list=(Pelement)calloc(size,sizeof(Element));
if(list==NULL)
{

	printf("creat teacher error\n");
	exit(1);
}
list_size=size;
counter=0;

}

void destroy()
{
if(list==NULL) exit(1);
free(list);
list=NULL;
list_size=0;
counter=0;

}
void add(Pelement p)
{
if(listNULL ||pNULL)
{
printf(“add teacher error\n”);
exit(1);

}
if(is_full){
	
	resize(2);
}
list[counter++]=*p;

}

void insert(uint index,Pelement p)
{
if(listNULL || pNULL)
{
printf(“add teacher error\n”);
exit(1);

}
if(is_full)
	resize(2);

int i;
for(i=counter;i>index;i--)
{
	
	list[i]=list[i-1];
	
	
}
list[index]=*p;
counter++;

}
void del(uint index)
{

if(list==NULL)
{
	printf("delete teacher error\n");
	exit(1);
	
}
if(is_empty())
{
	printf("teacher is empty\n");
	exit(1);
	
}
for(int i=index;i<counter-1;i++)
{
	list[i]=list[i+1];
	
	
}
counter--;

}
Pelement get(uint index)
{

if(list==NULL)
{
	printf("add teacher error\n");
	exit(1);
	
}

return list+index;

}
uint size()
{
return counter;

}

void iterate()
{
if(list==NULL)
{
printf(“teacher is empty\n”);
exit(1);

}
int i;
for(i=0;i<counter;i++)
{
	printf("%d %s %d %.2f\n",(list+i)->id,(list+i)->name,(list+i)->age,(list+i)->slary);
	
}

}

static uint is_full()
{
return counter>=list_size;

}

static uint is_empty()
{
return counter==0;

}

static void resize(uint increment)
{
list=(Pelement)realloc(list,(increment+list_size)*sizeof(Element));
if(list==NULL)
{
printf(“teacher is empty\n”);
exit(1);

}
list_size+=increment;

}

//#include<stdio.h>
//#include “teacher.h”
//#include <stdlib.h>
//#include <malloc.h>

int main (void)
{
Element e1={1,“tom”,25,3000};
Element e2={2,“to”,25,4000};
Element e3={3,“tm”,25,5000};
*
Pelement p1=(Pelement)calloc(1,sizeof(Element));
p1->id=1;
p1->name=“tom”;
p1->age=25;
p1->slary=3000;

Pelement p2=(Pelement)calloc(1,sizeof(Element));
p2->id=2;
p2->name=“tom”;
p2->age=25;
p2->slary=3000;

Pelement p3=(Pelement)calloc(1,sizeof(Element));
p3->id=3;
p3->name=“tom”;
p3->age=25;
p3->slary=3000;

create(3);
add(p1); //add(&e1)
add(p2);//add(&e2)
add(p3);//add(&3)

iterate();
printf(“\n");
Pelement p4=(Pelement)calloc(1,sizeof(Element));
p4->id=4;
p4->name=“tom”;
p4->age=25;
p4->slary=3000;
insert(1,p4);
Pelement p5=(Pelement)calloc(1,sizeof(Element));
p5->id=5;
p5->name=“tom”;
p5->age=25;
p5->slary=3000;
add(p5);
iterate();
printf("\n”);
del(2);
iterate();
printf("**********************\n");
Pelement p=get(3);
printf("%s",p->name);
printf("%d",size());

destroy();
free(p1);
free(p2);
free(p3);
free(p4);
free(p5);
p1=NULL;
p2=NULL;
p3=NULL;
p4=NULL;
p5=NULL;

}

struct teacher
{

}

typedef unsigned int uint;

void sort_data(Pelement data, uint n, *(comp)(Pelement,Pelement))
*/
#include<stdio.h>
#include<stdlib.h>
typedef unsigned int uint;

struct teacher
{
int id;
int age;
char *name;
float salary;

};
typedef struct teacher Element;
typedef struct teacher* Pelement;

int comp(Pelement p1,Pelement p2)
{
if(p1->salary>p2->salary) return 1;
if(p1->salary>p2->salary) return -1;
if(p1->salary>p2->salary) return 0;

}
//回调函数
//data 排序的数据 n teacher 的数量

void data_sort(Pelement data,uint n,int (*comp)(Pelement,Pelement))
{
if(dataNULL||comp0)
{
printf(“error”);

	exit(1);
}
int i,j;
for(i=0;i<n-1;i++)
{
int pos=i;
for(j=i;j<n;j++){
		if(comp(data+j,data+pos)<0)
	  pos=j;
}
if (pos!=i)
{
	Element temp;
	  temp=*(data+i);
	  *(data+i)=*(data+pos);
	  *(data +pos)=temp;
	
}
}

}

//p指向结构体数组
Pelement data()
{
Pelement p =(Pelement)calloc(3,sizeof(Element));
if(p==NULL)
{
printf(“get data error\n”);
exit(1);

p[0].id=1; //p->id
p[0].name=“zhang”;
p[0].age=29;
p[0].salary=3000;

p[1].id=1; //p+1;
p[1].name=“zhang”;
p[1].age=24;
p[1].salary=3300;

p[2].id=1; //p+2
p[2].name=“zhang”;
p[2].age=21;
p[2].salary=30030;

return p;

}
void out(Pelement p,uint n)

{
if(p==NULL)
{
printf(“out data error\n”);
exit(1);

}

for(int i=0;i<n;i++)
{
	printf("%d %s %d %.2f\n",
	(p+i)->id,(p+i)->name,(p+i)->age,(p+i)->salary);
	
	
	
}

}
int main(void)
{
Pelement p=data();

out(p,3);
printf("***************\n");
data_sort(p,3,compare);
out(p,3);


return 0;

}

countryboy666

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
内存分配

/*重点：动态内存分配堆内存内存分配的方式：静态存储区分配（静态变量，全局变量）栈上分配（局部变量，参数），堆中分配动态分配:全局的（malloc ralloc ralloc free）动态内存分配和释放函数内存包括数据段（静态存储区（初始化区未初始化区），常量区）内存分布（代码段，数据段，堆，栈）void *malloc(size_t size)功能：分配连续的内存size :...
复制链接

扫一扫