memcpy () vs memmove ()

Saya mencoba memahami perbedaan antara memcpy()dan memmove(), dan saya telah membaca teks yang memcpy()tidak menangani sumber dan tujuan yang tumpang tindih sedangkan yang memmove()tidak.

Namun, ketika saya menjalankan kedua fungsi ini pada blok memori yang tumpang tindih, keduanya memberikan hasil yang sama. Misalnya, ambil contoh MSDN berikut di memmove()halaman bantuan: -

Apakah ada contoh yang lebih baik untuk memahami kelemahan memcpydan bagaimana memmovemenyelesaikannya?

// 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 );
}

Keluaran:

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

Saya tidak sepenuhnya terkejut bahwa contoh Anda tidak menunjukkan perilaku aneh. Coba salin str1ke str1+2gantinya dan lihat apa yang terjadi kemudian. (Mungkin tidak benar-benar membuat perbedaan, tergantung pada kompiler / perpustakaan.)

Secara umum, memcpy diimplementasikan dengan cara yang sederhana (tapi cepat). Secara sederhana, itu hanya loop atas data (dalam urutan), menyalin dari satu lokasi ke lokasi lain. Ini dapat menyebabkan sumber ditimpa saat sedang dibaca.

Memmove melakukan lebih banyak pekerjaan untuk memastikannya menangani tumpang tindih dengan benar.

EDIT:

(Sayangnya, saya tidak dapat menemukan contoh yang layak, tetapi ini akan berhasil). Bandingkan implementasi memcpy dan memmove di sini. memcpy just loop, sementara memmove melakukan tes untuk menentukan arah mana yang harus di-loop agar tidak merusak data. Implementasi ini agak sederhana. Sebagian besar implementasi berkinerja tinggi lebih rumit (melibatkan menyalin blok ukuran kata pada suatu waktu daripada byte).

Memori dalam memcpy tidak bisa tumpang tindih atau Anda berisiko perilaku tidak terdefinisi, sedangkan memori dalam memmovebisa tumpang tindih.

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. 

Beberapa implementasi memcpy mungkin masih berfungsi untuk input yang tumpang tindih tetapi Anda tidak dapat menghitung perilaku itu. Sementara memmove harus memungkinkan untuk tumpang tindih.

Hanya karena memcpytidak harus berurusan dengan daerah yang tumpang tindih, tidak berarti itu tidak berurusan dengan mereka dengan benar. Panggilan dengan wilayah yang tumpang tindih menghasilkan perilaku yang tidak terdefinisi. Perilaku tidak terdefinisi dapat bekerja sepenuhnya seperti yang Anda harapkan pada satu platform; itu tidak berarti itu benar atau valid.

Baik memcpy dan memove melakukan hal serupa.

Tetapi untuk melihat satu perbedaan:

#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 );

}

memberi:

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

Demo Anda tidak mengekspos kelemahan memcpy karena kompiler "buruk", itu membantu Anda dalam versi Debug. Versi rilis, bagaimanapun, memberi Anda output yang sama, tetapi karena optimasi.

    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  

Register di %eaxsini berfungsi sebagai penyimpanan sementara, yang "secara elegan" memperbaiki masalah yang tumpang tindih.

Kekurangannya muncul ketika menyalin 6 byte, well, setidaknya sebagian.

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);
}

Keluaran:

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

Terlihat aneh, itu disebabkan oleh optimasi juga.

    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  

Inilah sebabnya saya selalu memilih memmoveketika mencoba menyalin 2 blok memori yang tumpang tindih.

Perbedaan antara memcpydan memmoveitu

1. di memmove, memori sumber ukuran tertentu disalin ke buffer lalu dipindahkan ke tujuan. Jadi jika ingatannya tumpang tindih, tidak ada efek samping.

2. dalam hal memcpy(), tidak ada buffer tambahan yang diambil untuk memori sumber. Penyalinan dilakukan langsung pada memori sehingga ketika ada memori yang tumpang tindih, kami mendapatkan hasil yang tidak terduga.

Ini dapat diamati dengan kode berikut:

//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);
}

Output adalah:

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

Seperti yang telah ditunjukkan dalam jawaban lain, memmovelebih canggih daripada memcpyyang menyebabkan tumpang tindih memori. Hasil memmove didefinisikan seolah-olah srcdisalin ke dalam buffer dan kemudian disalin ke dalam buffer dst. Ini TIDAK berarti bahwa implementasi aktual menggunakan buffer apa pun, tetapi mungkin melakukan beberapa aritmatika pointer.

kompiler dapat mengoptimalkan memcpy, misalnya:

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

Memcpy ini dapat dioptimalkan sebagai: x = *(int*)some_pointer;

Kode yang diberikan dalam tautan http://clc-wiki.net/wiki/memcpy untuk memcpy agak membingungkan saya, karena tidak memberikan output yang sama ketika saya menerapkannya menggunakan contoh di bawah ini.

#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();
}

Output:

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

Tapi sekarang Anda bisa mengerti mengapa memmove akan menangani masalah yang tumpang tindih.

C11 draft standar

The C11 N1570 standar rancangan mengatakan:

7.24.2.1 "Fungsi memcpy":

2 Fungsi memcpy menyalin n karakter dari objek yang ditunjuk oleh s2 ke objek yang ditunjuk oleh s1. Jika penyalinan terjadi di antara objek yang tumpang tindih, perilaku tidak terdefinisi.

7.24.2.2 "Fungsi memmove":

2 Fungsi memmove menyalin n karakter dari objek yang ditunjuk oleh s2 ke objek yang ditunjuk oleh s1. Menyalin terjadi seolah-olah n karakter dari objek yang ditunjuk oleh s2 pertama kali disalin ke array sementara karakter n yang tidak tumpang tindih objek yang ditunjukkan oleh s1 dan s2, dan kemudian karakter n dari array sementara disalin ke dalam objek yang ditunjukkan oleh s1

Oleh karena itu, setiap tumpang tindih memcpymengarah pada perilaku yang tidak terdefinisi, dan apa pun bisa terjadi: buruk, tidak ada, atau bahkan baik. Bagus jarang terjadi :-)

memmove Namun jelas mengatakan bahwa semuanya terjadi seolah-olah buffer perantara digunakan, jadi jelas tumpang tindih OK.

C ++ std::copylebih memaafkan, dan memungkinkan tumpang tindih: Apakah std :: copy menangani rentang yang tumpang tindih?

Saya telah mencoba menjalankan program yang sama menggunakan eclipse dan itu menunjukkan perbedaan yang jelas antara memcpydan memmove. memcpy()tidak peduli tentang tumpang tindih lokasi memori yang mengakibatkan kerusakan data, sementara memmove()akan menyalin data ke variabel sementara terlebih dahulu dan kemudian menyalin ke lokasi memori aktual.

Saat mencoba menyalin data dari lokasi str1ke str1+2, output dari memcpyadalah " aaaaaa". Pertanyaannya bagaimana? memcpy()akan menyalin satu byte pada satu waktu dari kiri ke kanan. Seperti yang ditunjukkan dalam program Anda " aabbcc" maka semua penyalinan akan terjadi seperti di bawah ini,

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() akan menyalin data ke variabel sementara terlebih dahulu dan kemudian menyalin ke lokasi memori aktual.

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)

Output adalah

memcpy : aaaaaa

memmove : aaaabb