Comment utiliser et quand est-il bon d'utiliser memmove en C?

J'ai deux doutes au sujet de l'utilisation de memmove():

  • Quand est préférable d'utiliser cette fonction plutôt que d'en utiliser une autre fonction (c'est à dire une fonction propre)? Je ne suis pas sûr que j'ai compris correctement.
  • La signature de la fonction est void *memmove(void *dest, const void *src, size_t n). Si j'ai un tableau simple arr[N]comment puis-je le mettre dans la fonction appelée? arr[N] ou &arr[N]? La différence est que si le tableau est déclaré avec une taille initiale, ou comme un pointeur? J'ai ce doute parce que j'ai vu de nombreux exemples où est utilisé à la fois.

J'espère que j'ai expliqué mes doutes sur la bonne voie.

edit: j'ai supprimer un élément du tableau, et puis je veux décaler les éléments suivants de l'supprimés sur la gauche.

source d'informationauteur Kyrol

  1. 14
    1. memmove peut être plus rapide, mais il ne sera probablement jamais être plus lent que votre propre fonction pour copier des données (c'est généralement codé soigneusement conçue à l'assemblée pour déplacer des choses autour de la manière la plus efficace possible sur l'architecture actuelle);
    2. cela dépend de ce que vous voulez faire avec ce tableau... si vous voulez copier son contenu à un autre tableau arr suffira (et, comme la longueur de paramètre, vous devez faire sizeof(*arr)*N où N est le nombre d'éléments à copier).

    Par ailleurs, si la source et la destination et la copie sont ne se chevauchent pas memcpy peut être plus rapide.

    Je veux supprimer un élément de la matrice et la maj gauche de l'élément de la même matrice.

    int arr[N];
/* ... */
/* Let's say you want to remove the element i (error checking on i omitted) */
memmove(arr+i, arr+i+1, (N-i-1)*sizeof(*arr));
/* or, if you prefer array indexing over pointer arithmetics: */
memmove(&arr[i], &arr[i+1], (N-i-1)*sizeof(*arr));

    (sizeof(*arr) signifie "obtenir la taille d'un élément du tableau")

  2. 4

    memmove est comme memcpy à l'exception de la destination et la source de tableau peuvent se chevaucher.

    Avec memcpy vous promets que les régions ne sont pas superposées qui permet la mise en œuvre d'effectuer quelques optimisations supplémentaires. Donc memcpy peut être plus rapide que memmove.

    La memmove fonction prend un void * argument de destination et un const void * argument de source. Cela signifie que vous pouvez appeler la fonction avec la destination et la source argument de type tableau, car ils seront convertis en types de pointeur. Et comme vous pouvez assigner n'importe quel non-qualifiés objet de type pointeur de void * ou const void *vous n'aurez pas besoin de cast lors de l'appel de la fonction.

    char src[1024] = {0};
char dst[1024];

memmove(dst, src, sizeof dst);
/* src and dst don't overlap you should choose memcpy instead */
memcpy(dst, src, sizeof dst);

    Maintenant, il est généralement préférable d'utiliser memcpy ou memmove que votre propre code de fonction. Dans la glibc, par exemple, selon le MCU et jeu d'instructions de la taille de la copie, memcpy peut être remplacé par le compilateur avec quelques rapide inline assemblée versions de memcpy.

  3. 0

    Quand est préférable d'utiliser cette fonction plutôt que d'en utiliser une autre fonction (c'est à dire une fonction propre)

    C'est plus rapide qu'un "créé une fonction".

    la signature de la fonction est void *memmove(void *dest, const void *src, size_t n). Si j'ai un tableau simple arr[N], comment puis-je le mettre dans la fonction appelée? arr[N] ou &arr[N]

    Juste arr?