memcpy、memmove、memset、memcmp 的参数表里没有元素类型,只有 void * 和字节数。这让它们能处理任何对象,也让两个错误反复出现:把元素个数当成字节数,以及在源和目标重叠时继续用 memcpy。

四个原型都只认字节

函数原型停止条件
memcpyvoid *memcpy(void *dest, const void *src, size_t num);拷满 num 个字节
memmovevoid *memmove(void *dest, const void *src, size_t num);拷满 num 个字节,允许重叠
memsetvoid *memset(void *ptr, int value, size_t num);写满 num 个字节
memcmpint 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] 开始,每次先读源、再写目标、两个指针各加一个元素:

步写入位置读到的值数组状态
1arr[2]arr[0] 的 11 2 1 4 5 6 7 8 9 10
2arr[3]arr[1] 的 21 2 1 2 5 6 7 8 9 10
3arr[4]arr[2],此时已是 11 2 1 2 1 6 7 8 9 10
4arr[5]arr[3],此时已是 21 2 1 2 1 2 7 8 9 10
5arr[6]arr[4],此时已是 11 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 字节。

能安全使用的场合有个共同特征:目标值的每个字节都一样。

目标想设的值写入的字节结果
int0全 000
int-1全 FF-1
int1全 010x01010101
double0.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 比大小。返回值只有符号有意义:

返回值含义
小于 0p1 的前 num 个字节更小
等于 0前 num 个字节完全相同
大于 0p1 更大

具体是 -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 就会说不相等。要比就逐字段比,或者保证填充区先被清零。

调用这几个函数之前,花三秒确认两件事:这两段内存会不会压在一起,这个长度到底是字节还是元素。相关的事故大多停在这两个问题上。