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 de
memmove()。
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 en
void*)。 - str2: adresse source, pointant vers la position de départ des données à copier (convertie en
const 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 <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 :
- 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。 - 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. - Si le scénario 2 est remplacé par
memcpy, 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 <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 <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 <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. |
autres extensions