Fonction de la bibliothèque C - memmove()

Bibliothèque standard C - string.h


memmove()est la bibliothèque standard C<string.h>fonction de manipulation de mémoire qu'elle contient, utilisée pour copier un nombre spécifié d'octets depuis l'adresse source vers l'adresse de destination, et qui peut gérer en toute sécurité les cas de chevauchement de mémoire.

Définitions de mots:memmoveOuimemory moveAbréviation de (memory move), qui signifie déplacer des données en mémoire.

Fonctions de la bibliothèque Cvoid *memmove(void *str1, const void *str2, size_t n)depuisstr2Copiernoctets versstr1。

Différence avec memcpy():

  • Lorsque la région de destination et la région source se chevauchent en mémoire,memmove()elle peut garantir qu'avant que les données source ne soient écrasées, les octets qui se chevauchent sont d'abord transférés en toute sécurité vers la région de destination, donc comparé àmemcpy()plus fiable.
  • lorsque la région de destination et la région source ne se chevauchent pas du tout,memmove()le comportement etmemcpy()Idem.
  • lorsqu'on ne sait pas si les deux régions mémoire se chevauchent, il faut privilégier l'utilisation dememmove()。

Déclaration de fonction

void *memmove(void *str1, const void *str2, size_t n)

Description des paramètres

  • str1: adresse de destination, pointant vers la zone mémoire utilisée pour stocker le contenu copié (convertie envoid*)。
  • str2: adresse source, pointant vers la position de départ des données à copier (convertie enconst void*)。
  • n: le nombre d'octets à copier (size_ttype).

Valeur de retour

renvoie un pointeur vers la zone de stockage de destinationstr1pointeur (identique à celui passé enstr1identique).

Fichier d'en-tête

#include <string.h>

Exemple

Exemple 1 : Utilisation de base

L'exemple suivant illustrememmove()Utilisation dans les scénarios sans chevauchement et avec chevauchement :

Exemple

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

int main()
{
    /* Scénario 1 : copie mémoire sans chevauchement */
    char dest[] = "oldstring";
    char src[]  = "newstring";

    printf("Avant la copie sans chevauchement:dest = %s, src = %s\n", dest, src);
    memmove(dest, src, 9);
    printf("Après la copie sans chevauchement:dest = %s, src = %s\n", dest, src);

    /* Scénario 2: copie mémoire avec chevauchement (où memmove a l'avantage) */
    char str[] = "123456789";
    printf("\nAvant la copie avec chevauchement:%s\n", str);
    memmove(str + 2, str, 6);
    printf(Après la copie avec chevauchement: %s\n", str);

    return 0;
}

Résultat de l'exécution :

非重叠拷贝前:dest = oldstring, src = newstring
非重叠拷贝后:dest = newstring, src = newstring

重叠拷贝前:123456789
重叠拷贝后:121234569

Analyse du code :

  1. Dans le scénario 1,destetsrcsont deux tableaux indépendants, aucun chevauchement,memmove(dest, src, 9)vasrcles 9 premiers octets sont copiés sans modification versdest。
  2. Dans le scénario 2,str + 2(destination) etstr(source) pointe vers une région qui se chevauche dans le même tableau,memmoveenregistre d'abord les données écrasées, puis termine la copie, de sorte que le résultat soit correct.
  3. Si le scénario 2 est remplacé parmemcpy, peut produire des résultats incorrects sur certains compilateurs ou plateformes, carmemcpyne garantit pas la gestion des cas de chevauchement.

Exemple 2 : Gestion de la mémoire qui se chevauche

Lorsque deux zones de mémoire se chevauchent,memmove()peut toujours donner le résultat correct :

Exemple

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

int main()
{
    char str[] = "memmove can be very useful";

    printf("Before: %s\n", str);
    /* Copier 7 octets à partir de la position 11 vers la position 5 ; les deux régions se chevauchent */
    memmove(str + 5, str + 11, 7);
    printf("Après : %s\n", str);

    return 0;
}

Résultat de l'exécution :

Before: memmove can be very useful
After:  memmove can be very useful

Analyse du code :

  • Dans la chaîne d'origine, à partir de la position 5 se trouve"ve can be very useful", les 7 octets à partir de la position 11 sont"can be"(y compris l'espace final).
  • memmove(str + 5, str + 11, 7)va"can be"déplacé à la position 5, les deux régions se chevauchent, maismemmoveIl sélectionnera une stratégie de copie en avant ou en arrière en fonction de la taille des adresses pour garantir l'intégrité des données.
  • Après la copie, le contenu à partir de la position 5 devient"can be", tandis que les caractères restants restent inchangés.

Exemple 3 : Comparer memcpy() et memmove()

L'exemple suivant montre que dans le même scénario de chevauchement, les deux fonctions peuvent produire des résultats différents :

Exemple

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

int main()
{
    char str1[] = "abcdefghij";
    char str2[] = "abcdefghij";

    printf("Original : %s\n", str1);

    /* Utilisation de memcpy : comportement indéfini en cas de chevauchement */
    memcpy(str1 + 2, str1, 5);
    printf("memcpy: %s\n", str1);

    /* Utilisation de memmove : comportement garanti en cas de chevauchement */
    memmove(str2 + 2, str2, 5);
    printf("memmove: %s\n", str2);

    return 0;
}

Résultat de l'exécution :

Original: abcdefghij
memcpy:   ababababij
memmove:  ababcdfghij

Description: dans cet exemple,memcpyParce que la copie octet par octet vers l'avant entraîne l'écrasement prématuré des données source, la sortie ne correspond pas aux attentes ; tandis quememmoveil détecte le chevauchement et utilise une copie inverse, donc le résultat est correct. Les différentes plateformes ou compilateursmemcpyle comportement d'implémentation peut être incohérent, il faut donc toujours l'utiliser lorsqu'on rencontre des scénarios de chevauchement.memmove。


Exemple 4 : Copier le nombre d'octets spécifié

memmove()est une opération au niveau des octets et n'écrit pas automatiquement le terminateur de chaîne ; lorsque vous l'utilisez, vous devez l'ajouter manuellement.'\0':

Exemple

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

int main()
{
    char src[]  = "Hello, World!";
    char dest[20];

    /* Copier uniquement les 5 premiers octets */
    memmove(dest, src, 5);
    dest[5] = '\0';  /* Ajouter manuellement le terminateur de chaîne */

    printf("Source : %s\n", src);
    printf("Dest : %s\n", dest);
    printf("Longueur : %zu\n", strlen(dest));

    return 0;
}

Résultat de l'exécution :

Source: Hello, World!
Dest:   Hello
Length: 5

Analyse du code :

  • memmove(dest, src, 5)ne copie que les 5 premiers octets ('H' 'e' 'l' 'l' 'o')。
  • memmove()n'écrira pas automatiquement à la fin de la destination'\0', s'il est omisdest[5] = '\0', les opérations suivantes sur les chaînes (telles queprintf、strlen) liront une mémoire indéterminée, entraînant un comportement indéfini.

Différence avec memcpy()

Fonctionnalités memcpy() memmove()
Gestion des chevauchements de mémoire Le comportement est indéfini, ce qui peut produire des résultats erronés Gestion sécurisée, garantissant une copie correcte
Approche d'implémentation Copie directement octet par octet dans l'ordre Détecte la direction du chevauchement, choisit une copie vers l'avant ou vers l'arrière
Performance Généralement légèrement plus rapide (sans surcoût de détection de chevauchement) Légèrement plus lent (inclut la logique de détection de chevauchement)
Suggestions d'utilisation À utiliser pour confirmer que la source et la destination ne se chevauchent pas du tout À utiliser lorsqu'il y a chevauchement ou lorsqu'on ne sait pas s'il y a chevauchement.

Bibliothèque standard C - string.h

autres extensions