C语言：动态内存分配，内存操作

最新推荐文章于 2025-08-03 15:54:10 发布

悟2134

最新推荐文章于 2025-08-03 15:54:10 发布

阅读量1.1k

点赞数 40

CC 4.0 BY-SA版权

文章标签： c语言开发语言

本文链接：https://blog.csdn.net/wuin129/article/details/149813036

动态内存分配

要实现动态内存分配，需要使用标准C库提供的库函数，我们所说的动态内存分配，其实就是在堆区申请内存（此时的内存回收需要程序员自身来维护）

常用函数

malloc

头文件：#include <stdlib.h>
函数原型：
```
 void* malloc(size_t size);
```
功能：分配指定字节数的内存到堆区，返回指向内存块首地址的指针。内存内容未初始化（随机值）。
参数：
- size：要分配的内存大小（字节），这里的size_t是数据类型 unsigned long int的别名。
返回值：
- 成功：返回内存指针（申请到的内存的首地址）
- 失败：失败返回NULL

示例：

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

int main(int argc, char *argv[])
{
	// 新建一个指针变量，用来接收内存分配后返回的堆内存首地址
	int *p = malloc(sizeof(int)); // 4字节 这里尽量不使用常量
	
	// 对于指针的使用，一定要进行有效性校验，防止野指针
	if(p == NULL){ // 等价于 !p
		perror("内存申请失败！");// 这个函数用于向控制台输出异常信息
		return -1;
	}
	
	// malloc申请的内存空间，默认填充的是随机值，需要我们手动清零
	memset(p,0,sizeof(int)); // 对指定空间赋值0，支持批量赋值
	
	// 向这块空间赋值
	*p = 100;
	// 访问这块空间
	printf("%d\n", *p);
	
	// 堆空间使用完毕，一定要释放内存，此时需要程序员写代码释放
	free(p);
	
	// 如果指针对应的内存被释放，此时指针需要置空，防止产生空悬指针
	p = NULL;
	
	
	return 0;
}

注意事项：
- 分配内存后需要手动初始化内存，推荐memset或calloc
- 内存空间连续，不可越界访问

calloc

头文件：#include <stdlib.h>

函数原型：

 void* calloc(size_t nitems, size_t size);

功能：动态分配内存，并初始化为0
参数：
- nitems：元素个数
- size：每个元素的字节大小
返回值：
- 成功：返回内存指针（申请到的内存的首地址）
- 失败：失败返回NULL

示例：

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

#define LEN 5

int main(int argc, char *argv[])
{
	// 创建一个指针变量，用来接收内存分配后返回的堆内存地址
	int *arr = calloc(LEN, sizeof(int)); // 等价于 int *arr = malloc(LEN * sizeof(int); memset(arr,0,LEN * sizeof(int));
	
	// 对于指针的使用，一定要进行非空检验，防止野指针
	if (arr == NULL) // 等价于 !arr
	{
		perror("内存申请失败！");
		return -1;
	}
	
	// 使用for循环快速赋值
	for (int i = 0; i < LEN; i++)
	{
		if(i % 2 == 0) continue;
		arr[i] = (i+1)*10;
	}
	
	// 遍历数组
	int *p = arr;
	for (; p < arr + LEN; p++)
	{
		printf("%-6d", *p);
	}
	printf("\n");
	
	// 内存使用完毕，释放内存
	free(arr);
	// 置空，防止产生空悬指针
	arr = p = NULL;
	
	return 0;
}

使用场景：为数组分配内存时更安全高效。

realloc

头文件：#include <stdlib.h>
函数原型：
```
 void* realloc(void* ptr, size_t size);
```
功能：调整已分配内存块的大小，可能迁移数据到新地址。扩容后，空余位置是随机值，需要手动清零。
原理：
- 当前内存空间后面的剩余空间足够扩容，就在原空间基础上进行扩容，返回原地址；
- 当前内存空间后面的剩余空间不够扩容，会重新开辟一块空间，将原空间数据按顺序拷贝后，销毁原空间，返回新地址。扩容后的内存空间中的数据是随机的。需要手动清零。
参数：
- ptr：原内存指针（需要扩容的内存空间的指针，这个ptr的来源（malloc/calloc/realloc））
- size：指定重新分配内存的大小（字节）
返回值：
- 成功：返回内存指针（申请到的内存的首地址）
- 失败：失败返回NULL

示例：


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

#define LEN 5
#define NEW_LEN 8
#define NEW_LEN_MIN 3

int main(int argc, char *argv[])
{
	// 创建一个指针，指向堆内存分配的内存空间
	int *arr = (int*)calloc(LEN, sizeof(int));
	
	// 指针的非空检验，防止野指针
	if (!arr){
		perror("内存申请失败！");
		return -1;
	}
	
	// 使用for循环赋值
	for (int i = 0; i < LEN; i++)
	{
		arr[i] = (i+1)*10;
	}
	
	// 遍历数组
	int *p = arr;
	for (; p < arr + LEN; p++) printf("%-6d", *p); printf("\n");
	
	// 扩容数组
	int *temp = (int*)realloc(arr, NEW_LEN * sizeof(int)); // 扩容出来的空间，默认是随机值
    // 非空校验，防止野指针
	if(!temp){
		perror("内存申请失败！");
        free(arr); // 扩容失败，回收原空间
		return -1;
	}
	
	// 更新数组指针
	arr = temp;
	// 对扩容部分清零
	memset(arr+LEN,0,(NEW_LEN - LEN) * sizeof(int));
	
	// 修改数组元素
	arr[7] = 666;
	
	// 遍历数组
	for (int i = 0; i < NEW_LEN; i++) printf("%-6d", *(arr+i)); printf("\n");
	
	// 缩容数组
	temp = (int*)realloc(arr, 0); // 此时，会回收掉内存，等价于free(arr);
	// 非空校验，防止野指针
	if(!temp){
		perror("内存申请失败！");
		return -1;
	}
	
	// 更新数组指针
	arr = temp;

	// 遍历数组
	for (int i = 0; i < NEW_LEN; i++) printf("%-6d", *(arr+i)); printf("\n");
	
	// 释放内存
	free(arr);
	arr = NULL;
	p = NULL;
	
	return 0;
}

注意事项：
- 分配后需要手动初始化内存，推荐memset
- 必须用临时变量接收返回值，避免直接覆盖原指针导致内存泄漏。
- 若size为0，等效于free(ptr)

free

头文件：#include <stdlib.h>
函数原型：void free(void* ptr);
功能：释放动态分配的内存。
注意事项：
- 只能释放一次，重复释放会导致程序崩溃。
- 释放后应将指针置为NULL，避免野指针。
- 栈内存由系统自动释放，无需手动free。
头文件：#include <string.h>
函数原型：
```
void* memset(void* s, int c, size_t n);
```
函数功能：将内存块s的前n个字节填充为c，一般用于初始化或者清零操作。
参数说明：
- s：目标内存首地址
- c：填充值（以unsigned char形式处理（0~255））
- n：填充字节数
返回值：
- 成功：返回s的指针
- 失败：返回NULL
注意事项：
- 常用于动态初始化，c通常设置为0（清零）
- 按字节填充，非整型初始化需要谨慎（如填充int数组时，0是安全的）

案例：

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

#define LEN 4

int main(int argc, char *argv[])
{
	// 在堆内存申请4个int的连续空间
	int *p = (int*)malloc(LEN * sizeof(int));
	
	// 非空校验
	if (!p){
		perror("内存申请失败！");
		return -1;
	}
	
	// 初始化堆内存空间，填充0，我们也可以称作 清零操作
	memset(p, 0, LEN * sizeof(int));
	
	// 测试输出
	printf("%d,%d\n", p[1], *(p+1));
	
	// 释放内存
	free(p);  // 等价于 realloc(p,0);
	
	// 对指针置空，防止空悬指针
	p = NULL;
	
	return 0;
}

内存拷贝

头文件：#include <string.h>

函数原型：

源与目标内存无重叠时使用

 void* memcpy(void* dest, const void* src, size_t n);

安全处理内存重叠

 void* memmove(void* dest, const void* src, size_t n);

函数功能：将src的前n个字节拷贝到dest
参数说明：
- dest：目标内存首地址，支持指针偏移
- src：源内存首地址，支持指针偏移
- size_t n：拷贝的字节数
返回值：
- 成功：返回dest的首地址
- 失败：返回NULL
注意事项：
- memmove能正确处理内存重叠，推荐优先使用
- 确保目标内存足够大，避免溢出。

示例：

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
	// 准备两个数组，用来存储源和目标
	int src[4] = {11,22,33,44}; // 拷贝 22,33  从src+1开始，拷贝2个sizeof(int)
	int dest[6] = {111,222,333,444,555,666}; // 目的地 dest+1，拷贝后：111,22,33,444,555,666
	
	register int i = 0;
	printf("拷贝前：");
	for (i = 0; i < 6; i++) printf("%-6d", dest[i]);
	
	// 进行拷贝
	// memcpy(dest+1,src+1,2 * sizeof(int));
	memmove(dest+1, src+1, 2 * sizeof(int));
	
	printf("\n拷贝后：");
	for (i = 0; i < 6; i++) printf("%-6d", dest[i]); printf("\n");
	
	return 0;
}

内存比较

头文件：#include <string.h>

函数原型：

int memcmp(const void* s1, const void* s2, size_t n);

函数功能：比较s1和s2的前n个字节
返回值：
- 0：内存内容相同
- >0：s1中第一个不同字节大于s2
- <0：s1中第一个不同字节小于s2
注意事项：比较按字节进行，非字符串需确保长度一致（总字节数一致）。

示例：

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
	// 准备两个测试用的数组
	int src[] = {111,22,33,44};
	int dest[] = {111,22,10,44,555,666};
	
	// 进行比较
	int result = memcmp(src, dest, 4 * sizeof(int)); 
	printf("%d与%d的比较结果是%d\n",*src, *dest, result);
	
	return 0;
}

内存查找

头文件：#include <string.h>
函数原型：
- 正向查找，C语言标准库函数
```
void* memchr(const void* s, int c, size_t n);
```
- 逆向查找，这个不是C语言标准库函数，属于GNU扩展
```
void* memrchr(const void* s, int c, size_t n);
```
函数功能：在s的前n个字节中查找字符c
返回值：
- 成功：返回找到内容对应的地址
- 失败：返回NULL
注意事项：
- memrchr是GNU扩展函数，需手动声明（只要不是C语言标准提供，编译的时候都需要手动声明或链接）
- 查找单位为字节值，非整型数据需要注意内存布局

示例：

#include <stdio.h>
#include <string.h>
// #include <stddef.h>

// 逆向查找函数 memrchr是GNU扩展函数，这个函数需要额外声明
extern void* memrchr(const void*, int, size_t);

//void* memrchr(const void* s, int c, size_t n) {
//	const unsigned char* ptr = (const unsigned char*)s + n;
//	while (n--) {
//		if (*--ptr == (unsigned char)c) {
//			return (void*)ptr;
//		}
//	}
//	return NULL;
//}

int main(int argc, char *argv[])
{
	// 准备一个测试数组
	char str[] = {'A','B','C','B'};
	
	// 查找字符 B
	char* first = (char*)memchr(str, 'B', sizeof(str)); // 返回 低地址对应的字符地址
	char* last  = (char*)memrchr(str, 'B', sizeof(str)); // GNU扩展函数，返回 高地址对应的字符地址
	
	printf("first=%p,last=%p\n", first, last);// first=0x7fff65a47875,last=0x7fff65a47877
	printf("第1个B的位置：%ld\n", first - str);// 1
	printf("最后1个B的位置：%ld\n", last - str);// 3
	
	return 0;
}