C语言快速入门之动态内存管理

    1.为什么要有动态内存分配？

        我们已经知道的内存开辟方式有：

int a;
char arr[20];

        当他们创建时，空间开辟的大小是固定的，且创建好后，大小就无法调整，例如我们想描述某个班级的数学成绩，这个班级的学生有30人，我们写int arr[30]，但有的班有26人，会有内存浪费，而有的班级有35人，导致了数组的越界

        那么，C语言是否允许程序员自己来动态的申请空间呢？这就是动态内存分配

2.动态内存分配四大函数详解

        动态分配与四个函数有关，他们都放在stdlib.h头文件中。

2.1 malloc

malloc是一个动态内存开辟的函数，它的函数原型是

void* malloc(size_t size);

输入开辟空间的大小(字节的长度)，向内存申请一块连续可用的空间，输出开辟空间的首地址，如果开辟失败，会返回NULL。

int main()
{
	//存放5个整数
	int* p = (int)malloc(20);

	//使用空间
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}


	return 0;
}

        我们使用malloc函数如上，但是我们会发现，可能会开辟失败，返回的指针为NULL，这是使用就会导致出错，因此我们在使用前需要判断是否成功的开辟了空间。

int main0()
{
	//存放5个整数
	int* p = (int)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	
	return 0;
}

        同时，这是我们动态申请的空间，需要有内存的释放和回收。

2.2 free

        free函数就是专门用来动态内存的释放和回收的，他会把空间的使用权返回给操作系统，它的函数原型是

void free(void* ptr)

        传入的内容是释放空间的首地址，不返回值，如果ptr为NULL，则什么都不做。

        因此，上面的代码完整应该是这样

int main0()
{
	//存放5个整数
	int* p = (int)malloc(20);
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}
	//释放内存,传入释放空间的起始地址，只能释放动态内存
	//把空间的使用权限还给了操作系统
	free(p);
	p = NULL;	//避免成为野指针

	return 0;
}

        记得，在我们释放后动态内存空间后，指针就变为了野指针，因此我们需要把它置为NULL

        请注意，free只能释放动态内存的空间，不能用来free数组或者其他的东西。

2.3 calloc

        calloc也是用来开辟动态内存空间的，他的函数原型如下：

void* calloc(size_t num,size_t size);

        为num个大小为size的元素开辟一块空间，返回空间的起始地址，并且把所有的内容置为0

        举个例子：

#include <stdio.h>
#include <stdlib.h>
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

        如果我们需要对申请的内存空间初始化，那么可以使用calloc来完成任务

2.4 realloc

        realloc可以更改动态开辟内存的大小

        它的函数原型如下：

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

输入原本动态空间的起始地址和改变后的大小，返回更改后的动态空间的起始地址，再更改地址的时候，会有两种情况。

第一个情况是可以在原本的动态空间后仍有未分配的空间，我们就会进行分配，返回值是原本的ptr地址

第二种情况是原本的动态空间后不足以再分配空间，这个函数会执行以下的操作：
在堆栈中找到一个符合要求的内存空间，然后将原来空间的内容拷贝到新空间中，释放旧空间的内存，最后返回新空间的起始地址。

第三种情况是在堆栈中无法找到对应的内存空间，此时会返回NULL

int main()
{
	int* p = (int*)malloc(20);//20
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}

	//将空间调整为40个字节
	int* ptr = (int*)realloc(p, 40);
	if (ptr != NULL)
	{
		p = ptr;
		for (i = 5; i < 10; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
		free(p);
		p = NULL;
	}
	else
	{
		perror("realloc");
	}
	//40个字节的空间

	return 0;
}

        最后记得free和将指针置为空

3.常见的动态内存的错误

对NULL指针的解引用操作

void test()
{
    int *p = (int *)malloc(INT_MAX/4);
    *p = 20;//如果p的值是NULL，就会有问题 
    free(p);
}

这里申请了一块非常大的空间，堆栈中是无法申请的，会返回NULL，这里直接对NULL指针进行了解引用

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

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;//当i是10的时候越界访问 
    }
     free(p);
}

在这个代码种，我们申请了10个int空间也就是40个字节的大小，但是在后面的应用，我们却访问更改了11个int类型，这里导致了越界

对非动态内存的free释放

int main()
{
    int arr[10] = { 0 };
    free(arr);
}

使用free释放一块动态内存空间的一部分

void test()
{
    int *p = (int *)malloc(100);
    p++;
    free(p);//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.动态内存经典题目

题目一

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

这个出现了很多错误

1.内存泄漏，没有free        2.GetMemory函数中，没有返回值，因此str还是NULL

因此，我们应该这样更改

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

题目二

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

GetMemory中，返回数组p的地址，但是数组p是在函数中创建的，因此会在函数结束时被释放，因此返回的地址str会成为野指针

题目三

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

忘记了free，内存泄漏

题目四

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

应该先判断是否为空，没有free

5.柔性数组

C99中，结构体的最后一个元素是数组，这个数组没有固定的大小，叫做柔性数组

struct S
{
    int n;
    int a[0];    //int a[];
}

结构中的柔性数组成员前⾯必须⾄少⼀个其他成员。 

sizeof返回的这种结构⼤⼩不包括柔性数组的内存。

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

#include <stdio.h>
#include <stdlib.h>
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;
}

方便内存释放，有利于访问速度