memcpy () contre memmove ()

J'essaie de comprendre la différence entre memcpy()et memmove(), et j'ai lu le texte qui memcpy()ne prend pas en compte la source et la destination qui se chevauchent alors que le memmove()fait.

Cependant, lorsque j'exécute ces deux fonctions sur des blocs de mémoire qui se chevauchent, elles donnent toutes deux le même résultat. Par exemple, prenez l'exemple MSDN suivant sur la memmove()page d'aide: -

Existe-t-il un meilleur exemple pour comprendre les inconvénients memcpyet comment les memmoverésoudre?

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

Production:

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

Je ne suis pas entièrement surpris que votre exemple ne présente aucun comportement étrange. Essayez plutôt str1de copier str1+2et voyez ce qui se passe ensuite. (Peut ne pas faire de différence, dépend du compilateur / des bibliothèques.)

En général, memcpy est implémenté de manière simple (mais rapide). De manière simpliste, il ne fait que faire une boucle sur les données (dans l'ordre), en copiant d'un emplacement à l'autre. Cela peut entraîner l'écrasement de la source lors de sa lecture.

Memmove fait plus de travail pour s'assurer qu'il gère correctement le chevauchement.

ÉDITER:

(Malheureusement, je ne peux pas trouver d'exemples décents, mais ceux-ci feront l'affaire). Comparez les implémentations memcpy et memmove illustrées ici. memcpy ne fait que faire une boucle, tandis que memmove effectue un test pour déterminer dans quelle direction effectuer la boucle pour éviter de corrompre les données. Ces implémentations sont assez simples. La plupart des implémentations hautes performances sont plus compliquées (impliquant la copie de blocs de taille de mot à la fois plutôt que d'octets).

La mémoire dans memcpy ne peut pas se chevaucher ou vous risquez un comportement indéfini, tandis que la mémoire dans memmovepeut se chevaucher.

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. 

Certaines implémentations de memcpy peuvent toujours fonctionner pour des entrées qui se chevauchent, mais vous ne pouvez pas compter ce comportement. Alors que memmove doit permettre le chevauchement.

Ce memcpyn'est pas parce qu'il n'a pas à faire face à des régions qui se chevauchent que cela ne signifie pas qu'il les traite correctement. L'appel avec des régions qui se chevauchent produit un comportement indéfini. Un comportement non défini peut fonctionner entièrement comme prévu sur une seule plateforme; cela ne veut pas dire que c'est correct ou valide.

Memcpy et memove font des choses similaires.

Mais pour voir une différence:

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

}

donne:

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

Votre démo n'a pas exposé les inconvénients de memcpy à cause d'un "mauvais" compilateur, elle vous rend service dans la version Debug. Une version finale, cependant, vous donne le même résultat, mais à cause de l'optimisation.

    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  

Le registre %eaxjoue ici comme un stockage temporaire, qui corrige "élégamment" le problème de chevauchement.

L'inconvénient apparaît lors de la copie de 6 octets, au moins une partie de celui-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);
}

Production:

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

Ça a l'air bizarre, c'est aussi causé par l'optimisation.

    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  

C'est pourquoi je choisis toujours memmoveen essayant de copier 2 blocs de mémoire superposés.

La différence entre memcpyet memmoveest que

1. dans memmove, la mémoire source de la taille spécifiée est copiée dans la mémoire tampon, puis déplacée vers la destination. Donc, si la mémoire se chevauche, il n'y a pas d'effets secondaires.

2. dans le cas de memcpy(), aucun tampon supplémentaire n'est utilisé pour la mémoire source. La copie se fait directement sur la mémoire afin qu'en cas de chevauchement de mémoire, nous obtenions des résultats inattendus.

Ceux-ci peuvent être observés par le code suivant:

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

La sortie est:

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

Comme déjà souligné dans d'autres réponses, memmoveest plus sophistiqué que memcpytel qu'il tient compte des chevauchements de mémoire. Le résultat de memmove est défini comme si le srcétait copié dans un tampon, puis copié dans le tampon dst. Cela ne signifie PAS que l'implémentation réelle utilise un tampon, mais fait probablement une arithmétique de pointeur.

compilateur pourrait optimiser memcpy, par exemple:

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

Ce memcpy peut être optimisé comme: x = *(int*)some_pointer;

Le code donné dans les liens http://clc-wiki.net/wiki/memcpy pour memcpy semble me dérouter un peu, car il ne donne pas le même résultat lorsque je l'ai implémenté en utilisant l'exemple ci-dessous.

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

Production :

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

Mais vous pouvez maintenant comprendre pourquoi memmove s'occupera du problème de chevauchement.

Projet standard C11

Le projet standard C11 N1570 dit:

7.24.2.1 "La fonction memcpy":

2 La fonction memcpy copie n caractères de l'objet pointé par s2 dans l'objet pointé par s1. Si la copie a lieu entre des objets qui se chevauchent, le comportement n'est pas défini.

7.24.2.2 "La fonction memmove":

2 La fonction memmove copie n caractères de l'objet pointé par s2 dans l'objet pointé par s1. La copie a lieu comme si les n caractères de l'objet pointé par s2 étaient d'abord copiés dans un tableau temporaire de n caractères qui ne chevauche pas les objets pointés par s1 et s2, puis les n caractères du tableau temporaire sont copiés dans l'objet pointé par s1

Par conséquent, tout chevauchement memcpyconduit à un comportement indéfini, et tout peut arriver: mauvais, rien ou même bien. Le bien est rare cependant :-)

memmove cependant dit clairement que tout se passe comme si un tampon intermédiaire est utilisé, donc clairement les chevauchements sont OK.

std::copyCependant, C ++ est plus indulgent et autorise les chevauchements: std :: copy gère-t-il les plages qui se chevauchent?

J'ai essayé d'exécuter le même programme en utilisant eclipse et cela montre une différence claire entre memcpyet memmove. memcpy()ne se soucie pas du chevauchement de l'emplacement de la mémoire qui entraîne la corruption des données, alors que memmove()copiera d'abord les données dans une variable temporaire, puis copiera dans l'emplacement de mémoire réel.

Lors de la tentative de copie des données de l'emplacement str1vers str1+2, la sortie de memcpyest " aaaaaa". La question serait comment? memcpy()copiera un octet à la fois de gauche à droite. Comme indiqué dans votre programme " aabbcc", toutes les copies auront lieu comme ci-dessous,

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() copiera d'abord les données dans la variable temporaire, puis copiera dans l'emplacement de mémoire réel.

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)

La sortie est

memcpy : aaaaaa

memmove : aaaabb