Différence entre memcpy et memmove

+---+---+---+---+---+---+---+
| 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+

memmove()

+---+---+---+---+---+---+---+
| 1 | 2 | 3 | 1 | 2 | 3 | 4 |
+---+---+---+---+---+---+---+

memcpy()

+---+---+---+---+---+---+---+
| 1 | 2 | 3 | 1 | 2 | 3 | 1 |
+---+---+---+---+---+---+---+

memcpy()

memcpy()

memcpy()

int tab[10] = {1, 2, 3, 4, 5, 6, 7};
int tab2[10];
strncpy(tab2,tab1,4);

memmove(tab + 3, tab2, strlen(tab))
memcpy(tab + 3, tab2, strlen(tab))

memcpy

memmove

memmove

memcpy

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

void * Memcpy(void* dst, const void* src, unsigned int cnt)
{
    char *pszDest = (char *)dst;
    const char *pszSource =( const char*)src;
    if((pszDest!= NULL) && (pszSource!= NULL))
    {
        while(cnt) //till cnt
        {
            //Copy byte by byte
            *(pszDest++)= *(pszSource++);
            --cnt;
        }
    }
    return dst;
}

int main(void){
    char chaine[7] = "aabbcc";
    Memcpy(chaine + 2, chaine, 4);
    printf("%s\n", chaine);
    return 0;
}

• Memcpy

  renvoie

  aaaaaa

  ;

• memcpy

  renvoie

  aaaabb

  .

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

void myMemCpy(void *dest, void *src, size_t n){
  // Typecast src and dest addresses to (char *)
  char *csrc = (char *)src;
  char *cdest = (char *)dest;
  
  // Copy contents of src[] to dest[]
  for (int i = 0; i < n; i++)
    cdest[i] = csrc[i];
}

int main(void){
    char str1[7] = "aabbcc";
    myMemMove(str1 + 2, str1, 4);
    printf("New string: %s\n", str1);
    return 0;
}

• mymencpy

  renvoie

  aaaaaa

  ;

• memcpy

  renvoie

  aaaabb

  .

memcpy

memmove

memcpy

man memmove

man memcpy

• memcpy

  copie un bloc mémoire d'une adresse vers une autre adresse. Le bloc cible doit être préalloué en mémoire pour accueillir le bloc source, sinon tu as en général une erreur de segmentation. La recopie se fait typiquement octet par octet (et pour rappel un caractère ASCII (

  char

  ) fait un octet, c'est pourquoi cette fonction est très proche de

  strcpy

  et donc dans

  <string.h>

  ) : on lit l'octet source courant, on le recopie dans l'octet cible correspondant, et on répète l'opération jusqu'à avoir traité tout le bloc.
• Officiellement

  memmove

  déplace un bloc mémoire d'une adresse vers une autre adresse. Le bloc cible doit être préalloué en mémoire pour accueillir le bloc source, sinon tu as en général une erreur de segmentation. Il n'y aucune garantie sur ce qui restera au niveau du bloc de départ mais la plupart des implémentations se contentent de le laisser tel quel afin d'améliorer la performance (et pour ces implémentation,

  memmove

  fait exactement la même chose que

  memcpy

  quand les blocs sources et cibles ne se chevauchent pas). Dans ces situations, on utilise plus

  memmove

  pour la lisibilité du programme. Cependant le bloc source ne doit plus être lu car selon l'implémentation, il pourrait avoir été réinitialisé.

• D'après cette page,

  memmove

  passe par un buffer intermédiaire pour se prémunir de ces effets de bord .
• D'après cette page, ce n'est pas le cas de

  memcpy

  , et donc il faut être vigilant à ce qu'on fait.

strcpy

memcpy

uint32_t

'\0'

uint8_t

0

str*

strcpy

strlen

printf

"abc"

{'a', 'b', 'c', '\0'}

str*

memcpy

strcpy

'\0'

memcpy

const void *

void *

'\0'

'\0'

strcpy

memcpy