La fonction memcpy() est également appelée fonction Copier le bloc mémoire. Il est utilisé pour faire une copie d'une plage spécifiée de caractères. La fonction n'est capable de copier les objets d'un bloc de mémoire à un autre bloc de mémoire que s'ils ne se chevauchent à aucun moment.
Syntaxe
La syntaxe de la fonction memcpy() en langage C est la suivante :
void *memcpy(void *arr1, const void *arr2, size_t n);
La fonction memcpy() copiera le n caractère spécifié à partir du tableau ou de l'emplacement source. Dans ce cas, c'est arr1 vers l'emplacement de destination qui est arr2. arr1 et arr2 sont tous deux les pointeurs qui pointent respectivement vers l’emplacement source et destination.
Paramètre ou arguments passés dans memcpy()
Retour
Il renvoie un pointeur qui est le arr1.
garniture javascript
En tête de fichier
Puisque la fonction memcpy() est définie dans le fichier d'en-tête string.h, il est nécessaire de l'inclure dans le code pour implémenter la fonction.
#include
Voyons comment implémenter la fonction memcpy() dans le programme C.
//Implementation of memcpy() in C Programming #include #include int main(int argc, const char * argv[]) { //initializing a variable that will hold the result./* Create a place to store our results */ int res; //declare the arrays for which you want to copy the data and //in which you want to copy it char orgnl[50]; char copy[50]; //Entering a string the orgnl array strcpy(orgnl, 'This is the program for implementing the memcpy() in C Program'); //use the memcpy() function to copy the characters from the source to destination. res = memcpy(copy, orgnl, 27); // we have specified n as 27 this means it will copy the first 27 character of //orgnl array to copy array //set the value for last index in the copy as 0 copy[27] = 0; //display the copied content printf('%s
', copy); return 0; } Remarque : Il est nécessaire de définir le dernier index comme nul dans le tableau copié car la fonction copie uniquement les données et n'initialise pas la mémoire elle-même. La chaîne attend une valeur nulle pour terminer la chaîne.
Faits importants à prendre en compte avant d'implémenter memcpy() dans la programmation C :
- La fonction memcpy() est déclarée dans le fichier d'en-tête string.h. Le programmeur doit donc s'assurer d'inclure le fichier dans le code.
- La taille du tampon dans lequel le contenu doit être copié doit être supérieure au nombre d'octets à copier dans le tampon.
- Cela ne fonctionne pas lorsque les objets se chevauchent. Le comportement est indéfini si l'on essaie d'exécuter la fonction sur les objets qui se chevauchent.
- Il est nécessaire d'ajouter un caractère nul lors de l'utilisation des chaînes car il ne vérifie pas les caractères nuls de fin dans les chaînes.
- Le comportement de la fonction ne sera pas défini si la fonction accède au tampon au-delà de sa taille. Il est préférable de vérifier la taille du tampon en utilisant la fonction sizeof().
- Cela ne garantit pas que le bloc mémoire de destination est valide ou non dans la mémoire du système.
#include #include int main () { //The first step is to initialize the source and destination array. char* new; char orgnl[30] = 'Movetheobject'; //Print the contents before performing memcpy() function. printf('Before implementing memcpy() destination and source memory block respt is
new = %s
orgnl = %s
', new, orgnl); memcpy(new, orgnl, sizeof(orgnl)); //Display the content in both new and orgnl array after implementing memcpy. printf('After memcpy >> new = %s
orgnl = %s
', new, orgnl); return 0; } Sortir:
Le comportement du code n'est pas défini car le nouveau pointeur ne pointe vers aucun emplacement valide. Le programme ne fonctionnera donc pas correctement. Dans certains compilateurs, cela peut également renvoyer une erreur. Le pointeur de destination dans le cas ci-dessus n'est pas valide.
- La fonction memcpy() n'effectue pas non plus la validation du tampon source.
#include #include int main () { //The first step is to initialize the source and destination array. char new[10]= {1}; char *orgnl; //Print the contents before performing memcpy() function. printf('Before implementing memcpy() destination and source memory block respt is
new = %s
orgnl = %s
', new, orgnl); memcpy(new, orgnl, sizeof(orgnl)); //Display the content in both new and orgnl array after implementing memcpy. printf('After memcpy >> new = %s
orgnl = %s
', new, orgnl); return 0; } Sortir:
Le résultat, dans ce cas, est également similaire à celui du cas ci-dessus, où la destination n'a pas été spécifiée. La seule différence ici est que cela ne renvoie aucune erreur de compilation. Il affichera simplement un comportement indéfini car le pointeur source ne pointe vers aucun emplacement défini.
pages du serveur Java
- Les fonctions memcpy() fonctionnent au niveau octet des données. Par conséquent, la valeur de n doit toujours être en octets pour obtenir les résultats souhaités.
- Dans la syntaxe de la fonction memcpy(), les pointeurs sont déclarés void * pour le bloc mémoire source et destination, ce qui signifie qu'ils peuvent être utilisés pour pointer vers n'importe quel type de données.
Voyons quelques exemples implémentant la fonction memcpy() pour différents types de données.
Implémentation de la fonction memcpy() avec des données de type char
#include #include int main() { //initialize the source array, //the data will be copied from source to destination/ char sourcearr[30] = 'This content is to be copied.'; //this is the destination array //data will be copied at this location. char destarr[30] = {0}; //copy the data stored in the sourcearr buffer into destarr buffer memcpy(destarr,sourcearr,sizeof(sourcearr)); //print the data copied into destarr printf('destination array content is now changed to
= %s
', destarr); return 0; } Sortir:
contrôle du programme stocké
Ici, nous avons initialisé deux tableaux de taille 30. Le sourcearr[] contient les données à copier dans le destarr. Nous avons utilisé la fonction memcpy() pour stocker les données dans destarr[].
Implémentation de la fonction memcpy (0 avec des données de type entier
#include #include int main() { //initialize the source array, //the data will be copied from source to destination/ int sourcearr[100] = {1,2,3,4,5}; //this is the destination array //data will be copied at this location. int destarr[100] = {0}; //copy the data stored in the sourcearr buffer into destarr buffer memcpy(destarr,sourcearr,sizeof(sourcearr)); //print the data copied into destarr printf('destination array content is now changed to
'); for(int i=0;i<5;i++){ printf('%d', destarr[i]); }return 0;} < pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/16/memcpy-c-4.webp" alt="memcpy() in C"> <p>In this code, we have stored the integers in the array. Both the arrays can store int datatype. We have used the indexes to print the elements of the destarr after copying the elements of the sourcearr into destarr.</p> <h3>Implementing the memcpy() function with struct datatype</h3> <pre> #include #include struct { char name[40]; int age; } prsn1, prsn2; int main() { // char firstname[]='Ashwin'; //Using the memcpy() function to copy the data from //firstname to the struct //add it is as prsn1 name memcpy ( prsn1.name, firstname, strlen(firstname)+1 ); //initialize the age of the prsn1 prsn1.age=20; //using the memcpy() function to copy one person to another //the data will be copied from prsn1 to prsn2 memcpy ( &prsn2, &prsn1, sizeof(prsn1) ); //print the stored data //display the value stored after copying the data //from prsn1 to prsn2 printf ('person2: %s, %d
', prsn2.name, prsn2.age ); return 0; } </pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/16/memcpy-c-5.webp" alt="memcpy() in C"> <p>In the above code, we have defined the structure. We have used the memcpy() function twice. The first time we used it to copy the string into prsn1, we used it the second time to copy the data from the prsn1 to prsn2.</p> <h2>Define your memcpy() function in C Programming Language</h2> <p>Implementing the memcpy() function in the C Programming language is comparatively easy. The logic is quite simple behind the memcpy() function. To implement the memcpy() function, you must typecast the source address and the destination address to char*(1 byte). Once the typecasting is performed, now copy the contents from the source array to the destination address. We have to share the data byte by byte. Repeat this step until you have completed n units, where n is the specified bytes of the data to be copied.</p> <p>Let us code our own memcpy() function:</p> <h4>Note: The function below works similarly to the actual memcpy() function, but many cases are still not accounted for in this user-defined function. Using your memcpy() function, you can decide specific conditions to be included in the function. But if the conditions are not specified, it is preferred to use the memcpy() function defined in the library function.</h4> <pre> //this is just the function definition for the user defined memcpy() function. void * MemCpy(void* destinatn, const void* source, unsigned int cn) { char *pntDest = (char *)destinatn; const char *pntSource =( const char*)source; if((pntDest!= NULL) && (pntSource!= NULL)) { while(cn) //till cn the loop will be executed { //copy the contents from source to dest //the data should be copied byte by byte *(pntDest++)= *(pntSource++); //decrement the value of cn --cn; } } return destinatn; } </pre> <p>Let us write a driver code to check that above code is working properly on not.</p> <p>Driver Code to test MemCpy() Function</p> <p>In the code below we will use the arr1 to copy the data into the arr2 by using MemCpy() function.</p> <pre> void * MemCpy(void* destinatn, const void* source, unsigned int cn) { char *pntDest = (char *)destinatn; const char *pntSource =( const char*)source; if((pntDest!= NULL) && (pntSource!= NULL)) { while(cn) //till cn the loop will be executed { //copy the contents from source to dest //the data should be copied byte by byte *(pntDest++)= *(pntSource++); //decrement the value of cn --cn; } } return destinatn; } int main() { char src[20] = 'How Are you ?'; //Source String char dst[20] = {0}; //dst buffer //copy source buffer int dst MemCpy(dst,src,sizeof(src)); printf('dst = %s
', dst); return 0; } </pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/16/memcpy-c-6.webp" alt="memcpy() in C"> <hr></5;i++){> Sortir:
Dans le code ci-dessus, nous avons défini la structure. Nous avons utilisé la fonction memcpy() deux fois. La première fois que nous l'avons utilisé pour copier la chaîne dans prsn1, nous l'avons utilisé la deuxième fois pour copier les données de prsn1 vers prsn2.
Définissez votre fonction memcpy() en langage de programmation C
L'implémentation de la fonction memcpy() dans le langage de programmation C est relativement simple. La logique derrière la fonction memcpy() est assez simple. Pour implémenter la fonction memcpy(), vous devez transtyper l'adresse source et l'adresse de destination en char*(1 octet). Une fois le transtypage effectué, copiez maintenant le contenu du tableau source vers l'adresse de destination. Nous devons partager les données octet par octet. Répétez cette étape jusqu'à ce que vous ayez terminé n unités, où n représente les octets spécifiés des données à copier.
Codons notre propre fonction memcpy() :
Remarque : La fonction ci-dessous fonctionne de manière similaire à la fonction memcpy() réelle, mais de nombreux cas ne sont toujours pas pris en compte dans cette fonction définie par l'utilisateur. En utilisant votre fonction memcpy(), vous pouvez décider des conditions spécifiques à inclure dans la fonction. Mais si les conditions ne sont pas précisées, il est préférable d'utiliser la fonction memcpy() définie dans la fonction bibliothèque.
//this is just the function definition for the user defined memcpy() function. void * MemCpy(void* destinatn, const void* source, unsigned int cn) { char *pntDest = (char *)destinatn; const char *pntSource =( const char*)source; if((pntDest!= NULL) && (pntSource!= NULL)) { while(cn) //till cn the loop will be executed { //copy the contents from source to dest //the data should be copied byte by byte *(pntDest++)= *(pntSource++); //decrement the value of cn --cn; } } return destinatn; } Écrivons un code de pilote pour vérifier que le code ci-dessus fonctionne correctement.
gimp changer de couleur
Code du pilote pour tester la fonction MemCpy()
Dans le code ci-dessous, nous utiliserons l'arr1 pour copier les données dans l'arr2 en utilisant la fonction MemCpy().
void * MemCpy(void* destinatn, const void* source, unsigned int cn) { char *pntDest = (char *)destinatn; const char *pntSource =( const char*)source; if((pntDest!= NULL) && (pntSource!= NULL)) { while(cn) //till cn the loop will be executed { //copy the contents from source to dest //the data should be copied byte by byte *(pntDest++)= *(pntSource++); //decrement the value of cn --cn; } } return destinatn; } int main() { char src[20] = 'How Are you ?'; //Source String char dst[20] = {0}; //dst buffer //copy source buffer int dst MemCpy(dst,src,sizeof(src)); printf('dst = %s
', dst); return 0; } Sortir:
