memcpy、memmove、memset、memcmp 的参数表里没有元素类型,只有 void * 和字节数。这让它们能处理任何对象,也让两个错误反复出现:把元素个数当成字节数,以及在源和目标重叠时继续用 memcpy。
四个原型都只认字节
| 函数 | 原型 | 停止条件 |
|---|---|---|
memcpy | void *memcpy(void *dest, const void *src, size_t num); | 拷满 num 个字节 |
memmove | void *memmove(void *dest, const void *src, size_t num); | 拷满 num 个字节,允许重叠 |
memset | void *memset(void *ptr, int value, size_t num); | 写满 num 个字节 |
memcmp | int memcmp(const void *p1, const void *p2, size_t num); | 比满 num 个字节,或提前分出大小 |
void * 不能解引用,也不能加减,编译器不知道一步该走多远。所以库实现统一先转成 char * 或 unsigned char *,一步正好一个字节。用 unsigned char 更好:它没有符号,取出来比较时不会变成负数。
memcpy 和 strcpy 最直接的区别在终止符。memcpy 完全不看 '\0',拷满 num 个字节就停;strcpy 看到 '\0' 就收工,并且把它写进去。结果是:中间夹 0 的数据只能走 memcpy;用 memcpy 搬字符串时,长度必须自己算成 strlen(src) + 1,否则终止符不会跟着过去。
#include <stdio.h>
#include <string.h>
int main(void)
{
int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int arr2[10] = {0};
memcpy(arr2, arr1, 5 * sizeof(int));
for (int i = 0; i < 10; i++)
printf("%d ", arr2[i]); /* 1 2 3 4 5 0 0 0 0 0 */
printf("\n");
return 0;
}课件的示例把长度写成 20。它在 sizeof(int) == 4 的平台上正好是 5 个元素,但 int 的宽度由实现决定,换成 2 字节的 int,20 就变成 10 个元素,复制的内容和“搬 5 个”的意图对不上。写成 5 * sizeof(int),元素个数和平台假设分开了。
模拟实现就是把上面的思路照抄一遍:
#include <assert.h>
#include <stddef.h>
void *my_memcpy(void *dest, const void *src, size_t count)
{
void *ret = dest;
unsigned char *d = (unsigned char *)dest;
const unsigned char *s = (const unsigned char *)src;
assert(dest != NULL);
assert(src != NULL);
while (count--)
*d++ = *s++;
return ret;
}重叠时,第三步要读的字节已经被第一步改写
把 memcpy(arr + 2, arr, 5 * sizeof(int)) 的每一步摊开,源从 arr[0] 开始,目标从 arr[2] 开始,每次先读源、再写目标、两个指针各加一个元素:
| 步 | 写入位置 | 读到的值 | 数组状态 |
|---|---|---|---|
| 1 | arr[2] | arr[0] 的 1 | 1 2 1 4 5 6 7 8 9 10 |
| 2 | arr[3] | arr[1] 的 2 | 1 2 1 2 5 6 7 8 9 10 |
| 3 | arr[4] | arr[2],此时已是 1 | 1 2 1 2 1 6 7 8 9 10 |
| 4 | arr[5] | arr[3],此时已是 2 | 1 2 1 2 1 2 7 8 9 10 |
| 5 | arr[6] | arr[4],此时已是 1 | 1 2 1 2 1 2 1 8 9 10 |
写到第三步时,源指针已经走到目标先改写过的位置。写的位置跑在读的位置前面,这就是全部原因。
C99 起 memcpy 的原型带 restrict:void *memcpy(void *restrict dest, const void *restrict src, size_t count);。两个 restrict 是交给编译器的承诺——这块内存在这段时间里只通过这一个指针访问。源和目标一重叠,承诺就破了,行为未定义。上面那张表只是某个库实现从低地址往高地址逐字节抄的结果,换机器、换优化等级都可以不同。看到同一个调用换环境就换结果,先想未定义行为。
memmove 只多做一件事:决定从哪头开始抄
memmove 的原型和 memcpy 一样,只是没有 restrict,语义上允许两段内存重叠。做法是先判断方向:目标在源的低地址一侧,从前往后抄;目标在源的高地址一侧,从后往前抄。这样每次写到的位置,都是源还没读到的地方。
#include <assert.h>
#include <stddef.h>
void *my_memmove(void *dest, const void *src, size_t n)
{
unsigned char *d = (unsigned char *)dest;
const unsigned char *s = (const unsigned char *)src;
assert(dest != NULL);
assert(src != NULL);
if (d == s || n == 0)
return dest;
if (d < s)
{
while (n--)
*d++ = *s++;
}
else
{
d += n;
s += n;
while (n--)
*--d = *--s;
}
return dest;
}课件给的判断是 if (dst <= src || (char *)dst >= ((char *)src + count)):前半个条件对应“目标在低地址”,后半个条件对应“两段完全不重叠且目标在高地址”,两种情况都从低往高抄。一个 d < s 就能覆盖,少一次比较。
顺带一句:两个指针如果来自不同的数组,标准并不定义它们的大小关系,这里比较的只是地址顺序,是实现层面的写法。
把开头的 memcpy 换成 memmove:
#include <stdio.h>
#include <string.h>
int main(void)
{
int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
memmove(arr1 + 2, arr1, 5 * sizeof(int));
for (int i = 0; i < 10; i++)
printf("%d ", arr1[i]); /* 1 2 1 2 3 4 5 8 9 10 */
printf("\n");
return 0;
}前五个数整体右移两格,源里的 3、4、5 都在。同一份数据、同一个长度,差别只有一个方向判断。
memmove 不是“更安全的 memcpy”。它照样不检查长度,照样越界;唯一多做的事是处理重叠。
想验证自己写的版本,别只拿一个例子跑。把源偏移、目标偏移、长度三层循环枚举一遍,每轮和标准库的结果逐字节比较,覆盖目标在前、目标在后、包含、部分重叠、不重叠和长度为 0 这些组合。
memset 填的是字节,不是元素
void *memset(void *ptr, int value, size_t num); 把 (unsigned char)value 写进连续 num 个字节。参数写成 int,实际只保留低 8 位。
#include <stdio.h>
#include <string.h>
int main(void)
{
char str[] = "hello world";
memset(str, 'x', 6);
puts(str); /* xxxxxxworld */
return 0;
}课件末尾写的是 printf(str);。这行能编过,但它把数据当成了格式串:字符串里出现 %s、%n 时,printf 会按格式说明继续取栈上的参数,%n 还会往内存里写。改成 printf("%s", str) 或 puts(str),GCC 开 -Wformat-security 会直接警告。
单位是字节,这件事在一个 int 数组上就露馅了:
#include <stdio.h>
#include <string.h>
int main(void)
{
int arr[4];
memset(arr, 1, sizeof(arr));
printf("%d\n", arr[0]); /* 16843009,即 0x01010101 */
return 0;
}在 int 为 4 字节的平台上,四个字节都变成 0x01,按 int 拼起来就是 0x01010101。把元素值想成 1,写进去的却是四个独立的 1 字节。
能安全使用的场合有个共同特征:目标值的每个字节都一样。
| 目标 | 想设的值 | 写入的字节 | 结果 |
|---|---|---|---|
int | 0 | 全 00 | 0 |
int | -1 | 全 FF | -1 |
int | 1 | 全 01 | 0x01010101 |
double | 0.0 | 全 0(IEEE 754 下) | +0.0 |
| 指针 | NULL | 全 0(主流实现) | 空指针 |
长度同样容易算错。memset(arr, 0, sizeof(arr)) 在数组上没问题,但 arr 一旦变成函数参数,它已经退化成指针,sizeof(arr) 只剩指针大小,清零只覆盖开头几个字节,不是整个数组。按元素写:
#include <string.h>
void clear_ints(int *p, size_t n)
{
memset(p, 0, n * sizeof(*p));
}memcmp 比满 num 个字节才停
int memcmp(const void *p1, const void *p2, size_t num); 从两个地址开始,向后比较 num 个字节,按 unsigned char 比大小。返回值只有符号有意义:
| 返回值 | 含义 |
|---|---|
| 小于 0 | p1 的前 num 个字节更小 |
| 等于 0 | 前 num 个字节完全相同 |
| 大于 0 | p1 更大 |
具体是 -1 还是 -47,标准不管,判断相等只能写 == 0。
#include <stdio.h>
#include <string.h>
int main(void)
{
char buffer1[] = "DWgaOtP12df0";
char buffer2[] = "DWGAOTP12DF0";
int n = memcmp(buffer1, buffer2, sizeof(buffer1));
if (n > 0)
printf("%s 大于 %s\n", buffer1, buffer2);
else if (n < 0)
printf("%s 小于 %s\n", buffer1, buffer2);
else
printf("两段相同\n");
return 0;
}前两个字节都是 DW,第三个字节 g(0x67)比 G(0x47)大,所以第一段更大。这里体现的是 ASCII 的排列顺序,大小写字母并不等价。
memcmp 和 strcmp 的差别只有一条:strcmp 碰到 '\0' 就收工,memcmp 必须数满 num 个字节。一段以 0 开头的二进制编码,用 strcmp 比会全部判成相等,用 memcmp 才能分出高下。定长记录、哈希值、序列化后的缓冲区都该用 memcmp。
拿 memcmp 比整个结构体要小心。编译器会在成员之间插入填充字节,两个字段值完全相同的结构体,填充区里的残留内容可能不一样,memcmp 就会说不相等。要比就逐字段比,或者保证填充区先被清零。
调用这几个函数之前,花三秒确认两件事:这两段内存会不会压在一起,这个长度到底是字节还是元素。相关的事故大多停在这两个问题上。
还没有评论 — 第一条由你来留。