当我们超越字符串的边界，进入更底层的领域，便会遇见直接操作内存的工具——mem系列函数。它们不关心数据是字符、数字还是结构体，仅以原始的字节视角高效处理内存块。无论是大块数据的快速复制（memcpy）、重叠区域的稳妥搬运（memmove），还是内存的批量初始化（memset）与精确比较（memcmp），这些函数都是系统编程、算法实现和性能优化的基石。掌握它们，意味着你真正开始以计算机的方式“思考”数据在内存中的流动与组织。
目录
1.memcpy函数使用和模拟实现
2.memmove函数使用和模拟实现
3.memset函数使用和模拟实现
4.memcmp函数使用和模拟实现
1.memcpy函数使用和模拟实现
函数原型：
void* memcpy(void* destination, const void* source, size_t num);destination：目标内存起始地址（接收拷贝数据）source：源内存起始地址（提供拷贝数据）num：要拷贝的字节数（核心：不是元素数！）
作用：将一段内存的二进制数据 “原样拷贝” 到另一段内存
函数遇到' ' 的时候并不会停下来，不处理内存重叠，重叠会导致数据错误，拷贝字符串时，不会自动添加' '
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]); } //1 2 3 4 5 0 0 0 0 0 return 0; }模拟实现：
void* my_memcpy(void* destination, const void* source, size_t num) { assert(destination); assert(source); void* ret = destination; while (num) { *(char*)destination = *(char*)source; destination = (char*)destination + 1; source = (char*)source + 1; num--; } return ret; } int main() { int arr1[20] = { 0 }; int arr2[] = { 1,2,3,4,5,6,7,8,9,10 }; my_memcpy(arr1, arr2, 12); int i = 0; for (i = 0; i < 20; i++) { printf("%d ", arr1[i]); } return 0; }2.memmove函数使用和模拟实现
函数原型：
void* memmove(void* destination, const void* source, size_t num);destination：目标内存起始地址（接收拷贝数据）source：源内存起始地址（提供拷贝数据）num：要拷贝的字节数（核心：不是元素数！）
作用：支持内存重叠的通用内存拷贝函数，核心是在memcpy基础上解决了源内存和目标内存重叠时拷贝数据错误的问题。
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]); } //1 2 1 2 3 4 5 8 9 10 return 0; }模拟实现：
void* my_memmove(void* destination, const void* source, size_t num) { assert(destination); assert(source); void* pcur = destination; char* p = (char*)destination; char* q = (char*)source; if (p < q) { while (num--) { *p++ = *q++; } } else { p += num - 1; q += num - 1; while (num--) { *p-- = *q--; } } return pcur; } int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; my_memmove(arr+2, arr, 20); int i = 0; for (i = 0; i < 10; i++) { printf("%d ", arr[i]); } return 0; }3.memset函数使用和模拟实现
函数原型：
void* memset(void* ptr, int value, size_t num);作用：memset 逐字节初始化内存，将指定内存区域的每一个字节统一设置为同一个单字节值。
int main() { char str[] = "hello world"; memset(str, 'x', 6); printf(str); //xxxxxxworld return 0; }模拟实现：
void* my_memset(void* ptr, int value, size_t num) { assert(ptr != NULL); void* start_ptr = ptr; char fill_byte = (char)value; char* byte_ptr = (char*)ptr; while (num--) { *byte_ptr = fill_byte; byte_ptr++; } return start_ptr; } int main() { char str[20]; my_memset(str, 'a', 5); str[5] = ' '; printf("char数组初始化：%s
", str); // aaaaa return 0; }4.memcmp函数使用和模拟实现
函数原型：
int memcmp(const void* ptr1, const void* ptr2, size_t num);作用：从内存起始地址开始，按字节的二进制值逐位对比，直到发现首个不同字节或完成num个字节的比较；若ptr1对应字节的二进制值小于ptr2，返回负数；若两段内存前num个字节完全相等，返回 0；若ptr1对应字节大于ptr2，返回正数（返回值为首个不同字节的差值）
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'.
", buffer1, buffer2); else if (n < 0) printf("'%s' is less than '%s'.
", buffer1, buffer2); else printf("'%s' is the same as '%s'.
", buffer1, buffer2); //'DWgaOtP12df0' is greater than 'DWGAOTP12DF0'. return 0; }模拟实现：
int my_memcmp(const void* ptr1, const void* ptr2, size_t num) { assert(ptr1 != NULL && ptr2 != NULL); const char* p1 = (const char*)ptr1; const char* p2 = (const char*)ptr2; while (num--) { if (*p1 != *p2) { return (char)*p1 - (char)*p2; } p1++; p2++; } return 0; } int main() { char str1[] = "abcde"; char str2[] = "abxde"; int ret1 = my_memcmp(str1, str2, 5); printf("%d
", ret1); // 'c'(99)-'x'(120)=-21 int arr1[] = { 1, 2, 3 }; // 小端存储：01 00 00 00 | 02 00 00 00 | 03 00 00 00 int arr2[] = { 1, 4, 3 }; // 小端存储：01 00 00 00 | 04 00 00 00 | 03 00 00 00 int ret2 = my_memcmp(arr1, arr2, sizeof(arr1)); printf("%d
", ret2); // 02-04=-2 return 0; }