【C语言】动态内存管理

原创已于 2025-10-18 10:56:00 修改 · 971 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#c语言

于 2024-07-29 15:12:31 首次发布

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

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

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

（1）空间开辟大小时确定的

（2）数组在申明时必须指定数组的长度，数组空间一旦确定了大小就不能调整

而C语言引入的动态内存开辟让程序员自己可以申请和释放空间。

2.malloc和free

2.1.malloc

malloc是C语言提供的一个动态内存函数。包含在stdlib.h文件中，函数原型如下：

void* malloc (size_t size);

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

（1）如果开辟成功，则返回一个指向开辟好空间的指针

（2）如果开辟失败，则返回一个NULL 指针，因此malloc的返回值⼀定要做检查。

（3）返回值类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

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

（5）使用 malloc 分配的内存空间不会自动进行初始化，其内容是未定义的。在使用完动态分配的内存后，需要使用 free 函数释放，以避免内存泄漏。内存泄漏是指程序在运行过程中不断地分配内存但未释放，导致可用内存逐渐减少，最终可能影响程序的正常运行。

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;
		printf("%d ", p[i]);//0 1 2 3 4
	}
    free(p);
    p = NULL;
	return 0;
}

2.2.free

void free (void* ptr);

- free 函数也是 C 语言标准库中的函数，用于释放由malloc 、calloc或realloc 函数分配的动态内存空间。
- 使用 free 函数的主要作用在于及时回收不再使用的内存，防止内存泄漏。
- 当使用 free 释放内存后，该内存空间将被标记为可重新分配，但指针 ptr 本身并不会被修改或自动设置为 NULL ，为避免后续对已释放内存的非法访问，通常建议在释放后将指针置为 NULL 。

（1）参数 ptr 是要释放的内存块的指针，该指针必须是先前通过动态内存分配函数（如malloc 等）获取的有效指针，如果指向的空间不是动态内存开辟的，则free的行为是未定义的。

（2）如果参数ptr是NULL指针，则函数什么事都不做

#include <stdio.h>
#include <stdlib.h>
int main()
{
;   int i = 0;
	int arr[10] = { 0 };
	int* ptr = (int*)malloc(10 * sizeof(int));
	if (ptr != NULL)
	{
		for (i = 0; i < 10; i++)
		{
			*(ptr + i) = i;
			printf("%d ", ptr[i]);
		}
	}
	free(ptr); //释放ptr所指向的动态内存
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ptr[i]);
	}
	ptr = NULL;
	return 0;
}

3.calloc和realloc

3.1.calloc

calloc也是C语言中的一个动态内存分配函数，原型如下：

void* calloc (size_t num, size_t size);

（1）函数的功能是在内存的动态存储区中分配 num 个大小为 size 的连续空间，并且把空间的每个字节初始化为0。

（2）与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0

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));//0 0 0 0 0 0 0 0 0 0
		}
	}
	free(p);
	p = NULL;
	return 0;
}

3.2.realloc

realloc函数用于重新调整之前通过 malloc 、calloc 或 realloc 分配的内存块的大小。其原型通常为

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

（1）ptr是指向要调整大小的内存块的指针， size 是新的大小（以字节为单位）。

（2） realloc 函数的作用包括：

1. 扩大内存块：如果新的大小大于原来的大小， realloc 会尝试在原内存块的基础上扩展，如果后面有足够的可用空间，就直接扩展并返回原指针；如果没有足够的连续空间，会重新分配一块新的更大的内存，并将原内存块中的内容复制到新的内存块中，然后释放原内存块，返回新内存块的指针。

2. 缩小内存块：如果新的大小小于原来的大小， realloc 会缩小内存块，并保留原内存块中前面 size 字节的内容，多余的部分被释放。

（3）使用 realloc 时需要注意返回值，如果重新分配内存成功，返回值为调整之后的内存起始位置。如果失败（例如内存不足），则返回 NULL ，并且原内存块不会被释放。

（4）使用 realloc 分配或调整大小后的内存，在不再使用时也需要使用 free 函数进行释放。

int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		perror(malloc);
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = i;
		printf("%d ", p[i]);//0 1 2 3 4
	}
	printf("\n");

	//将内存调整为40个字节
	int* ptr = (int*)realloc(p, 40);
	if (NULL != ptr)
	{
		p = ptr;
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
			printf("%d ", *(p + i));//0 1 2 3 4 5 6 7 8 9
		}
		free(p);
		p = NULL;
	}
	else
	{
		perror(ptr);
	}
	return 0;
}

4.常见动态内存的错误

（1）对NULL的解引用操作

int main()
{
	int* p = (int*)malloc(20);
	*p = 20;//如果内存开辟失败，p是空指针，就会有问题
	free(p);
	return 0;
}

正确示例：

int main()
{
	int* p = (int*)malloc(20);
	if (p = NULL)
	{
		perror(p);
		return 1;
	}
	*p = 20;
	free(p);
	return 0;
}

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

int main()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (p = NULL)
	{
		perror(p);
		return 1;
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;
		printf("%d ", *(p + i));//当i是10时越界访问
	}
	free(p);
	return 0;
}

（3）对非动态分配内存使用内存释放

int main()
{
	int n = 1;
	int* p = &n;
	free(p);//free用来释放动态内存空间
	return 0;
}

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

free 必须释放动态内存的起始地址

int main()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	free(p);//此处不是动态开辟内存的起始位置
	p = NULL;
	return 0;
}

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

int main()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);
	return 0;
}

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

test()
{
	int* p = (int*)malloc(100);
	if (p != NULL)
	{
		*p = 20;//内存不释放，while不断循环，不断占用内存
	}
}
int main()
{
	test();
	while (1);
	return 0;
}

5.柔性数组

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

柔性数组（Flexible Array）是指在结构体的末尾定义一个长度不定的数组。它之所以被称为“柔性数组”，主要是因为其具有一定的灵活性和特殊性。当结构体所包含的数据长度不固定，或者需要在分配结构体内存时根据实际情况动态确定数组的大小时，柔性数组可以避免额外的内存分配和指针操作，提高程序的性能和效率，通过动态存储函数设置结构体的大小，即可改变结构体最后一个元素的大小，这也是“柔性”的来源。

//两种方式
typedef struct type_st
{
	int i;
	int arr[];//柔性数组成员
}type;
typedef struct type_st
{
	int i;
	int arr[0];//柔性数组成员
}type;

（1）柔性数组的特点

结构中的柔性数组成员前面必须至少一个其他成员。

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

typedef struct type_st
{
	int i;
	int arr[];//柔性数组成员
}type;
int main()
{
	printf("%d\n", sizeof(type));//4
	return 0;
}

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

typedef struct type_st
{
	int i;
	int arr[];//柔性数组成员
}type;

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

（2）柔性数组的优势

 struct S 
{
	int i;
	int arr[];//柔性数组成员
};

int main()
{
	int i = 0;
	struct S* p = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
	if (p == NULL)
	{
		perror(p);
		return 1;
	}
	for (i = 0; i < 5; i++)
	{
		p->arr[i] = i;
	}
	//调整内存
	
	struct S* ptr = (struct S*)realloc(p, sizeof(struct S) + 10 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}

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

使用柔性数组有两个好处：

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

第二个好处是：这样有利于访问速度. 连续的内存有益于提高访问速度，也有益于减少内存碎片。