memmove与memcopy

发表于 | 浏览 次

memcpy、memmove，memcpy和strcpy分别用

memcpy

函数原型

1
void* memcpy(void* dest, const void* src, size_t count);

Copies count bytes from the object pointed to by src to the object pointed to by dest. Both objects are reinterpreted as arrays of unsigned char.

If the objects overlap, the behavior is undefined.

If either dest or src is a null pointer, the behavior is undefined, even if count is zero.

If the objects are potentially-overlapping or not TriviallyCopyable, the behavior of memcpy is not specified and may be undefined.

如果两段内存重叠，则会导致未定义的行为；如果dest或者src是空指针(即便count=0)，则是未定义的行为。

实现

1
2
3
4
5
6
7
8
9
10
11
12
void *memcpy(void *dest, const void *src, size_t n) {
    assert((nullptr != dest) && (nullptr != src));
    char *p1 = (char *) dest;
    char *p2 = (char *) src;
    if (n) {
        // 假设dest和src之间不存在重叠区域,因此这里不再检查
        while (n--) {
            *p1++ = *p2++;
        }
    }
    return dest;
}

测试程序

1
2
3
4
5
6
7
8
9
10
11
void test1() {
    int arr[5] = {1, 2, 3, 4, 5};
    int brr[5];
    
    // 注意第三个参数是sizeof(arr)
    memcpy(brr, arr, sizeof(arr));
    for (size_t i = 0; i < 5; ++i) {
        cout << brr[i] << " ";
    }
    cout << endl;
}

运行结果

1
1 2 3 4 5

比较

memcpy是最快的内存拷贝函数。它比strcpy和memmove都要快。strcpy需要扫描需要拷贝的数据，而memmove则需要检测是否存在内存重叠。
如果存在内存重叠，则应该使用memmove，而不是memcpy。

memmove

Move block of memory
Copies the values of num bytes from the location pointed by source to the memory block pointed by destination. Copying takes place as if an intermediate buffer were used, allowing the destination and source to overlap.
The underlying type of the objects pointed by both the source and destination pointers are irrelevant for this function; The result is a binary copy of the data.
The function does not check for any terminating null character in source - it always copies exactly num bytes.
To avoid overflows, the size of the arrays pointed by both the destination and source parameters, shall be at least num bytes.

以字节为单位，拷贝内存块。允许dest和src指向的内存块有重叠。

进行数组拷贝时，如果两段内存重叠，用memcpy函数可能会导致未定义。而memmove函数能够避免这种问题。下面是一种实现方式。题目链接
ptr1表示目的地址，ptr2表示源地址。如图所示，绿色表示数组2的元素，杏色表示数组1的元素．蓝色表示数组1和数组2重合的位置的元素。当pstr1 > pstr2时，需要逆序移动．否则，属于pstr2数组的后几个元素会被覆盖。a

1568902492023

当pstr1 < pstr2时，正向移动。

1568902612796

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void *memmove(void *str1, const void *str2, size_t n) {
    assert((nullptr != str1) && (nullptr != str2));
    char *pStr1 = (char *) str1;
    char *pStr2 = (char *) str2;

    if (pStr1 < pStr2) {
        for (size_t i = 0; i < n; ++i) {
            *pStr1++ = *pStr2++;
        }
    } else {
        // 如果目的在源之后,可能存在重叠区域,则逆向拷贝元素
        pStr1 += n - 1;
        pStr2 += n - 1;
        for (size_t i = 0; i < n; ++i) {
            *pStr1-- = *pStr2--;
        }
    }
    return str1;
}

测试程序
针对int

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void test1() {
    int arr[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 用arr[2],arr[3],...,arr[6]覆盖arr[0],arr[1],..,arr[4]
    memmove(arr, arr + 2, 5);
    for (int i = 0; i < 9; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test2() {
    int arr[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 用arr[0],arr[1],..,arr[4]覆盖arr[2],arr[3],...,arr[6]
    memmove(arr + 2, arr, 5);
    for (int i = 0; i < 9; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

运行结果：

1
2
3 4 5 6 7 6 7 8 9 
1 2 1 2 3 4 5 8 9

针对char

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void test3() {
    char arr[9] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'};

    // 用arr[2],arr[3],...,arr[6]覆盖arr[0],arr[1],..,arr[4]
    memmove(arr, arr + 2, 5);
    for (int i = 0; i < 9; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test4() {
    char arr[9] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'};

    // 用arr[0],arr[1],..,arr[4]覆盖arr[2],arr[3],...,arr[6]
    memmove(arr + 2, arr, 5);
    for (int i = 0; i < 9; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

运行结果

1
2
c d e f g f g h i 
a b a b c d e h i

strcpy

函数原型

1
char *strcpy(char *dest, const char* src);

Copy string

Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point).
To avoid overflows, the size of the array pointed by destination shall be long enough to contain the same C string as source (including the terminating null character), and should not overlap in memory with source.

strcpy只能用于拷贝C字符串(以空字符结尾)。为了防止溢出，dest指向的内存空间应该足够大，能够容纳src指向的字符串和一个表示字符串结尾的空字符。另外，dest和src指向的内存空间应该不存在重叠。

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
char *strcpy(char *dest, const char *src) {
    if (dest == nullptr) {
        return nullptr;
    }
    char *ptr = dest;

    while (*src != '\0') {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = '\0';
    return ptr;
}

测试程序

1
2
3
4
5
6
void test1() {
    char arr[6] = "hello";
    char brr[10];
    strcpy(brr, arr);
    cout << brr << endl;		// hello
}

参考文献

[1]memcpy: https://en.cppreference.com/w/cpp/string/byte/memcpy
[2]strcpy：https://www.techiedelight.com/implement-strcpy-function-c/
[3]memmove：http://www.cplusplus.com/reference/cstring/memmove/?kw=memmove
[4]memcpy等比较：https://www.cnblogs.com/youxin/p/3271074.html