memcpy () vs memmove()

ce n'est pas parce que memcpy n'a pas à traiter avec les régions qui se chevauchent, que cela ne veut pas dire qu'il ne traite pas avec eux correctement. L'appel avec des régions qui se chevauchent produit un comportement non défini. Un comportement non défini peut fonctionner entièrement comme vous l'attendez sur une plate-forme; cela ne signifie pas qu'il est correct ou valide.

memcpy et memove font des choses similaires.

mais à voir une différence:

#include <memory.h>
#include <string.h>
#include <stdio.h>

char str1[17] = "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( "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 de" mauvais " compilateur, il vous fait une faveur dans la version de débogage. Une version de publication, cependant, vous donne la même sortie, 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 %eax joue ici comme un stockage temporaire, qui "élégamment" correctifs de problème de chevauchement.

l'inconvénient émerge quand on copie 6 octets, enfin, 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);
}

sortie:

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

semble bizarre, il est causé par l'optimisation, aussi.

    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 memmove en essayant de copier 2 blocs de mémoire superposés.

la différence entre memcpy et memmove est que

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

2. dans le cas de memcpy() , il n'y a pas de tampon supplémentaire pour la mémoire source. La copie se fait directement sur la mémoire de sorte que lorsqu'il y a chevauchement de mémoire, 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);
}

sortie:

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

comme il a déjà été souligné dans d'autres réponses, memmove est plus sophistiqué que memcpy de sorte 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 dst . Cela ne signifie pas que la mise en œuvre réelle utilise un tampon, mais fait probablement une certaine arithmétique pointeur.

compilateur pourrait optimiser memcpy, par exemple:

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

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

le code indiqué dans les liens http://clc-wiki.net/wiki/memcpy pour memcpy semble m'embrouiller un peu, car il ne donne pas la même sortie 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();
}

sortie:

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

mais vous pouvez maintenant comprendre pourquoi memmove va prendre soin de la question de chevauchement.

j'ai essayé d'exécuter le même programme en utilisant eclipse et il montre une nette différence entre memcpy et memmove . memcpy() ne se soucie pas de chevauchement de l'emplacement de mémoire qui entraîne la corruption des données, tandis que memmove() va copier les données à la variable temporaire d'abord et ensuite copier dans l'emplacement de mémoire réelle.

en essayant de copier des données de l'emplacement str1 à str1+2 , la sortie de memcpy est aaaaaa ". Question serait comment? memcpy() copie d'un octet à la fois de gauche à droite. Comme indiqué dans votre programme " aabbcc " alors toute copie aura lieu comme ci-dessous,

1. aabbcc -> aaabcc

2. aaabcc -> aaaacc

3. aaaacc -> aaaaac

4. aaaaac -> aaaaaa

memmove() copie les données à la variable temporaire d'abord, puis copie à l'emplacement de la mémoire réelle.

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)

Sortie

memcpy : aaaaaa

memmove : aaaabb