C语言:动态内存分配

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

在之前的学习中我们已经掌握的内存开辟方式有:

int num = 20;  //在栈空间开辟四个字节
char arr[10] = { 0 };  //在栈空间开辟10个字节的连续空间

上述的开辟空间的方式有两个特点：
   •空间开辟大小是固定的。
   •数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整
但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知
道，那数组的编译时开辟空间的方式就不能满足了。
C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就比较灵活了。 

---

2.动态内存函数 

2.1  malloc----free

 *malloc

void* malloc ( size_t size );

在使用malloc函数之前要包含头文件 # include <stdlib.h> 

 malloc函数通常向内存申请一块连续可用的内存空间，并且返回指向该空间的指针。

注意：

1.如果开辟成功，则会返回一个指向已开辟空间的指针。

2.如果开辟失败，则返回一个 NULL 指针，所以开辟完后要检查malloc的返回值。

3.返回值的类型是 void* ，所以 malloc 函数并不知道开辟空间的类型，需要使用者人为规定。

4.如果参数 size 为0，malloc 的行为标准是未定义的，取决于编译器本身。

#include <stdlib.h>

int main()
{
	//20 个字节 - 存放5个整数
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		perror("malloc");//判断malloc函数申请是否成功
		return 1;
	}
	//使用空间
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i + 1;
	}

    //释放内存
	free(p);//传递给free函数的是要释放的内存空间的起始地址
	p = NULL;

	return 0;
}

 *free

 free函数是专门用来做动态内存的释放和回收的，函数原型如下：

void free ( void* ptr );

注意：

 1.如果参数 ptr 指向的空间不是动态内存开辟的，那 free 函数的行为就是未定义的。

 2.如果参数 ptr 是 NULL 指针，则函数不进行任何动作。

 3.同样的，free 函数使用前要包含头文件 # include <stdlib.h> 

#include<stdlib.h>

int main()
{
    //申请20字节的内存空间
	int*p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");//判断是否申请成功
		return 1;
	}

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);//释放空间
	p = NULL;//将p指针置为NULL空指针

	return 0;
}

---

2.2  calloc----realloc

 *calloc

void* calloc (size_t num, size_t size);

calloc 函数和 malloc 函数十分相似，唯一的区别就是把申请空间的每个字节初始化为0。同样包含于头文件 # include <stdlib.h> 中。

如下列代码：

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

int main()
{
    int *p = (int *)calloc(10,sizeof(int));
    if(p != NULL)
    {
         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 函数来很方便的实现。

 *realloc

 realloc 函数通常可以对动态内存开辟的大小很方便的进行调整。

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

 其中：

 1.ptr 是要调整的地址

 2.size 是调整之后新的大小

 3.返回值为调整之后内存的首地址（起始位置）

 4.realloc 函数在调整原内存空间大小的基础上，还会将原来内存中的数据移到新的内存空间

 5.realloc 函数调整大小有两种情况：

                 第一种情况：原有空间之后有足够的空间用来调整

                 处理方案：要扩展内存就直接在原有内存之后追加空间，原来空间的数据不发生变化

                 第二种情况：原有空间之后没有足够大的空间用来调整

                 处理方案：在堆空间上另外找一个合适大小的连续空间来使用，这样函数会返回一个新                                     的内存地址

 

 

int main()
{
	int* p = (int*)malloc(5 * sizeof(int));//申请20字节的内存空间
	//1 2 3 4 5
	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;
		int i = 0;
		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");//打印错误信息
		free(p);//释放内存空间
		p = NULL;//将指针p置为空指针
	}

	return 0;
}

---

3.常见的动态内存错误

 3.1 对 NULL 指针的解引用操作

void test()
{
    int *ptr = (int *)malloc(INT_MAX/4)//INT_MAX为int类型的最大范围
    *ptr = 20;//如果ptr为NULL就会出现问题
    free(ptr);
}

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

void test()
{
	int i = 0;
	int* ptr = (int*)malloc(sizeof(int) * 10);
	if (ptr != NULL)//保证ptr内存空间开辟成功
	{
		for (i = 0; i <= 10; i++)
		{
			*(ptr + i) = i;//当i=10的时候存在越界访问
		}
	}
	free(ptr);
}

 3.3 对非动态开辟内存的free释放

void test()
{
	int m = 2359;
	int* p = &m;
	free(p);//err--非动态内存申请空间不可以用free()释放
}

 3.4 free函数只释放动态内存空间的一部分

void test()
{
	int* ptr = (int*)malloc(sizeof(int) * 10);
	ptr++;//指针后移，不在指向首地址
	free(ptr);//err--仅释放部分动态内存开辟的内存空间
}

 3.5 对同一块动态内存空间的多次释放

void test()
{
	int* ptr = (int*)malloc(sizeof(int) * 10);
	free(ptr);
	free(ptr);//err--二次释放
}

 3.6 对开辟的动态内存空间忘记释放导致的内存泄漏

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

int main()
{
	test();
	while (1);
	//err--为free释放内存空间导致内存可能泄露
	return 0;
}

---

 4.经典笔试例题

 4.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;
}

错误原因：

1. GetMemory(char* p)在执行完之后形参直接释放了空间，所以strcpy是对NULL进行拷贝，是对NULL进行解引用操作，程序崩溃

2. 未free释放内存空间，导致内存泄露

//修改后
void GetMemory(char** p)//使用二级指针直接传输地址
{
    *p = (char*)malloc(100);
}

void Test(void)
{
    char* str = NULL;
    GetMemory(&str);
    strcpy(str, "hello world");
    printf(str);
    free(str);//释放动态内存空间
    str = NULL;//将指针置为空指针
}

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

 4.2

char* GetMemory()
{
    char p[] = "hello world";
    return p;
}

void Test(void)
{
    char* str = NULL;
    str = GetMemory();

    printf(str);
}

错误原因：p形参的内存空间出函数后内存空间还给操作系统，str为非法访问，str是野指

---

 4.3

void GetMemory(char** p, int num)
{
    *p = (char*)malloc(num);
}

void Test(void)
{
    char* str = NULL;
    GetMemory(&str, 100);

    strcpy(str, "hello");
    printf(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(str);
    str = NULL;
}

 4.4

void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);

    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
}

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

错误原因： 提前释放掉了str的内存空间，造成非法访问内存空间

//修改后

void Test(void)
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);
    str = NULL;

    if (str != NULL)
    {
        strcpy(str, "world");
        printf(str);
    }
    
}

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

---

 5.柔性数组

5.1柔性数组的特点

 1.结构中的柔性数组成员前面至少有一个其他成员

 2.sizeof返回的这种结构大小不包括柔性数组的内存

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

比如：

typedef struct member
{
	int i;//占四个字节
	int a[0];//柔性数组成员
} type_s ;

int main()
{
	printf("%d ", sizeof(type_s));//结果为4
	return 0;
}

5.2 柔性数组的使用

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
		return 1;
	
	ps->arr = (int*)malloc(5*sizeof(int));
	if (ps->arr == NULL)
		return 1;
	//使用
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}

	//调整数组大小
	int*ptr = (int*)realloc(ps->arr, 10*sizeof(int));
	if (ptr != NULL)
	{
		ps->arr = ptr;
	}
	//使用
	//...

	//释放
	free(ps->arr);
	free(ps);

	return 0;
}

5.3柔性数组的优势

第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。