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

关注

原创最新推荐文章于 2026-08-24 19:55:41 发布 329 阅读 AI 写同款· GEO 优化 ›

基于分段线性近似的Softmax硬件加速器设计本文深入探讨了基于分段线性近似的Softmax硬件加速器设计。针对深度学习模型中Softmax函数在硬件实现时指数运算成本高昂的问题，提出用分段线性拟合替代传统泰勒展开，通过一次乘加操作高效完成计算，并详细分析了输入范围压缩、精度与硬件资源权衡、以及包含地址生成、参数查找、乘加计算和归一化的完整硬件架构。该方法在保证精度的同时，显著提升了AI边缘芯片的推理速度和能效。阅读详情

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

常用函数

malloc

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

示例：

/*************************************************************************
  > File Name:    demo01.c
  > Author:       三道渊
  > Description:  
  > Created Time: 2025-07-31 09:31:49
 ************************************************************************/
#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

示例：

/*************************************************************************
  > File Name:    demo01.c
  > Author:       三道渊
  > Description:  
  > Created Time: 2025-07-31 09:50:17
 ************************************************************************/
#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

示例：

/*************************************************************************
  > File Name:    demo03.c
  > Author:       三道渊
  > Description:  
  > Created Time: 2025-07-31 10:21:26
 ************************************************************************/
#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。

内存操作

我们对于内存操作需要依赖于string.h头文件中相关的库函数。

常用函数

内存填充

头文件：#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是安全的）

案例：

/*************************************************************************
  > File Name:    demo04.c
  > Author:       三道渊
  > Description:  
  > Created Time: 2025-07-31 11:03:23
 ************************************************************************/
#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能正确处理内存重叠，推荐优先使用
- 确保目标内存足够大，避免溢出。

示例：

/*************************************************************************
  > File Name:    demo05.c
  > Author:       fpf
  > Description:  
  > Created Time: 2025-07-31 11:23:20
 ************************************************************************/
#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
注意事项：比较按字节进行，非字符串需确保长度一致（总字节数一致）。

示例：

/*************************************************************************
  > File Name:    demo06.c
  > Author:       三道渊
  > Description:  
  > Created Time: 2025-07-31 11:41:20
 ************************************************************************/
#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语言标准提供，编译的时候都需要手动声明或链接）
- 查找单位为字节值，非整型数据需要注意内存布局

示例：

/*************************************************************************
  > File Name:    demo07.c
  > Author:       三道渊
  > Description:  
  > Created Time: 2025-07-31 14:24:24
 ************************************************************************/
#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;
}