当前位置：首页 > ai >正文

C 语言学习笔记（指针6）

ai 2025/7/28 17:20:10

内容提要

内存操作
- 内存操作的函数

内存操作

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

内存的库函数

内存填充

头文件：#include <string.h>
函数原型

void* memset(void* s, int c, size_t)

函数功能：将内存块s的前n个字节填充为c，一般用于初始化或者清零操作
参数说明：
- s：目标内存首地址
- c：填充值（以unsigned char形式处理0~255）
- n：填充字节数
返回值：
- 成功：返回s的指针
- 失败：返回NULL
注意事项：
- 常用于动态化初始化，c通常设置为0（清零）
- 按字节填充，非整型初始化需要谨慎（如填充int数组时，0是安全的）
案例:

#include <stido.h>
#include <stdilb.h>
#include <string.h>int main()
{// 在堆内存中申请4个int的连续空间int *p = (int*)malloc(4 * sizeof(int));// 非空校验if (p == NULL){perror("内存申请失败！")；return -1；}// 初始化堆内存，填充0memset(p, 0, 4 * sizeof(int));// 测试输出printf("%d\n", p[1]); // p[1] 的底层 *(p+1) 我们可以将p[1]看作是*(p+1)语法糖// 内存使用完毕，释放free(p);// 对指针赋值NULLp = 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 src[4] = {11,22,33,44};int dest[6] = {111,222,333,444,555,666};// 进行拷贝memcpy(dest+1, src+1, 2 * sizeof(int));memmove(dest+1, src+1, 2 * sizeof(int)); // 从src拷贝22,33倒dest的222的位置printf("源数组：");register int i;for(i = 0; i < 4; i++) printf("%-6d", src[i]);printf("\n目标数组：");for(i = 0;i < 6; i++) printf("%-6d", dest[i]);return 0;
}

思考：什么是内存重叠？

内存重叠指在内存操作（如拷贝、移动数据）时，源区域和目标区域的内存地址范围存在部分或完全重叠，导致操作结果出现不确定性。

典型例子：memcpy 与 memmove

memcpy 的隐患
假设拷贝 10字节 从地址 p 到 p+2：
char str[] = "abcdefgh";
memcpy(str + 2, str, 5); // 源和目标重叠，行为未定义！
memcpy 不检查重叠，可能因逐字节拷贝导致数据被意外覆盖（如先覆盖a到c，后续操作又读取被修改的值）。
memmove 的解决方案
同样的操作，使用 memmove 会检测重叠方向：

若目标地址在源之前（正向拷贝），或地址不重叠，直接拷贝。
若目标地址在源之后（反向拷贝），则从尾部开始倒序拷贝，避免覆盖未读取的数据。
memmove(str + 2, str, 5); // 安全处理重叠

内存比较

头文件：#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 <stido.h>
#include <stdilb.h>
#include <string.h>int main()
{// 准备比较的数据int* arr1 = (int*)mallco(3 * sizeof(int)); // 3个元素int* arr2 = (int*)callco(4 * sizeof(in1t)); // 4个元素// 清零memset(arr1, 0, 3 * sizeof(int));// 赋值arr[0] = 60; arr[1] = 66;arr[0] = 70; arr2[1] = 5;// 比较int cmp_result = memcmp(arr2, arr1, 2 * sizeof(int)); // 双方参与比较的字节数完全一致printf("比较结果：%d-(%s)\n", cmp_result, cmp_result > 0 ? "大于" : cmp_result < 0 ? "小于" : "等于");// 释放内存free(arr1);free(arr2);arr1 = arr2 = NULL;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 <stido.h>
#include <string.h>// memrchr是GUN扩展函数，需要外部声明
extern void* memrchr(const void*, int, size_t);int main()
{// 准备一个测试数组char str[] = {'A','B','C','B'};// 查找字符'B'char * first = (char*) memchr(str, 'B', sizeof(str));char * last = (char*) memrchr(str, 'B', sizeof(str)); // GUN扩展函数printf("first = %p, last=%p\n", first, last);printf("第1个B的位置， %ld\n", first -str); // 1printf("最后1个B的位置， %ld\n", last -str);  // 3
}
``