C语言---动态内存管理

 C/C++总述：Study C/C++-CSDN博客

一、动态内存函数

1. malloc

描述：

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

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己
来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

声明：

void* malloc (size_t size);

参数：

size -- 内存块的大小，以字节为单位

2.free

描述：

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

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

假设p指向通过malloc动态开辟的空间，当空间被free释放后，p就成了野指针，因此free完后还要将p指针置为空

声明：

void free (void* ptr);

 参数：

ptr -- 指针指向一个要释放内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果传递的参数是一个空指针，则不会执行任何动作。

3.calloc

描述：

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

声明：

void* calloc (size_t num, size_t size);

 参数：

num -- 要被分配的元素个数。

size -- 元素的大小。

4.realloc

描述：

重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。

声明：

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

参数：

ptr -- 指针指向一个要重新分配内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针，则会分配一个新的内存块，且函数返回一个指向它的指针。

size -- 内存块的新的大小，以字节为单位。如果大小为 0，且 ptr 指向一个已存在的内存块，则 ptr 所指向的内存块会被释放，并返回一个空指针。

注意：

realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用，将之前的数据拷贝过来，并将旧地址释放掉。这样函数返回的是一个新的内存地址

二、常见动态内存错误

2.1对NULL指针的解引用操作

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

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

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

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

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

void test()
{
    int *p = (int *)malloc(100);
    p++;
    free(p);//p不再指向动态内存的起始位置
}

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

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

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

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

忘记释放不再使用的动态开辟的空间会造成内存泄漏

切记：

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

---

  柔性数组（flexible array）

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

特点：

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

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4

使用：

typedef struct S
{
	int a;
	int arr[];
} S;

int main()
{
	int i = 0;
	//申请内存用于存储我们定义的结构体，用一个结构体指针进行维护，为柔性数组成员申请了5个元素的空间
	S* p = (S*)malloc(sizeof(S) + 5 * sizeof(int));
	if (p == NULL)
	{
		return 0;
	}

	p->a = -1;
	//将结构体中的柔性数组成员初始化
	for (i = 0; i < 5; i++)
	{
		p->arr[i] = i;
	}
	//打印结构体a成员
	printf("%d\n", p->a);

	//打印结构体arr成员
	for (i = 0; i < 5; i++)
	{
		printf("%d ", p->arr[i]);
	}
	printf("\n");

	//调整malloc申请空间大小，增加5个整型元素空间
	S* ptr = (S*)realloc(p, sizeof(S) + 10 * sizeof(int));

	//如果调整失败，则结束程序，调整成功，将返回的新地址赋值给指针p
	if (ptr == NULL)
	{
		return 0;
	}
	p = ptr;
	ptr = NULL;

	//将arr后面增加的元素，进行赋值
	for (i = 5; i < 10; i++)
	{
		p->arr[i] = i;
	}

	//打印新增加的结构体arr成员
	for (i = 5; i < 10; i++)
	{
		printf("%d ", p->arr[i]);
	}
	printf("\n");

	//释放内存
	free(p);
	p = NULL;
	return 0;
}

 内存分析

 使用柔性数组是为了结构体中的数组成员大小可以变化下面的结构体也可以实现类似功能：

typedef struct S
{
	int a;
	int* arr;
} S;

int main()
{
	int i = 0;
	S* p = (S*)malloc(sizeof(S));
	//判断空间是否申请成功
	if (p == NULL)
	{
		return 0;
	}

	//申请5个整形元素大小空间，将空间地址赋值给结构体对象的arr成员，让arr成员维护这空间的数据
	(int*)p->arr = (int*)malloc(5 * sizeof(int));
	//判断空间是否申请成功
	if (p->arr == NULL)
	{
		return 0;
	}

	p->a = -1;
	printf("%d\n", p->a);

	//将arr指针存储地址对应空间的5个整形元素，进行赋值
	for (i = 0; i < 5; i++)
	{
		p->arr[i] = i;
	}

	//根据arr中存储的地址，进行5个整型元素的打印,打印所指空间的内容
	for (i = 0; i < 5; i++)
	{
		printf("%d ", p->arr[i]);
	}
	printf("\n");

	//若arr所指数组长度不满足我们所需，我们可以进行调整
	int* ptr = (int*)realloc(p->arr, 10 * sizeof(int));
	//判断是否调整成功
	if (ptr == NULL)
	{
		return 0;
	}

	//调整成功，将ptr赋值给p指向的arr成员
	p->arr = ptr;
	ptr = NULL;

	//根据arr存储的地址，将新增加的空间进行赋值
	for (i = 5; i < 10; i++)
	{
		p->arr[i] = i;
	}

	//根据arr存储的地址，将新增加的空间中存储的内容进行打印
	for (i = 5; i < 10; i++)
	{
		printf("%d ", p->arr[i]);
	}
	printf("\n");

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

}

上述代码可以完成同样的功能，但是柔性数组的实现有两个好处：

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

拓展阅读：C语言结构体里的成员数组和指针 | 酷 壳 - CoolShell