C内存动态分配

C内存动态分配

一、动态内存分配

1.内存分配方式

• 静态内存区域分配
  • 内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量、static变量。

数据	区域
全局变量、静态数据	data area
所有函数代码	code area
为运行函数而分配的局部变量、函数参数、返回数据、返回地址等	stack area
动态内存分配区	heap area

• 在栈上分配

  • 在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。效率很高，但是分配的内存容量有限。

• 从堆上分配 亦称 动态内存分配

  • 程序在运行的时候用malloc等函数申请任意多少内存，程序员自己负责在何时用free释放内存。动态内存的生命周期由我们决定，使用灵活，但问题也最多。
  • 在堆里的变量是全局变量

2.动态内存分配和释放函数

• malloc函数
  void *malloc(size_t size);
  • 功能：允许从空闲内存池中分配连续内存但不初始化
  • 参数：size参数是一个所需字节数的整数
  • 返回：若分配成功则返回一个指向该内存块的指针，在使用时可根据需要做强制类型转换;若申请不成功，比如需求大于了可分配空间，则返回NULL(空指针)。

#include<malloc.h>

/*向系统申请一个大小为n*4个字节的内存块*/
	int *p=(int*)malloc(n*sizeof(int));//存储n个整型数据
	if(p != NULL){
		out(p,n);//输出数组
		int i;
		for(i=0;i<n;i++)*(p+i)=i*i;
		out(p,n);
		/*释放资源*/
		free(p);
		p=NULL;//防止成为野指针
	}
	else printf("malloc error\n");

• calloc函数
  void *calloc(size_t num_elements, size_t element_size);
  • 功能：功能同malloc函数，但作初始化。
  • 参数：num_elements是所需元素的数量，element_size是每个元素所占字节数
  • 返回：同malloc函数

int *p=(int*)calloc(n,sizeof(int));

• realloc函数–扩展内存块大小
  void *realloc(void *ptr,size_t new_size);
  • 功能：在指针ptr指向的内存基础上扩大或缩小内存(动态数组)。注意不是加上原来的内存大小!
  • 参数：ptr是指先前通过malloc、calloc和realloc函数后分配的内存块的指针，new_size是内存块的新尺寸，可能大于或小于原有内存尺寸。
  • 返回：若能调整内存大小则返回指向调整后内存的指针，否则返回NULL。

p=(int*)realloc(p,7*sizeof(int));

• realloc函数的使用注意点

  • 当扩展内存时，不会对添加进内存块的字节进行初始化。
  • 若不能调整内存则返回NULL，但原有内存中的数据不会发生改变。
  • 若第一个参数为NULL，那么功能等同于malloc函数，若第二个参数为0,那么会释放调用内存块
  • 在缩小或扩大内存时一般不会对其进行移动(在原来块上扩展)，若无法扩大内存块(内存块后面字节已经用于其他目的)，那么可能会在别处分配新的内存块，然后把旧块中的数据复制到新块中，并将旧块删除释放内存。

• free函数
  void free(void *ptr);

  • 功能：释放由指针ptr指向的动态分配的内存块
  • 注意点：
    • 如果ptr是NULL指针，那么free对ptr无论操作多少次都不会出问题
    • 如果ptr不是NULL指针，那么free对ptr连续操作两次就会导致程序运行错误。

二、常见内存错误

1.常见内存错误及避免

• 使用未分配成功的内存

  • 避免方式：在使用之前检查指针是否为NULL

• 引用分配成功但尚未初始化的内存

  • 避免方式：赋初值

• 内存分配成功并且已经初始化，但操作越过了内存的边界

• 避免方式：注意下标的使用不能超出边界

• 忘记释放内存，造成内存泄露

  • 避免方式：动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则会出问题。

• 释放了内存却继续使用它

  • 避免方式：使用free释放内存后，将指针设置为NULL。若没有设置NULL，就会产生野指针，它是指向“垃圾”内存的指针。

2.内存错误的注意点和野指针

• 内存错误的注意点

  • 指针消亡了，并不表示它所指的内存会被自动释放。（如未调用free前将指针设为NULL）
  • 内存被释放了，并不表示指针会消亡或者成了NULL指针。（如调用了free但没有设置指针为NULL）

• 野指针

  • 野指针的形成是指针变量没有被初始化，任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。
  • 指针变量在创建同时应当被初始化，或为NULL，或指向合法的内存。
  • 使用free释放内存后需要将指针设置NULL，若没有设置则会产生野指针。

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

void malloc_test(int size){
	int *p=NULL,*s=NULL;
	p=(int*)malloc(size*sizeof(int));
	if(p==NULL)exit(1);
	for(s=p;s<p+size;s++)printf("%d ",*s);
	printf("\n");
	printf("before free p:%p\n ",p);
	free(p);
	printf("after free p:%p\n ",p);//p同free前
	
	//p=NULL;
	
	if(p!=NULL){
	for(s=p;s<p+size;s++)printf("%d ",*s);
	printf("\n");
	}
	p=NULL;
}

int main(){
	int size;
	printf("please input byte size of mem:");
	scanf("%d",&size);
	malloc_test(size);
	return 0;
}

三、案例—教师管理功能的实现

案例介绍：实现教师的创建、动态增加、删除、查找等功能。

案例设计：

• 使用动态内存分配在堆空间中创建教师信息
• 使用动态数组来存放创建的一组教师信息

思路：教师为一个结构体变量。使用内存函数开辟动态空间。

/*
文件名：element.h
描述：声明结构体teacher，定义类型别名ElementType和PElementType
*/
struct teacher{
    int id;      int age;
    char *name;  float salary;
};
typedef struct teacher ElementType;
typedef struct teacher* PElementType;

==================================================================
/*
文件名：teacher.h
描述：声明对教师操作的函数原型
*/
#include "element.h"
typedef unsigned int uint_t;
/*创建指定大小的动态数组*/
extern void create(uint_t);
/*销毁动态数组*/
extern void destroy();
/*往动态数组中加入teacher*/
extern void add(PElementType p);
/*在动态数组的指定位置插入teacher*/
extern void insert(uint_t index,PElementType p);
/*删除指定的teacher*/
extern void del(uint_t index);
/*获得指定的teacher*/
extern PElementType get(uint_t index);
/*获得teacher的数量*/
extern uint_t size();
/*遍历动态数组中的teacher*/
extern void iterate();
================================================================================

/*
文件名：teacher.c
描述：教师操作的函数功能实现
*/
#include"teacher"
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

/*定义一个指针list指向动态数组*/
static PElementType list;
/*list_size指定动态数组的大小*/
static uint_t list_size;
/*counter来统计teacher的实际数量*/
static uint_t counter;

/*判断动态数组是否满*/
static uint_t is_full();
/*判断动态数组是否为空*/
static uint_t is_empty();
/*扩展动态数组*/
static void resize(uint_t increment);

/*创建指定大小的动态数组*/
extern void create(uint_t size){
	list=(PElementType)calloc(size,sizeof(PElementType));
	if(list==NULL){
		printf("creat error\n");exit(1);
	}
	list_size=size;
	counter=0;
}
/*销毁动态数组*/
extern void destroy(){
	if(list==NULL)exit(1);
	free(list);
	list=NULL;
	list_size=0;
	counter=0;
}
/*往动态数组中加入teacher*/
extern void add(PElementType p){
	if(list==NULL||p==NULL){
		printf("add error\n");exit(1);
	}
	if(is_full())resize(2);//判断数组满则另辟2个元素空间
	list[counter++]=*p;
}
/*在动态数组的指定位置插入teacher*/
extern void insert(uint_t index,PElementType p){
	if(list==NULL||p==NULL){
		printf("insert error\n");exit(1);
	}
	if(is_full())resize(2);
	int i;
	//插入就是将插入下标后面的元素都往后移一个。counter是指向最后一个后面一个位置
	for(i=counter;i>index;i--)list[i]=list[i-1];
	list[index] = *p;
	counter++;
}
/*删除指定的teacher*/
extern void del(uint_t index){
	if(list==NULL){printf("delete error\n");exit(1);}
	if(is_empty()){printf("teacher is empty\n");exit(1);}
	int i;
	//删除就是把数往前覆盖，最后一个数可以不动，后面增加时会自动覆盖
	for(i=index;i<counter-1;i++)list[i]=list[i+1];
	counter--;
}
/*获得指定的teacher*/
extern PElementType get(uint_t index){
	if(list==NULL){printf("get error\n");exit(1);}
	return list+index;
}
/*获得teacher的数量*/
extern uint_t size(){
	return counter;
}
/*遍历动态数组中的teacher*/
extern void iterate(){
	if(list==NULL){printf("iterate error\n");exit(1);}
	int i;
	for(i=0;i<counter;i++)printf("id:%d name:%s age:%d salary:%.2f\n",
			(list+i)->id,(list+i)->name,(list+i)->age,(list+i)->salary);
}

/*判断动态数组是否满*/
static uint_t is_full(){
	return counter >= list_size;
}
/*判断动态数组是否为空*/
static uint_t is_empty(){
	return counter == 0;
}
/*扩展动态数组*/
static void resize(uint_t increment){ //传入的是扩展老师的个数
	list = (PElementType)realloc(list,
		(list_size+increment)*sizeof(ElementType));
	if(list==NULL){printf("resize capacity error\n");exit(1);}
	list_size += increment;
}
======================================================================

/*
文件名：teacher_management.c
描述：教师操作的调用程序
*/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "teacher.h"

int main(void){
	/*在堆上分配*/
	PElementType p1=
		(PElementType)calloc(1,sizeof(ElementType));
	p1->id=1;
	p1->name="Tom";
	p1->age=22;
	p1->salary=5000;
	
	PElementType p2=
		(PElementType)calloc(1,sizeof(ElementType));
	p2->id=2;
	p2->name="Nana";
	p2->age=24;
	p2->salary=4000;
	
	PElementType p3=
		(PElementType)calloc(1,sizeof(ElementType));
	p3->id=3;
	p3->name="Tata";
	p3->age=26;
	p3->salary=5000;
	
	create(3);
	add(p1);add(p2);add(p3);
	iterate();
	printf("**********************\n");
	
	PElementType p4=
		(PElementType)calloc(1,sizeof(ElementType));
	p4->id=4;
	p4->name="Lala";
	p4->age=28;
	p4->salary=8000;
	insert(1,p4);
	
	PElementType p5=
		(PElementType)calloc(1,sizeof(ElementType));
	p5->id=5;
	p5->name="Dola";
	p5->age=20;
	p5->salary=3000;
	add(p5);
	iterate();
	printf("**********************\n");
	del(2);iterate();
	printf("**********************\n");
	PElementType p=get(3);
	printf("name:%s\n",p->name);
	printf("teacher total:%d\n",size());
	
	destroy();
	free(p1);free(p2);free(p3);free(p4);free(p5);
	p1=NULL;p2=NULL;p3=NULL;p4=NULL;p5=NULL;
	
	return 0;
}