memcpy () vs memmove ()

ฉันพยายามที่จะเข้าใจความแตกต่างระหว่างmemcpy()และmemmove()และฉันได้อ่านข้อความที่memcpy()ไม่ดูแลแหล่งที่มาและปลายทางที่ทับซ้อนกันในขณะที่memmove()ทำ

อย่างไรก็ตามเมื่อฉันรันทั้งสองฟังก์ชั่นนี้บนบล็อคหน่วยความจำที่ทับซ้อนกันทั้งคู่ก็ให้ผลลัพธ์เหมือนกัน ตัวอย่างเช่นใช้ตัวอย่าง MSDN ต่อไปนี้ในmemmove()หน้าวิธีใช้: -

มีตัวอย่างที่ดีกว่าที่จะเข้าใจข้อเสียmemcpyและวิธีการmemmoveแก้ไขหรือไม่

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

เอาท์พุท:

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

ฉันไม่แปลกใจเลยที่ตัวอย่างของคุณไม่แสดงพฤติกรรมแปลก ๆ ลองคัดลอกstr1ไปที่str1+2แทนและดูว่าเกิดอะไรขึ้น (อาจไม่สร้างความแตกต่างขึ้นอยู่กับคอมไพเลอร์ / ไลบรารี)

โดยทั่วไป memcpy ถูกนำมาใช้ในลักษณะที่เรียบง่าย (แต่เร็ว) แบบง่ายๆมันวนรอบข้อมูล (ตามลำดับ) คัดลอกจากที่หนึ่งไปยังอีกที่หนึ่ง สิ่งนี้สามารถส่งผลให้แหล่งที่มาถูกเขียนทับในขณะที่มันกำลังอ่าน

Memmove ทำงานได้มากขึ้นเพื่อให้แน่ใจว่าจะจัดการการทับซ้อนได้อย่างถูกต้อง

แก้ไข:

(น่าเสียดายที่ฉันไม่สามารถหาตัวอย่างที่เหมาะสมได้ แต่สิ่งเหล่านี้จะทำ) ตัดกันการใช้memcpyและmemmove ที่แสดงที่นี่ memcpy จะวนซ้ำในขณะที่ memmove ทำการทดสอบเพื่อกำหนดทิศทางที่จะวนซ้ำเพื่อหลีกเลี่ยงการทำลายข้อมูล การใช้งานเหล่านี้ค่อนข้างง่าย การใช้งานที่มีประสิทธิภาพสูงส่วนใหญ่มีความซับซ้อนมากขึ้น

หน่วยความจำในmemcpy ไม่สามารถซ้อนทับกันหรือคุณเสี่ยงต่อพฤติกรรมที่ไม่ได้กำหนดในขณะที่หน่วยความจำในmemmoveสามารถทับซ้อนกันได้

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. 

การประยุกต์ใช้ memcpy บางอย่างอาจยังคงใช้งานได้กับอินพุตที่ทับซ้อนกัน แต่คุณไม่สามารถนับจำนวนการทำงานนั้นได้ ในขณะที่ memmove จะต้องอนุญาตให้มีการทับซ้อนกัน

เพียงเพราะmemcpyไม่ต้องจัดการกับภูมิภาคที่ทับซ้อนกันไม่ได้หมายความว่ามันไม่ได้จัดการกับมันอย่างถูกต้อง การโทรที่มีพื้นที่ทับซ้อนกันจะสร้างพฤติกรรมที่ไม่ได้กำหนด พฤติกรรมที่ไม่ได้กำหนดสามารถทำงานได้อย่างสมบูรณ์ตามที่คุณคาดหวังบนแพลตฟอร์มเดียว นั่นไม่ได้หมายความว่ามันถูกต้องหรือถูกต้อง

ทั้ง memcpy และ memove ทำสิ่งที่คล้ายกัน

แต่จะเห็นความแตกต่างหนึ่ง:

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

}

ให้:

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

การสาธิตของคุณไม่ได้เปิดเผยข้อเสีย memcpy เนื่องจากคอมไพเลอร์ "ไม่ดี" คุณชอบในเวอร์ชัน Debug อย่างไรก็ตามรุ่นที่วางจำหน่ายให้ผลลัพธ์เดียวกัน แต่เนื่องจากการปรับให้เหมาะสม

    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  

รีจิสเตอร์%eaxที่นี่เล่นเป็นที่เก็บข้อมูลชั่วคราวซึ่ง "อย่างสวยงาม" จะแก้ไขปัญหาการทับซ้อน

ข้อเสียเปรียบเกิดขึ้นเมื่อคัดลอก 6 ไบต์อย่างน้อยก็ส่วนหนึ่ง

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

เอาท์พุท:

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

ดูแปลก ๆ มันเกิดจากการปรับแต่งเช่นกัน

    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  

นี่คือเหตุผลที่ฉันเลือกเสมอmemmoveเมื่อพยายามคัดลอกบล็อกหน่วยความจำที่ซ้อนกัน 2 แผ่น

ความแตกต่างระหว่างmemcpyและmemmoveคือ

1. ในmemmoveหน่วยความจำแหล่งที่มาของขนาดที่ระบุจะถูกคัดลอกลงในบัฟเฟอร์แล้วย้ายไปยังปลายทาง ดังนั้นหากหน่วยความจำซ้อนกันไม่มีผลข้างเคียง

2. ในกรณีที่memcpy()ไม่มีบัฟเฟอร์พิเศษสำหรับหน่วยความจำที่มา การคัดลอกทำได้โดยตรงบนหน่วยความจำเพื่อที่ว่าเมื่อมีหน่วยความจำทับกันเราจะได้ผลลัพธ์ที่ไม่คาดคิด

สิ่งเหล่านี้สามารถสังเกตได้จากรหัสต่อไปนี้:

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

ผลลัพธ์คือ:

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

ตามที่ระบุไว้แล้วในคำตอบอื่น ๆmemmoveมีความซับซ้อนมากกว่าmemcpyที่มันจะทับซ้อนหน่วยความจำ ผลจากการ memmove ถูกกำหนดให้เป็นถ้าถูกคัดลอกลงในบัฟเฟอร์แล้วคัดลอกลงในบัฟเฟอร์src dstนี่ไม่ได้หมายความว่าการใช้งานจริงจะใช้บัฟเฟอร์ใด ๆ แต่อาจเป็นตัวชี้ทางคณิตศาสตร์

คอมไพเลอร์สามารถเพิ่มประสิทธิภาพ memcpy ตัวอย่างเช่น:

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

memcpy นี้อาจปรับให้เหมาะสมเป็น: x = *(int*)some_pointer;

รหัสที่ระบุในลิงก์http://clc-wiki.net/wiki/memcpyสำหรับ memcpy ดูเหมือนจะทำให้ฉันสับสนเล็กน้อยเนื่องจากไม่ได้ให้ผลลัพธ์เดียวกันเมื่อฉันใช้งานโดยใช้ตัวอย่างด้านล่าง

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

ผลผลิต:

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

แต่ตอนนี้คุณสามารถเข้าใจได้ว่าทำไมmemmoveจะดูแลปัญหาที่ทับซ้อนกัน

ร่างมาตรฐาน C11

ร่างมาตรฐาน C11 N1570พูดว่า:

7.24.2.1 "ฟังก์ชั่น memcpy":

2 ฟังก์ชั่น memcpy คัดลอกตัวละคร n จากวัตถุที่ชี้ไปโดย s2 ลงในวัตถุที่ชี้ไปโดย s1 หากการคัดลอกเกิดขึ้นระหว่างวัตถุที่ทับซ้อนกันพฤติกรรมจะไม่ได้กำหนดไว้

7.24.2.2 "ฟังก์ชั่น memmove":

2 ฟังก์ชั่น memmove คัดลอกตัวละคร n จากวัตถุที่ชี้ไปโดย s2 ลงในวัตถุที่ชี้ไปโดย s1 การคัดลอกเกิดขึ้นราวกับว่าอักขระ n จากวัตถุที่ชี้ไปยัง s2 ถูกคัดลอกไปยังอาร์เรย์ชั่วคราวที่มีอักขระ n ตัวที่ไม่ซ้อนทับวัตถุที่ชี้ไปที่ s1 และ s2 และคัดลอกอักขระ n จากอาร์เรย์ชั่วคราวลงใน วัตถุที่ชี้ไปโดย s1

ดังนั้นการทับซ้อนใด ๆ ที่memcpyนำไปสู่พฤติกรรมที่ไม่ได้กำหนดและสิ่งที่สามารถเกิดขึ้นได้: ไม่ดีไม่มีอะไรหรือแม้แต่ดี สิ่งที่ดีนั้นหาได้ยาก :-)

memmove อย่างไรก็ตามกล่าวอย่างชัดเจนว่าทุกอย่างเกิดขึ้นราวกับว่ามีการใช้บัฟเฟอร์ระดับกลางดังนั้นการซ้อนทับอย่างชัดเจนจึงโอเค

อย่างไรก็ตาม C ++ std::copyนั้นให้อภัยมากกว่าและอนุญาตให้มีการทับซ้อน: std :: copy จัดการช่วงที่ทับซ้อนกันหรือไม่

ผมได้พยายามที่จะเรียกใช้โปรแกรมเดียวกันโดยใช้คราสและมันแสดงให้เห็นถึงความแตกต่างที่ชัดเจนระหว่างและmemcpy ไม่สนใจเกี่ยวกับการทับซ้อนของตำแหน่งหน่วยความจำซึ่งทำให้ข้อมูลเสียหายขณะที่จะคัดลอกข้อมูลไปยังตัวแปรชั่วคราวก่อนแล้วจึงคัดลอกไปยังตำแหน่งหน่วยความจำจริงmemmovememcpy()memmove()

ในขณะที่พยายามคัดลอกข้อมูลจากตำแหน่งstr1ไปยังstr1+2ผลลัพธ์ของmemcpyคือ " aaaaaa" คำถามจะเป็นอย่างไร memcpy()จะคัดลอกครั้งละหนึ่งไบต์จากซ้ายไปขวา ดังที่แสดงในโปรแกรมของคุณ " aabbcc" จากนั้นการคัดลอกทั้งหมดจะเกิดขึ้นดังนี้

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() จะคัดลอกข้อมูลไปยังตัวแปรชั่วคราวก่อนแล้วจึงคัดลอกไปยังตำแหน่งหน่วยความจำจริง

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)

ผลผลิตคือ

memcpy : aaaaaa

memmove : aaaabb