动态内存管理

目录

1.为什么存在动态内存管理

2.动态内存函数的介绍

2.1malloc和free

2.2calloc

 2.3realloc

3.常见的动态内存错误

4.柔性数组

4.1柔性数组的概念

4.2柔性数组的特点

4.3柔性数组的使用

 4.4柔性数组的的优势

---

1.为什么存在动态内存管理

 当然我们已经掌握的内存开辟方式：

int a=10;//局部变量-在栈空间上开辟了四个空间

int g_a=10;//全局变量-静态区

 

 但是上述的开辟空间的方式有两个特点：

       1. 空间开辟大小是固定的。

       2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编 译时开辟空间的方式就不能满足了。 这时候就只能试试动态存开辟了。

注意：有人会说c语言是可以创建变长数组的我们可以这样写：

struct stu{
  char name[20];
   int age;
}
int main(){
  int n=0;  
  scanf("%d",&n);
  struct stu arr[n];
   return 0;
}

的确在C99中引入了这个标准，但是很多编译器不支持此标准，从而会报错，故此方法不可行。

2.动态内存函数的介绍

2.1malloc和free

动态内存开辟的函数代码示例：

void* malloc ( size_t size );

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用自己来决定。 

C 语言提供了另外一个函数 free ，专门是用来做动态内存的释放和回收的，函数原型如下：

void free ( void* ptr );

free函数用来释放动态开辟的内存。

• 如果参数 ptr 指向的空间不是动态开辟的，那 free 函数的行为是未定义的.
• 如果参数 ptr 是 NULL 指针，则函数什么事都不做。

malloc 和 free 都声明在 stdlib.h 头文件中。代码示例：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//向内存申请10个整型的空间
	int* p = (int*)malloc(10 * sizeof(int));//int*强制类型转化为整型
	if (p == NULL) {
		//开辟空间失败，打印错误原因
		printf("%s\n", strerror(errno));
	}
	else {
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10; i++) {
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++) {
			printf("%d", *(p + i));
		}
	}
	//当动态内存空间不在使用的时候
	//就应该还给操作系统
	free(p);
	p = NULL;
	return 0;
	}

2.2calloc

calloc函数动态内存分配。原型如下：

void* calloc ( size_t num , size_t size ); 

• 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。 
• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全 0 。 代码如下：

 2.3realloc

• realloc 函数的出现让动态内存管理更加灵活。
• 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存， 我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。 函数原型 如下：

  void* realloc ( void* ptr , size_t size );

• ptr 是要调整的内存地址 ,size 调整之后新大小 ,返回值为调整之后的内存起始位置。
• 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。

realloc使用的注意事项:

   1.如果p指向的空间之后有足够大的内存空间可以追加，则直接追加，后返回0

   2.如果p指向的空间之后没有足够大的内存空间可以追加，则realloc函数会重新找一个新的内存区域开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间,最后返回新开辟的内存空间地址。

   3.得到新的变量来接受realloc函数的返回值，防止relloc开辟空间失败将前面开辟好的空间也销毁

代码如下：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//向内存申请10个整型的空间
	int* p = (int*)malloc(20);//int*强制类型转化为整型
	if (p == NULL) {
		//开辟空间失败，打印错误原因
		printf("%s\n", strerror(errno));
	}
	else {
		//正常使用空间
		int i = 0;
		for (i = 0; i < 10; i++) {
			*(p + i) = i;
		}
	}
	int* ptr = realloc(p, 40);
	if (ptr != NULL) {
		p = ptr;
		int i = 0;
		for (i = 5; i < 10; i++) {
			*(p + i) = i;
		}
		for (i = 0; i < 10; i++) {
			printf("%d", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
	}

3.常见的动态内存错误

• 对 NULL 指针的解引用操作

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
	}

万一malloc开辟空间失败，则p将被赋值为空指针，所以malloc使用时一定要对其返回值判断是否为空指针。

• 对动态开辟空间的越界访问

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL) {
		return 0;
	}
	else {
		int i = 0;
		for (i = 0; i < 10; i++) {
			*(p + i) = i;
		}
	}
	free(p);
	p = NULL;
	return 0;
	}

malloc只开辟了5个整型元素，而for循环访问10个造成越界访问，程序崩溃。

• 对非动态开辟内存使用 free 释放

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a = 10;
	int* p = &a;
	*p = 20;
	free(p);
	return 0;
	}

• 使用 free 释放一块动态开辟内存的一部分

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL) {
		return 0;
	}
	else {
		int i = 0;
		for (i = 0; i < 10; i++) {
			*p++ = i;
		}
	}
	free(p);
	p = NULL;
	return 0;
	}

p在此过程中已经发生变化，则不是我们完整的开辟空间，如果要释放只能从开辟的起始位置释放，故错误。

• 对同一块动态内存多次释放

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

• 动态开辟内存忘记释放（内存泄漏）

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

用过之后没有释放空间，会不断消耗内存，有可能会导致服务器崩溃。

切记： 动态开辟的空间一定要释放，并且正确释放 。

4.柔性数组

4.1柔性数组的概念

也许你从来没有听说过 柔性数组（ flflexible array ） 这个概念，但是它确实是存在的。 C99 中，结构中的最

后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员

 代码如下：

typedef struct st_type
{
 int i;
 int a[];//柔性数组成员
}type_a;

4.2柔性数组的特点

•  结构中的柔性数组成员前面必须至少一个其他成员。
• sizeof 返回的这种结构大小不包括柔性数组的内存.
• 包含柔性数组成员的结构用 malloc () 函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应 柔性数组的预期大小。

4.3柔性数组的使用

代码1：

#include<stdio.h>
struct S {
	int n;
	int arr[0];
};
int main()
{
	struct S* s = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 5; i++) {
		s->arr[i] = i;
	}
	struct S* ps = realloc(s, 44);
	if (ps!= NULL) {
		s = ps;
		for (i = 5; i < 10; i++) {
			s->arr[i] = i;
		}
	}
	for (i = 0; i < 10; i++) {
		printf("%d", s->arr[i]);
	}
	free(s);
	s = NULL;
	return 0;
}

 代码2：

#include<stdio.h>
struct S {
	int n;
	int* arr;
};
int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
	ps->arr = malloc(5 * sizeof(int));
	int i = 0;
	for (i = 0; i < 5; i++) {
		ps->arr[i] = i;
	}
	for (i = 0; i < 5; i++) {
		printf("%d\n", ps->arr[i]);
	}
	int* ptr = realloc(ps->arr, 10 * sizeof(int));
	if (ptr!= NULL) {
		ps->arr = ptr;
		for (i = 5; i < 10; i++) {
			ps->arr[i] = i;
		}
	}
	for (i = 0; i < 10; i++) {
		printf("%d ", ps->arr[i]);
	}
	free(ps->arr);
	free(ps);
	ps = NULL;
	return 0;
}

 4.4柔性数组的的优势

通过对比上述的代码1和代码2，代码1的实现有俩个好处：

1.方便内存释放

2.有利于访问速度