memcpy () vs memmove ()

Próbuję zrozumieć różnicę między memcpy()i memmove(), i przeczytałem tekst, memcpy()który nie uwzględnia nakładającego się źródła i miejsca docelowego, podczas gdy memmove()tak.

Jednak gdy wykonuję te dwie funkcje na nakładających się blokach pamięci, obie dają ten sam wynik. Na przykład weź następujący przykład MSDN na stronie memmove()pomocy: -

Czy istnieje lepszy przykład, aby zrozumieć wady memcpyi jak memmoveje rozwiązać?

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

Wynik:

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

Nie jestem całkowicie zaskoczony, że twój przykład nie wykazuje dziwnego zachowania. Zamiast tego spróbuj skopiować str1do str1+2i zobacz, co się wtedy stanie. (Może nie mieć znaczenia, zależy od kompilatora / bibliotek).

Ogólnie rzecz biorąc, memcpy jest implementowane w prosty (ale szybki) sposób. Upraszczając, po prostu zapętla dane (w kolejności), kopiując z jednej lokalizacji do drugiej. Może to spowodować nadpisanie źródła podczas odczytu.

Memmove wykonuje więcej pracy, aby upewnić się, że poprawnie obsługuje nakładanie się.

EDYTOWAĆ:

(Niestety nie mogę znaleźć przyzwoitych przykładów, ale te wystarczą). Kontrast memcpy i memmove implementacje pokazany tutaj. memcpy po prostu zapętla, podczas gdy memmove wykonuje test w celu określenia, w którym kierunku zapętlić, aby uniknąć uszkodzenia danych. Te implementacje są raczej proste. Większość wysokowydajnych implementacji jest bardziej skomplikowana (polega na kopiowaniu bloków rozmiaru słowa na raz, a nie bajtów).

Pamięć w memcpy nie może się nakładać lub ryzykujesz niezdefiniowane zachowanie, podczas gdy pamięć w memmovemoże się nakładać.

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. 

Niektóre implementacje memcpy mogą nadal działać w przypadku nakładania się danych wejściowych, ale nie można policzyć tego zachowania. Podczas gdy memmove musi pozwalać na nakładanie się.

To, że memcpynie ma do czynienia z nakładającymi się regionami, nie oznacza, że ​​nie radzi sobie z nimi poprawnie. Wywołanie z nakładającymi się regionami powoduje niezdefiniowane zachowanie. Niezdefiniowane zachowanie może działać zgodnie z oczekiwaniami na jednej platformie; to nie znaczy, że jest poprawne lub ważne.

Zarówno memcpy, jak i memove robią podobne rzeczy.

Ale żeby zauważyć jedną różnicę:

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

}

daje:

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

Twoje demo nie ujawniło wad memcpy z powodu "złego" kompilatora, robi ci to przysługę w wersji Debug. Wydana wersja daje jednak te same wyniki, ale ze względu na optymalizację.

    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  

Rejestr %eaxdziała tutaj jako tymczasowy magazyn, który „elegancko” rozwiązuje problem nakładania się.

Wada pojawia się przy kopiowaniu 6 bajtów, no cóż, przynajmniej jej części.

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

Wynik:

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

Wygląda dziwnie, jest to również spowodowane optymalizacją.

    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  

Dlatego zawsze wybieram memmove, próbując skopiować 2 nakładające się bloki pamięci.

Różnica między memcpyi memmovejest taka

1. w memmoveprogramie pamięć źródłowa o określonym rozmiarze jest kopiowana do bufora, a następnie przenoszona do miejsca docelowego. Więc jeśli pamięć się nakłada, nie ma żadnych skutków ubocznych.

2. w przypadku memcpy()braku dodatkowego bufora dla pamięci źródłowej. Kopiowanie odbywa się bezpośrednio w pamięci, więc gdy pamięć się nakłada, otrzymujemy nieoczekiwane wyniki.

Można to zaobserwować za pomocą następującego kodu:

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

Wynik to:

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

Jak już wskazano w innych odpowiedziach, memmovejest bardziej wyrafinowany niż memcpytaki, że odpowiada za nakładanie się pamięci. Wynik memmove jest definiowany tak, jakby srcplik został skopiowany do bufora, a następnie do bufora dst. NIE oznacza to, że rzeczywista implementacja używa jakiegokolwiek bufora, ale prawdopodobnie wykonuje jakąś arytmetykę wskaźników.

kompilator może zoptymalizować memcpy, na przykład:

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

Ten memcpy można zoptymalizować jako: x = *(int*)some_pointer;

Kod podany w linkach http://clc-wiki.net/wiki/memcpy dla memcpy wydaje mi się nieco dezorientujący, ponieważ nie daje takich samych wyników, gdy zaimplementowałem go za pomocą poniższego przykładu.

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

Wynik :

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

Ale teraz możesz zrozumieć, dlaczego memmove zajmie się nakładającym się problemem.

Wersja standardowa C11

C11 N1570 standardowy projekt mówi:

7.24.2.1 „Funkcja memcpy”:

2 Funkcja memcpy kopiuje n znaków z obiektu wskazywanego przez s2 do obiektu wskazywanego przez s1. Jeśli kopiowanie odbywa się między nakładającymi się obiektami, zachowanie jest niezdefiniowane.

7.24.2.2 „Funkcja memmove”:

2 Funkcja memmove kopiuje n znaków z obiektu wskazywanego przez s2 do obiektu wskazywanego przez s1. Kopiowanie odbywa się tak, jakby n znaków z obiektu wskazywanego przez s2 było najpierw kopiowanych do tymczasowej tablicy n znaków, która nie pokrywa się z obiektami wskazywanymi przez s1 i s2, a następnie n znaków z tymczasowej tablicy jest kopiowanych do obiekt wskazywany przez s1

Dlatego każde nakładanie się memcpyprowadzi do nieokreślonego zachowania i wszystko może się zdarzyć: złe, nic lub nawet dobre. Jednak dobre jest rzadkie :-)

memmove jednak wyraźnie mówi, że wszystko dzieje się tak, jakby używany był bufor pośredni, więc wyraźnie nakładanie się jest OK.

C ++ std::copyjest jednak bardziej wyrozumiały i pozwala na nakładanie się: Czy std :: copy obsługuje nakładające się zakresy?

Próbowałem uruchomić ten sam program za pomocą eclipse i pokazuje wyraźną różnicę między memcpyi memmove. memcpy()nie dba o pokrywających się z miejsca w pamięci, co powoduje uszkodzenie danych, podczas gdy memmove()skopiuje dane do zmiennej tymczasowej, a następnie skopiować do aktualnej lokalizacji pamięci.

Podczas próby skopiowania danych z lokalizacji str1do str1+2, wyjście memcpyto „ aaaaaa”. Pytanie brzmi: jak? memcpy()kopiuje po jednym bajcie od lewej do prawej. Jak pokazano w programie, " aabbcc" kopiowanie będzie przebiegać jak poniżej,

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() skopiuje dane najpierw do zmiennej tymczasowej, a następnie skopiuje do rzeczywistej lokalizacji pamięci.

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)

Wyjście jest

memcpy : aaaaaa

memmove : aaaabb