文章/答案/技术大牛

发布

社区首页 >专栏 >C语言strcpy(),memcpy(),memmove() | 数组赋值给数组

C语言strcpy(),memcpy(),memmove() | 数组赋值给数组

CtrlX

发布于 2023-03-21 03:48:23

3.9K01

代码可运行

文章被收录于专栏：C++核心编程C++核心编程

运行总次数：1

代码可运行

一个数组赋值给另一个数组的方法

int arr1[5] = {1, 2, 3, 4, 5};
int arr2[5];
arr2 = arr1;  // 错误，不能直接赋值

方法一

使用循环遍历数组中的每一个元素

int arr1[5] = {1, 2, 3, 4, 5};
int arr2[5];
for (int i = 0; i < 5; i++) {
  arr2[i] = arr1[i];
}

使用std::array时，可以使用赋值运算符来复制：

std::array<int, 5> arr1 = {1, 2, 3, 4, 5};
std::array<int, 5> arr2;
arr2 = arr1;

方法二

使用C语言库函数解决

1.使用strcpy()和strncpy()函数处理字符串数组

strcpy()函数用于复制一个字符串到另一个字符串。该函数的语法如下：

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

它从源字符串src复制字符到目标字符串dest，包括NULL字符（即字符串结束标志）。

strncpy()函数与strcpy()类似，但是其复制的字符数可以限制。该函数的语法如下：

char *strncpy(char *dest, const char *src, size_t n);

它从源字符串src复制字符到目标字符串dest，但是最多复制n个字符。

举个例子：

#include <iostream>
#include <cstring>

int main()
{
    char source[] = "Hello, World!";
    char destination[50];

    // using strcpy
    strcpy(destination, source);
    std::cout << "After using strcpy: " << destination << std::endl;

    // using strncpy
    strncpy(destination, source, 5);
    destination[5] = '\0';
    std::cout << "After using strncpy: " << destination << std::endl;

    return 0;
}

输出：

After using strcpy: Hello, World!
After using strncpy: Hello

PS：详见C Primer Plus P351

2.使用string.h库中memcpy()和memmove()函数处理任意类型的数组

memcpy() 和 memmove() 是 string.h 库中的两个常用的内存复制函数。这两个函数可以用来处理任意类型的数组，并复制从源数组到目标数组。

memcpy() 函数把一块内存复制到另一块内存，但是不会去处理内存是否重叠。它可以被用来处理整个数组或仅仅一部分。它的语法如下：

void *memcpy(void *dest, const void *src, size_t n);

memmove() 函数的作用与 memcpy() 类似，可以处理内存重叠的情况。它的语法如下：

void *memmove(void *dest, const void *src, size_t n);

如果你想复制一个整数数组，例如：

int source[5] = {1, 2, 3, 4, 5};
int target[5];

memcpy(target, source, sizeof(source));

这两个函数是 C 语言中非常有用的内存复制函数，可以用来处理任意类型的数组，也可以用来处理字符数组。

PS：详见C Primer Plus P558

c和c++使用的内存拷贝函数，memcpy函数和memmove函数的功能都是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。

要使用这两个库函数需要引用头文件 <string.h> 函数原型： void* memcpy(void* destination,const void* source,size_t num); voidmemmove(void destination,const void* source,size_t num); destination:目的地指针（首地址） source:源头指针（首地址） num:需要复制的字节数

memcpy和memmove都是C语言标准库函数，用于内存拷贝。两者的主要区别在于：

memcpy是直接在内存中复制数据，不会考虑内存重叠的情况。如果源区域和目标区域有重叠的部分，可能会出现未定义的行为。
memmove是在内存中复制数据，考虑内存重叠的情况。如果源区域和目标区域有重叠的部分，会先把数据复制到临时空间，再从临时空间复制到目标区域，保证数据不会被覆盖。

因为memcpy的运行速度比memmove快，所以memcpy常常被用于内存拷贝。在程序员能确保源区域和目标区域没有重叠或者能够接受重叠部分数据被覆盖的情况下memcpy是很好的选择。但是在不能确定源区域和目标区域是否重叠或者不能接受重叠部分数据被覆盖的情况下，应该使用memmove以保证数据完整性。

举个例子，假设我们有一个字符数组char arr[10]，我们想把arr[2]~~arr[5]这4个字符移动到arr[6]~~arr[9]这4个位置上。如果使用memcpy(arr+6, arr+2, 4)，结果就会是这样的：

原数组: | A | B | C | D | E | F | G | H | I | J |
拷贝后: | A | B | C | D | E | C | D | E | C | J |

可以发现，原本arr[6]~arr[9]的数据被覆盖了。如果使用memmove(arr+6, arr+2, 4)，结果就会是这样的：

原数组: | A | B | C | D | E | F | G | H | I | J |
拷贝后: | A | B | C | D | E | C | D | E | F | J |

可以发现，原本arr[6]~arr[9]的数据没有被覆盖，源区域的数据也没有丢失。在这个例子中，memmove 保证了数据完整性，而memcpy没有。简而言之，memcpy是一个快速的内存拷贝函数，memmove是一个安全的内存拷贝函数，当你不能确保源区域和目标区域是否重叠或者不能接受重叠部分数据被覆盖的情况下，应该使用memmove来保证数据完整性。

借一下图：https://blog.csdn.net/m0_66363962/article/details/126903690

通过上图的变化路程可知：memcpy总是从低地址开始往高地址复制的，但是当dest>src，并且目的地与源头有重叠时，使用memcpy会覆盖掉源头后面的数据，导致结果出错。这个时候就需要进行判断，如果再次出现上面的事件，我们应当从高地址往低地址开始复制，但是memcpy函数在设计时没有这种判断。所以使用memmove函数解决。

memcpy从高地址往低地址复制不会受内存重叠时的问题的影响。从低地址往高地址复制时需要使用memmove函数。

memcpy比循环赋值快，原因如下：

1.在 C 语言中，使用 memcpy 函数进行内存复制通常比使用循环赋值更快。这是因为 memcpy 是一个底层的函数，它可以直接操作内存，而不需要进行额外的运算。它使用缓存和高级的内存管理技术来提高性能。

2.另外，memcpy 函数可以并行执行，因此多核处理器上能够更高效地运行，而循环赋值是串行执行的，所以性能更差。

下面是一个使用 memcpy 函数进行内存复制的示例代码：

#include <string.h>

int main() {
    int arr1[5] = {1, 2, 3, 4, 5};
    int arr2[5];
    memcpy(arr2, arr1, sizeof(arr1));
    // arr2 is now {1, 2, 3, 4, 5}
    return 0;
}