memcpy () vs memmove ()

Ich versuche, den Unterschied zwischen memcpy()und zu verstehen memmove(), und ich habe den Text gelesen, der memcpy()sich nicht um die überlappende Quelle und das überlappende Ziel memmove()kümmert.

Wenn ich diese beiden Funktionen jedoch auf überlappenden Speicherblöcken ausführe, ergeben beide das gleiche Ergebnis. Nehmen Sie zum Beispiel das folgende MSDN-Beispiel auf der memmove()Hilfeseite: -

Gibt es ein besseres Beispiel, um die Nachteile zu verstehen memcpyund wie es memmovegelöst werden kann?

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

Ausgabe:

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

Ich bin nicht ganz überrascht, dass Ihr Beispiel kein seltsames Verhalten zeigt. Versuchen Sie das Kopieren str1zu str1+2statt und sehen , was dann passiert. (Kann keinen Unterschied machen, hängt vom Compiler / den Bibliotheken ab.)

Im Allgemeinen wird memcpy auf einfache (aber schnelle) Weise implementiert. Vereinfacht gesagt werden nur die Daten (in der angegebenen Reihenfolge) durchlaufen und von einem Ort zum anderen kopiert. Dies kann dazu führen, dass die Quelle beim Lesen überschrieben wird.

Memmove leistet mehr Arbeit, um sicherzustellen, dass die Überlappung korrekt behandelt wird.

BEARBEITEN:

(Leider kann ich keine anständigen Beispiele finden, aber diese reichen aus). Vergleichen Sie die memcpy und memmove Implementierungen hier gezeigt. memcpy wird nur wiederholt, während memmove einen Test durchführt, um festzustellen, in welche Richtung eine Schleife ausgeführt werden soll, um eine Beschädigung der Daten zu vermeiden. Diese Implementierungen sind ziemlich einfach. Die meisten Hochleistungsimplementierungen sind komplizierter (das gleichzeitige Kopieren von Blöcken in Wortgröße anstelle von Bytes).

Der Speicher in memcpy kann sich nicht überlappen, oder Sie riskieren undefiniertes Verhalten, während sich der Speicher in memmoveüberlappen kann.

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. 

Einige Implementierungen von memcpy funktionieren möglicherweise immer noch für überlappende Eingaben, aber Sie können dieses Verhalten nicht zählen. Während memmove Überlappungen zulassen muss.

Nur weil memcpyes sich nicht um überlappende Regionen handeln muss, heißt das nicht, dass es nicht richtig mit ihnen umgeht. Der Aufruf mit überlappenden Regionen erzeugt undefiniertes Verhalten. Undefiniertes Verhalten kann auf einer Plattform wie erwartet funktionieren. das heißt nicht, dass es richtig oder gültig ist.

Sowohl memcpy als auch memove machen ähnliche Dinge.

Aber um einen Unterschied zu erkennen:

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

}

gibt:

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

Ihre Demo hat keine memcpy-Nachteile aufgrund des "schlechten" Compilers aufgedeckt, es tut Ihnen in der Debug-Version einen Gefallen. Eine Release-Version liefert jedoch die gleiche Ausgabe, jedoch aufgrund von Optimierungen.

    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  

Das Register wird %eaxhier als temporärer Speicher abgespielt, wodurch Überlappungsprobleme "elegant" behoben werden.

Der Nachteil tritt auf, wenn 6 Bytes kopiert werden, zumindest ein Teil davon.

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

Ausgabe:

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

Sieht komisch aus, es wird auch durch Optimierung verursacht.

    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  

Deshalb wähle ich immer, memmovewenn ich versuche, 2 überlappende Speicherblöcke zu kopieren.

Der Unterschied zwischen memcpyund memmoveist das

1. In memmovewird der Quellspeicher der angegebenen Größe in den Puffer kopiert und dann zum Ziel verschoben. Wenn sich der Speicher also überlappt, treten keine Nebenwirkungen auf.

2. Im Falle von memcpy()wird kein zusätzlicher Puffer für den Quellspeicher benötigt. Das Kopieren erfolgt direkt im Speicher, sodass bei Überlappung des Speichers unerwartete Ergebnisse erzielt werden.

Diese können durch den folgenden Code beobachtet werden:

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

Ausgabe ist:

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

Wie bereits in anderen Antworten erwähnt, memmoveist es komplexer als memcpysolche, dass es Speicherüberschneidungen berücksichtigt. Das Ergebnis von memmove ist so definiert, als ob das srcin einen Puffer und dann in den Puffer kopiert wurde dst. Dies bedeutet NICHT, dass die eigentliche Implementierung einen Puffer verwendet, sondern wahrscheinlich eine Zeigerarithmetik.

Der Compiler könnte memcpy optimieren, zum Beispiel:

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

Dieser Speicher kann wie folgt optimiert werden: x = *(int*)some_pointer;

Der Code in den Links http://clc-wiki.net/wiki/memcpy für memcpy scheint mich ein wenig zu verwirren, da er nicht die gleiche Ausgabe liefert, wenn ich ihn anhand des folgenden Beispiels implementiert habe.

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

Ausgabe :

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

Aber Sie können jetzt verstehen, warum memmove sich um überlappende Probleme kümmert.

C11 Standardentwurf

Der Standardentwurf C11 N1570 lautet:

7.24.2.1 "Die memcpy-Funktion":

2 Die memcpy-Funktion kopiert n Zeichen von dem Objekt, auf das s2 zeigt, in das Objekt, auf das s1 zeigt. Wenn zwischen überlappenden Objekten kopiert wird, ist das Verhalten undefiniert.

7.24.2.2 "Die memmove-Funktion":

2 Die Funktion memmove kopiert n Zeichen von dem Objekt, auf das s2 zeigt, in das Objekt, auf das s1 zeigt. Das Kopieren erfolgt so, als würden die n Zeichen des Objekts, auf das s2 zeigt, zuerst in ein temporäres Array von n Zeichen kopiert, das die Objekte, auf die s1 und s2 zeigen, nicht überlappt. Anschließend werden die n Zeichen des temporären Arrays kopiert das Objekt, auf das s1 zeigt

Daher führt jede Überlappung memcpyzu undefiniertem Verhalten, und alles kann passieren: schlecht, nichts oder sogar gut. Gut ist allerdings selten :-)

memmove Es wird jedoch klar gesagt, dass alles so geschieht, als ob ein Zwischenpuffer verwendet wird, sodass Überlappungen eindeutig in Ordnung sind.

C ++ std::copyist jedoch verzeihender und erlaubt Überlappungen: Behandelt std :: copy überlappende Bereiche?

Ich habe versucht, dasselbe Programm mit Eclipse auszuführen, und es zeigt einen deutlichen Unterschied zwischen memcpyund memmove. memcpy()Es ist nicht wichtig, dass sich der Speicherort überlappt, was zu einer Beschädigung der Daten führt, während zuerst memmove()Daten in eine temporäre Variable und dann in den tatsächlichen Speicherort kopiert werden.

Beim Versuch, Daten vom Speicherort str1nach zu kopieren str1+2, ist die Ausgabe von memcpy" aaaaaa". Die Frage wäre wie? memcpy()kopiert jeweils ein Byte von links nach rechts. Wie in Ihrem Programm " aabbcc" gezeigt, erfolgt der gesamte Kopiervorgang wie folgt:

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() kopiert zuerst Daten in eine temporäre Variable und dann in den tatsächlichen Speicherort.

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)

Ausgabe ist

memcpy :: aaaaaa

memmove :: aaaabb