C语言学习第二十二天（动态内存管理）

1、需要动态内存分配的原因

（1）空间开辟的大小是固定的

（2）数组在声明的时候，必须指定数组的长度，一旦数组空间大小确定了就不能改变，所以我们引入了动态内存管理，可以方便我们申请和释放空间。

2、malloc和free

（1）malloc是一个开辟动态内存的函数

void *malloc (size_t size);

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

需要注意的是：如果开辟空间成功，则返回的是一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL型的指针，返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，使用的时候需要自己决定类型。如果size为0，malloc的行为是标准未定义的

（2）free

这个函数专门是用来动态内存的释放和回收的

void free (void* ptr)

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

需要注意的是：如果参数ptr指向的空间不是动态开辟的，那free函数的行为是标准未定义的。如果参数ptr是NULL指针，则函数什么事情都不会做

使用malloc和free函数需要引用头文件#include

下面是一个这两个函数使用的例子

#include
#include

int main()
{
	int num = 0;
	scanf("%d", &num);
	int arr[num] = { 0 };
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (NULL != ptr)
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}

	}
	free(ptr);
	ptr = NULL;
	return 0;
}

3、calloc和realloc

（1）calloc

这个函数也是用来动态内存分配的，和malloc函数很相似，与malloc的区别只在于calloc会在返回地址之前把申请空间的每个字节初始化全为0。

void*calloc(size_t num,size_t size);

函数的功能是为num个大小为size的元素开辟一块空间 ，并且把空间的每个字节初始化为0.

如下面代码所示：

#include
#include

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++) 
		{
			printf("%d", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

输出结果：0 0 0 0 0 0 0 0 0 0 

（2）realloc

这个函数对于内存空间的管理更加的灵活

有时候我们发现之前的空间大小申请小了，或者太大了，为了合理的使用内存，需要对此时的内存做出调整，realloc函数刚好就能够满足

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

ptr是要调整的内存地址

size是调整之后的大小

返回值是调整之后的内存起始位置

这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

realloc在调整内存的时候分为两种情况：原有空间之后有足够大的空间；原有空间之后没有足够大的空间，当是第一种情况的时候，要扩展内存就直接原有内存之后增加空间，原来空间的数据不发生变化。当是第二种情况的时候，原有的空间因为没有足够的空间时，扩展的方法是：在堆空间上另外找一个合适大小的连续空间来使用。这样的函数返回的是一个新的内存地址

对于realloc的使用，可以先将其返回值放一个临时的p指针当中，判断这返回值不是NULL的时候，再将这个值放到ptr当中

4、对于动态内存当中的常见的错误

（1）对NULL指针的解引用操作

void test()
{
    int *p = (int *)malloc(INT_MAX/4);
    *p = 20;
    free(p);
}

（2）对动态开辟空间的越界访问

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
}

（3）对非动态开辟内存使用free函数

void test()
{
   int a = 10;
   int *p = &a;
   free(p);//err 
}

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

void test()
{
  int *p = (int *)malloc(100);
  p++;
  free(p);
}

需要注意的是，这个释放内存p要指向起始位置才可以

（5）对同一块动态内存多次释放

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

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

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

int main()
{
	test();
	while (1);
}

动态内存例题解析

题目一：

void GetMemory(char *p)
 {
 p = (char *)malloc(100);
 }
void Test(void)
 {
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
 }

int main()
{
   Test();
   return 0;
}

因为这个str参数传过去是形参，所以使用函数之后就会被销毁，str的地址和p完全不一样，所以打印p什么都没有

题目二：

char *GetMemory(void)
 {
 char p[] = "hello world";
 return p;
 }
void Test(void)
 {
 char *str = NULL;
 str = GetMemory();
 printf(str);
 }
int main()
{
   Test();
   return 0;
}

这道题本来的意思是想让str的地址换成p的地址，然后打印出来这个字符串，但是这个GetMemery函数中p被开辟之后就会被销毁，所以打印出来是一堆乱码，我们可以在char *p前面加上static，就可以正常打印出来了

题目三：

void GetMemory(char **p, int num)
 {
 *p = (char *)malloc(num);
 }
void Test(void)
 {
 char *str = NULL;
 GetMemory(&str, 100);
 strcpy(str, "hello");
 printf(str);
 }
int main()
{
   Test();
   return 0;
}

这道题目运行出来结果是正确的，与前面不同，在调用GetMemory这个函数的时候，传过去的是二级指针，所以就可以在str所在的位置开辟内存。

题目四：

void Test(void)
 {
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
 }

这样直接使用一个野指针是很危险的行为，所以在使用指针的时候，一定要把这个指针置为空指针NULL。

5、柔性数组

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

因为有些编译器无法正常编译柔性数组，所以可以把a[0]写成a[]

关于柔性数组的特点：
结构中的柔性数组成员前面必须至少需要一个其他成员

sizeof返回的这种节后大小不包括柔性数组的内存

包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

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

int main()
{
	printf("%d\n", sizeof(type_a));
	return 0;
}

这个代码的结果是4，因为柔性数组的大小是不被包括的，只包括了i这个整形的4个字节

第一个代码：

#include
#include

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

int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
	p->i = 100;
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
	}
	free(p);
	return 0;
}

这样相当于柔性数组成员a，相当于获得了100个整形元素的连续空间

柔性数组的优势

第二个代码：

typedef struct st_type
{
	int i;
	int* p_a;
}type_a;

int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));

	for ( int i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
	}

	//释放空间
	free(p->p_a);
	p->p_a = NULL;
	free(p);
    p = NULL;
    return 0;
}

以上两个代码可以完成同样的工作，但各有自己的优点之处：

第一个：方便内存的释放

如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free。所以如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉

第二个：这样有利于访问速度

连续的内存有益于提高访问速度，也有益于减小内存碎片

6、总结C/C++中程序内存区域划分

（1）栈区：在执行函数的时候，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行时函数而分配的局部变量、函数参数、返回数据、返回地址等

（2）堆区（heap）：一般是由程序员分配释放、若程序员不释放、程序结束的时候可能由OS回收。分配方式类似于链表

（3）数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放

（4）代码段：存放函数体（类成员函数和全局函数）的二进制代码