C语言内存函数

思维导图：

1. memcpy使用和模拟实现

前言：

strcpy是针对字符串的

 void * 是无类型指针，不能直接运算和赋值，得先转成具体类型。

memcpy 函数的返回值是目标空间的起始地址，在编程中，函数名前面加 my_ 通常是开发者为了区分自定义函数和系统库函数而起名的。用于模拟实现的功能。

void * memcpy ( void * destination, const void * source, size_t num );

1. 函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。
2. 这个函数在遇到 '\0' 的时候并不会停下来。
3. 如果source和destination有任何的重叠，复制的结果都是未定义的。

#include <stdio.h>
#include <string.h>
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[10] = { 0 };
  memcpy(arr2, arr1, 20);
  int i = 0;
  for (i = 0; i < 10; i++)
  {
     printf("%d ", arr2[i]);
  }
   return 0;
}

对于重叠的内存，交给memmove来处理。

void * memcpy ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
  assert(dst);
  assert(src);
  /*
  * copy from lower addresses to higher addresses
  */
    while (count--) 
  {
  *(char *)dst = *(char *)src;
  dst = (char *)dst + 1;
  src = (char *)src + 1;
  }
   return(ret);
}

模拟实现2：

vvoid* my_memcpy(void* dest,const void* src, size_t num)
{
  assert(dest && src);//void*的指针不能直接运算，要类型转换//转换成什么类型合适呢?
  void* ret = dest;
  while (num--)
  {
       *(char*)dest=*(char*src;
       src =(char*)src + 1:
       dest=(char*)dest + 1;
  }
   return ret;
}
vint main()
{
  int arr1[]= { 1,2,3 4,5,6,7 8,9,10 };
  //112123458910 
  my_memcpy(arr1+2，arr1，20);
  memcpy(arr1 +2，arr1，20);//不是所有的编译器都能正确的处理
  memmove(arr1 +2,arrl,20);
}

2. memmove 使用和模拟实现

void * memmove ( void * destination, const void * source, size_t num );

1. 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
2. 如果源空间和⽬标空间出现重叠，就得使⽤memmove函数处理。

ps：

memmove 可以看作是 memcpy 的 “增强版” 或 “安全升级版”，两者的核心功能都是内存复制，但最大的区别在于对内存重叠的处理：
memcpy：简单直接地从源地址向目标地址复制数据，不处理内存重叠。如果源地址和目标地址的内存区域有重叠（比如你说的 “数组叠加” 场景），可能会导致复制结果错误（尚未复制的源数据被已复制的目标数据覆盖）。
memmove：在复制前会先判断源地址和目标地址是否存在重叠，若存在重叠则通过从后往前复制的方式避免数据覆盖，确保复制结果正确。

在不确定源和目标内存是否重叠时，使用 memmove 更安全；若能确保内存不重叠，memcpy 可能会略快一些

#include <stdio.h>
#include <string.h>
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  memmove(arr1+2, arr1, 20);
  int i = 0;
  for (i = 0; i < 10; i++)
  {
printf("%d ", arr1[i]);
  }
return 0：
}

输出结果：

2.1 memmove的模拟实现：

void * memmove ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
//先保存原始目标地址，最终返回它（符合 C 标准库的设计规范）
  if (dst <= src || (char *)dst >= ((char *)src + count)) 
//这是整个函数的关键判断，用于检测内存是否重叠：
 {
   /*
   * Non-Overlapping Buffers
   * copy from lower addresses to higher addresses
   */
   while (count--) //非重叠内存复制（正向复制）
  {
   *(char *)dst = *(char *)src;
   dst = (char *)dst + 1;
   src = (char *)src + 1;
  }
 }
else //重叠内存复制（反向复制）
{
  /*
  * Overlapping Buffers
  * copy from higher addresses to lower addresses
  */
  dst = (char *)dst + count - 1;
  src = (char *)src + count - 1;
  while (count--) 
  {
  *(char *)dst = *(char *)src;
  dst = (char *)dst - 1;
  src = (char *)src - 1;
  }
 }
return(ret);
}

代码分析：

第一步：

• 函数参数：dst（目标地址）、src（源地址）、count（复制字节数）

第二步：重叠判断条件

• dst <= src：目标地址在源地址左侧，肯定不重叠
• (char *)dst >= ((char *)src + count)：目标地址在源地址右侧且不重叠
• 满足以上任一条件，说明内存不重叠，使用正向复制

第三步：非重叠内存复制（正向复制）

• 从低地址到高地址逐个字节复制
• 每次复制后，源地址和目标地址都向后移动 1 字节
• count-- 作为循环条件，完成count次复制后结束

第四步： 重叠内存复制（反向复制）

• 当内存重叠时（目标地址在源地址中间区域），先将指针定位到复制区域的末尾
• 从高地址向低地址复制，避免覆盖还未复制的源数据
• 每次复制后，指针向前移动 1 字节

第五步：返回值

2.2 memcpy 和 memove 区别实例

示例场景验证

以 "123456" 复制到重叠区域为例：

• 源：src = "123456"（地址 0x1000）
• 目标：dst = src + 2（地址 0x1002）
• 复制 4 字节：count = 4

判断结果：dst > src且dst < src + count（存在重叠），进入反向复制：

1. 指针定位到末尾：src→0x1003（'4'），dst→0x1005（原 '6' 位置）
2. 反向复制：'4'→0x1005，'3'→0x1004，'2'→0x1003，'1'→0x1002
3. 最终结果："112344"（正确保留了原始数据）

如果用memcpy的正向复制，会得到错误结果"121234"。

3. memset 函数的使用

 void * memset ( void * ptr, int value, size_t num );

#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] = "hello world";
  memset (str,'x',6);
  printf(str);
  return 0;
}

输出结果：

3.1 memset 的深入理解

因为 memset 函数的 设计本质就是按字节操作 ，而字符串相关场景里的“看似按元素”，其实是字符类型本身特性（1 字节）带来的巧合，以下展开解释：

1. 先看 memset 的底层逻辑

memset 是 C 标准库 <string.h> 里的函数，核心作用是「按字节」填充内存 。

它的函数原型是：
         void *memset(void *s, int c, size_t n);

1. • s 是要填充的内存起始地址；
2. • c 是要填充的“字节值”（虽然参数写 int ，但实际只取低 8 位，也就是 1 个字节的数据）；
3. • n 是要填充的 字节数量 。

不管你操作的是 char 数组、int 数组还是其他类型，memset 永远逐字节修改内存 。

2. 看这段 char 字符串操作：

char arr[] = "hello world";
memset(arr+2, 'x', 7);

• char 类型本身 占 1 个字节 ，所以 memset 填 1 个字节，刚好对应 1 个 char 元素 。

• 填充 7 个字节，就相当于替换 7 个 char 元素，表现出“按元素替换”的效果。

3. 再看 int 数组操作：

int arr[ ] = {1,2,3,4,5,6,7,8,9,10};
memset(arr, 0, 40);

• int 类型在多数环境下 占 4 个字节 ，memset 填 40 个字节，本质是把 arr 前 40 / 4 = 10 个 int 元素的内存，逐个字节填成 0 。

• 最终效果是数组元素全变成 0 ，但这不是 memset 直接按“int 元素”处理 ，而是逐字节填 0 后，int 元素的 4 个字节全 0 ，自然值为 0 。

4. 总结

• memset 本质：永远「按字节」操作内存，和数组元素类型无关。

• 字符串场景的“像按元素”：因为 char 刚好 1 字节，填 1 字节 ≈ 替换 1 个元素

• int 数组的“按字节”：int 占 4 字节，填 n 字节会影响 n/4 个元素，本质还是逐字节填。

5. 实例

vint main()
{
 //0x 00 00 00 01
 int arrl[] = { 1,2.3.4.5 };
 //01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
 //01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 01 33 23 12
 int arr2[]= { 1,2,3,4,0x12233301 };
 //0x 12 23 33 01int r=memcmp(arrl,arr2,17);
 printf("%d\n"，r);
 //0x 00 00 00 05
 return 0;
}

1. C 语言中 int 通常是 4 字节（32 位），所以数值 5 会用 4 个字节存储，高位补 0，形成 0x00000005。
2. 工具显示整数值时，会按 “高位在前” 的逻辑（类似大端视觉），所以直接显示 0x00000005

4. memcmp 函数的使用

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

1. 比较从ptr1和ptr2指针指向的位置开始，向后的num个字节，直接对比两块内存的二进制内容
2. memcmp 是 C 语言标准库（<string.h>）里的函数

返回值如下【逐字节看 ASCII（或二进制）值】：

• 若某字节 ptr1 < ptr2 → 返回负数（通常是 -1，但标准没强制，取决于编译器实现）。
• 若某字节 ptr1 > ptr2 → 返回正数（通常是 1）。
• 若 num 字节全相同 → 返回 0。

int a[] = {1, 2};       // 内存：01 00 00 00  02 00 00 00
int b[] = {1, 0x02000003}; // 内存：01 00 00 00  03 00 00 02
// 对比前 8 字节（2 个 int），第 5 字节（a 是 02，b 是 03）不同 → 返回负数
int res = memcmp(a, b, 8); 

代码参考：

#include <stdio.h>
#include <string.h>
int main()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";
  int n;
  n = memcmp(buffer1, buffer2, sizeof(buffer1));
  if (n > 0)
  printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
  else if (n < 0)
  printf("'%s' is less than '%s'.\n", buffer1, buffer2);
  else
  printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
 return 0;
}