memcpy () vs memmove ()

Tôi đang cố gắng để hiểu sự khác biệt giữa memcpy()và memmove(), và tôi đã đọc văn bản memcpy()không quan tâm đến nguồn và đích chồng chéo trong khi memmove()đó.

Tuy nhiên, khi tôi thực hiện hai chức năng này trên các khối bộ nhớ chồng chéo, cả hai đều cho kết quả như nhau. Ví dụ: lấy ví dụ MSDN sau trên memmove()trang trợ giúp: -

Có một ví dụ tốt hơn để hiểu những nhược điểm của memcpyvà làm thế nào để memmovegiải quyết nó?

// crt_memcpy.c
// Illustrate overlapping copy: memmove always handles it correctly; memcpy may handle
// it correctly.

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[7] = "aabbcc";

int main( void )
{
    printf( "The string: %s\n", str1 );
    memcpy( str1 + 2, str1, 4 );
    printf( "New string: %s\n", str1 );

    strcpy_s( str1, sizeof(str1), "aabbcc" );   // reset string

    printf( "The string: %s\n", str1 );
    memmove( str1 + 2, str1, 4 );
    printf( "New string: %s\n", str1 );
}

Đầu ra:

The string: aabbcc
New string: aaaabb
The string: aabbcc
New string: aaaabb

Tôi không hoàn toàn ngạc nhiên khi ví dụ của bạn thể hiện không có hành vi lạ. Hãy thử sao chép str1vàostr1+2 thay thế và xem những gì xảy ra sau đó. (Có thể không thực sự tạo ra sự khác biệt, phụ thuộc vào trình biên dịch / thư viện.)

Nói chung, memcpy được thực hiện theo cách đơn giản (nhưng nhanh chóng). Đơn giản, nó chỉ lặp trên dữ liệu (theo thứ tự), sao chép từ vị trí này sang vị trí khác. Điều này có thể dẫn đến nguồn bị ghi đè trong khi nó được đọc.

Memmove thực hiện nhiều công việc hơn để đảm bảo nó xử lý trùng lặp chính xác.

BIÊN TẬP:

(Thật không may, tôi không thể tìm thấy các ví dụ phong nha, nhưng chúng sẽ làm được). Tương phản các triển khai memcpy và memmove được hiển thị ở đây. memcpy chỉ là các vòng lặp, trong khi memmove thực hiện một bài kiểm tra để xác định hướng nào sẽ lặp lại để tránh làm hỏng dữ liệu. Những triển khai này khá đơn giản. Hầu hết các triển khai hiệu suất cao đều phức tạp hơn (liên quan đến việc sao chép các khối kích thước từ tại một thời điểm thay vì byte).

Bộ nhớ trong memcpy không thể chồng lấp hoặc bạn có nguy cơ hành vi không xác định, trong khi bộ nhớ trong memmovecó thể chồng lấp.

char a[16];
char b[16];

memcpy(a,b,16);           // valid
memmove(a,b,16);          // Also valid, but slower than memcpy.
memcpy(&a[0], &a[1],10);  // Not valid since it overlaps.
memmove(&a[0], &a[1],10); // valid. 

Một số triển khai của memcpy vẫn có thể hoạt động cho các đầu vào chồng chéo nhưng bạn không thể đếm được hành vi đó. Trong khi memmove phải cho phép chồng chéo.

Chỉ vì memcpykhông phải đối phó với các vùng chồng lấn, không có nghĩa là nó không giải quyết chúng một cách chính xác. Cuộc gọi với các vùng chồng chéo tạo ra hành vi không xác định. Hành vi không xác định có thể hoạt động hoàn toàn như bạn mong đợi trên một nền tảng; điều đó không có nghĩa là nó đúng hoặc hợp lệ.

Cả memcpy và memove đều làm những việc tương tự nhau.

Nhưng để nhận ra một sự khác biệt:

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[7] = "abcdef";

int main()
{

   printf( "The string: %s\n", str1 );
   memcpy( (str1+6), str1, 10 );
   printf( "New string: %s\n", str1 );

   strcpy_s( str1, sizeof(str1), "aabbcc" );   // reset string


   printf("\nstr1: %s\n", str1);
   printf( "The string: %s\n", str1 );
   memmove( (str1+6), str1, 10 );
   printf( "New string: %s\n", str1 );

}

cho:

The string: abcdef
New string: abcdefabcdefabcd
The string: abcdef
New string: abcdefabcdef

Bản demo của bạn không phơi bày nhược điểm của memcpy vì trình biên dịch "xấu", nó giúp bạn trong phiên bản Debug. Một phiên bản phát hành, tuy nhiên, cung cấp cho bạn cùng một đầu ra, nhưng vì tối ưu hóa.

    memcpy(str1 + 2, str1, 4);
00241013  mov         eax,dword ptr [str1 (243018h)]  // load 4 bytes from source string
    printf("New string: %s\n", str1);
00241018  push        offset str1 (243018h) 
0024101D  push        offset string "New string: %s\n" (242104h) 
00241022  mov         dword ptr [str1+2 (24301Ah)],eax  // put 4 bytes to destination
00241027  call        esi  

Sổ đăng ký %eax ở đây đóng vai trò là một bộ lưu trữ tạm thời, "thanh lịch" khắc phục vấn đề chồng chéo.

Hạn chế nổi lên khi sao chép 6 byte, ít nhất là một phần của nó.

char str1[9] = "aabbccdd";

int main( void )
{
    printf("The string: %s\n", str1);
    memcpy(str1 + 2, str1, 6);
    printf("New string: %s\n", str1);

    strcpy_s(str1, sizeof(str1), "aabbccdd");   // reset string

    printf("The string: %s\n", str1);
    memmove(str1 + 2, str1, 6);
    printf("New string: %s\n", str1);
}

Đầu ra:

The string: aabbccdd
New string: aaaabbbb
The string: aabbccdd
New string: aaaabbcc

Trông có vẻ lạ, đó cũng là do tối ưu hóa.

    memcpy(str1 + 2, str1, 6);
00341013  mov         eax,dword ptr [str1 (343018h)] 
00341018  mov         dword ptr [str1+2 (34301Ah)],eax // put 4 bytes to destination, earlier than the above example
0034101D  mov         cx,word ptr [str1+4 (34301Ch)]  // HA, new register! Holding a word, which is exactly the left 2 bytes (after 4 bytes loaded to %eax)
    printf("New string: %s\n", str1);
00341024  push        offset str1 (343018h) 
00341029  push        offset string "New string: %s\n" (342104h) 
0034102E  mov         word ptr [str1+6 (34301Eh)],cx  // Again, pulling the stored word back from the new register
00341035  call        esi  

Đây là lý do tại sao tôi luôn chọn memmovekhi sao chép 2 khối bộ nhớ chồng chéo.

Sự khác biệt giữa memcpyvà memmovelà

1. trong memmove, bộ nhớ nguồn có kích thước được chỉ định được sao chép vào bộ đệm và sau đó được chuyển đến đích. Vì vậy, nếu bộ nhớ bị chồng chéo, không có tác dụng phụ.

2. trong trường hợp memcpy(), không có bộ đệm bổ sung nào được lấy cho bộ nhớ nguồn. Việc sao chép được thực hiện trực tiếp trên bộ nhớ để khi có bộ nhớ trùng lặp, chúng ta sẽ nhận được kết quả không mong muốn.

Chúng có thể được quan sát bởi đoạn mã sau:

//include string.h, stdio.h, stdlib.h
int main(){
  char a[]="hare rama hare rama";

  char b[]="hare rama hare rama";

  memmove(a+5,a,20);
  puts(a);

  memcpy(b+5,b,20);
  puts(b);
}

Đầu ra là:

hare hare rama hare rama
hare hare hare hare hare hare rama hare rama

Như đã chỉ ra trong các câu trả lời khác, memmovephức tạp hơn so với memcpyviệc nó chiếm phần chồng lấp bộ nhớ. Kết quả của memmove được định nghĩa như thể srcđược sao chép vào một bộ đệm và sau đó bộ đệm được sao chép vào dst. Điều này KHÔNG có nghĩa là việc triển khai thực tế sử dụng bất kỳ bộ đệm nào, nhưng có lẽ là một số số học con trỏ.

trình biên dịch có thể tối ưu hóa memcpy, ví dụ:

int x;
memcpy(&x, some_pointer, sizeof(int));

Memcpy này có thể được tối ưu hóa như: x = *(int*)some_pointer;

Mã được đưa ra trong các liên kết http://clc-wiki.net/wiki/memcpy cho memcpy dường như làm tôi bối rối một chút, vì nó không cho cùng một đầu ra khi tôi triển khai nó bằng ví dụ dưới đây.

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[11] = "abcdefghij";

void *memcpyCustom(void *dest, const void *src, size_t n)
{
    char *dp = (char *)dest;
    const char *sp = (char *)src;
    while (n--)
        *dp++ = *sp++;
    return dest;
}

void *memmoveCustom(void *dest, const void *src, size_t n)
{
    unsigned char *pd = (unsigned char *)dest;
    const unsigned char *ps = (unsigned char *)src;
    if ( ps < pd )
        for (pd += n, ps += n; n--;)
            *--pd = *--ps;
    else
        while(n--)
            *pd++ = *ps++;
    return dest;
}

int main( void )
{
    printf( "The string: %s\n", str1 );
    memcpy( str1 + 1, str1, 9 );
    printf( "Actual memcpy output: %s\n", str1 );

    strcpy_s( str1, sizeof(str1), "abcdefghij" );   // reset string

    memcpyCustom( str1 + 1, str1, 9 );
    printf( "Implemented memcpy output: %s\n", str1 );

    strcpy_s( str1, sizeof(str1), "abcdefghij" );   // reset string

    memmoveCustom( str1 + 1, str1, 9 );
    printf( "Implemented memmove output: %s\n", str1 );
    getchar();
}

Đầu ra:

The string: abcdefghij
Actual memcpy output: aabcdefghi
Implemented memcpy output: aaaaaaaaaa
Implemented memmove output: aabcdefghi

Nhưng bây giờ bạn có thể hiểu tại sao memmove sẽ quan tâm đến vấn đề chồng chéo.

Dự thảo tiêu chuẩn C11

Các C11 N1570 dự thảo tiêu chuẩn nói:

7.24.2.1 "Hàm memcpy":

2 Hàm memcpy sao chép n ký tự từ đối tượng được trỏ bởi s2 vào đối tượng được trỏ bởi s1. Nếu sao chép diễn ra giữa các đối tượng chồng lấp, hành vi không được xác định.

7.24.2.2 "Hàm memmove":

2 Hàm memmove sao chép n ký tự từ đối tượng được trỏ bởi s2 vào đối tượng được trỏ bởi s1. Việc sao chép diễn ra như thể các ký tự n từ đối tượng được trỏ bởi s2 trước tiên được sao chép vào một mảng tạm thời của n ký tự không trùng với các đối tượng được trỏ bởi s1 và s2, sau đó các ký tự n từ mảng tạm thời được sao chép vào đối tượng được chỉ bởi s1

Do đó, bất kỳ sự chồng chéo nào memcpydẫn đến hành vi không xác định, và bất cứ điều gì có thể xảy ra: xấu, không có gì hoặc thậm chí tốt. Tốt là rất hiếm mặc dù :-)

memmove tuy nhiên rõ ràng nói rằng mọi thứ xảy ra như thể một bộ đệm trung gian được sử dụng, vì vậy rõ ràng trùng lặp là ổn.

std::copyTuy nhiên, C ++ dễ tha thứ hơn và cho phép chồng lấp: std :: copy có xử lý các phạm vi chồng lấp không?

Tôi đã cố gắng chạy cùng một chương trình bằng cách sử dụng nhật thực và nó cho thấy sự khác biệt rõ ràng giữa memcpyvà memmove. memcpy()không quan tâm đến sự chồng chéo của vị trí bộ nhớ dẫn đến hỏng dữ liệu, trong khi đó memmove()sẽ sao chép dữ liệu sang biến tạm thời trước rồi sao chép vào vị trí bộ nhớ thực.

Trong khi cố gắng sao chép dữ liệu từ vị trí str1sang str1+2, đầu ra memcpylà " aaaaaa". Câu hỏi sẽ là như thế nào? memcpy()sẽ sao chép một byte mỗi lần từ trái sang phải. Như được hiển thị trong chương trình của bạn " aabbcc", sau đó tất cả sao chép sẽ diễn ra như dưới đây,

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() sẽ sao chép dữ liệu vào biến tạm thời trước rồi sao chép vào vị trí bộ nhớ thực.

1. aabbcc(actual) -> aabbcc(temp)

2. aabbcc(temp) -> aaabcc(act)

3. aabbcc(temp) -> aaaacc(act)

4. aabbcc(temp) -> aaaabc(act)

5. aabbcc(temp) -> aaaabb(act)

Đầu ra là

memcpy : aaaaaa

memmove : aaaabb