La funció memcpy() també s'anomena funció Copy Memory Block. S'utilitza per fer una còpia d'un rang especificat de caràcters. La funció només és capaç de copiar els objectes d'un bloc de memòria a un altre bloc de memòria si tots dos no es superposen en cap moment.

Sintaxi

La sintaxi de la funció memcpy() en llenguatge C és la següent:

 void *memcpy(void *arr1, const void *arr2, size_t n); 

La funció memcpy() copiarà el caràcter n especificat de la matriu o ubicació d'origen. En aquest cas, és arr1 a la ubicació de destinació que és arr2. Tant arr1 com arr2 són els punters que apunten a la ubicació d'origen i de destinació, respectivament.

Paràmetre o arguments passats a memcpy()

arr1:és el primer paràmetre de la funció que especifica la ubicació del bloc de memòria font. Representa la matriu que es copiarà a la destinació.arr2:El segon paràmetre de la funció especifica la ubicació del bloc de memòria de destinació. Representa la matriu on es copiarà el bloc de memòria.n:Especifica el nombre de caràcters copiats de la font a la destinació.

Tornar

Retorna un punter que és l'arr1.

Fitxer de capçalera

Com que la funció memcpy() es defineix al fitxer de capçalera string.h, cal incloure-la al codi per implementar la funció.

git checkout

 #include 

Vegem com implementar la funció memcpy() al programa 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; } 

Nota: Cal establir l'últim índex com a nul a la matriu copiada, ja que la funció només copia les dades i no inicialitza la memòria mateixa. La cadena espera un valor nul per acabar la cadena.

Fets importants que cal tenir en compte abans d'implementar memcpy() a la programació C:

• La funció memcpy() es declara al fitxer de capçalera string.h. Per tant, el programador ha d'assegurar-se d'incloure el fitxer al codi.
• La mida de la memòria intermèdia en què s'ha de copiar el contingut ha de ser superior al nombre de bytes que s'han de copiar a la memòria intermèdia.
• No funciona quan els objectes es superposen. El comportament no està definit si intentem realitzar la funció sobre els objectes que se superposen.
• Cal afegir un caràcter nul quan s'utilitzen les cadenes, ja que no comprova els caràcters nuls finals a les cadenes.
• El comportament de la funció no es definirà si la funció accedeix a la memòria intermèdia més enllà de la seva mida. És millor comprovar la mida del buffer utilitzant la funció sizeof().
• No garanteix que el bloc de memòria de destinació sigui vàlid a la memòria del sistema o no.

 #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; } 

Sortida:

El comportament del codi no està definit perquè el nou punter no apunta a cap ubicació vàlida. Per tant, el programa no funcionarà correctament. En alguns compiladors, també pot retornar un error. El punter de destinació en el cas anterior no és vàlid.

• La funció memcpy() tampoc realitza la validació de la memòria intermèdia font.

 #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; } 

Sortida:

La sortida, en aquest cas, també és similar a la del cas anterior, on no s'ha especificat la destinació. L'única diferència aquí és que no retornaria cap error de compilació. Només mostrarà un comportament no definit, ja que el punter d'origen no apunta a cap ubicació definida.

• Les funcions memcpy() funcionen al nivell de bytes de les dades. Per tant, el valor de n sempre hauria d'estar en bytes per obtenir els resultats desitjats.
• A la sintaxi de la funció memcpy(), els punters es declaren nuls * tant per al bloc de memòria d'origen com de destinació, el que significa que es poden utilitzar per apuntar cap a qualsevol tipus de dades.

Vegem alguns exemples que implementen la funció memcpy() per a diferents tipus de dades.

Implementació de la funció memcpy() amb dades de tipus 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; } 

Sortida:

Aquí hem inicialitzat dues matrius de mida 30. El sourcearr[] conté les dades que s'han de copiar al destarr. Hem utilitzat la funció memcpy() per emmagatzemar les dades a destarr[].

Implementació de la funció memcpy(0 amb dades de tipus enter

 #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
&apos;); 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[]=&apos;Ashwin&apos;; //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 ( &amp;prsn2, &amp;prsn1, sizeof(prsn1) ); //print the stored data //display the value stored after copying the data //from prsn1 to prsn2 printf (&apos;person2: %s, %d 
&apos;, 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) &amp;&amp; (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) &amp;&amp; (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] = &apos;How Are you ?&apos;; //Source String char dst[20] = {0}; //dst buffer //copy source buffer int dst MemCpy(dst,src,sizeof(src)); printf(&apos;dst = %s
&apos;, 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++){>

Sortida:

En el codi anterior, hem definit l'estructura. Hem utilitzat la funció memcpy() dues vegades. La primera vegada que la vam utilitzar per copiar la cadena a prsn1, la vam utilitzar la segona vegada per copiar les dades del prsn1 a prsn2.

Definiu la vostra funció memcpy() en el llenguatge de programació C

Implementar la funció memcpy() al llenguatge de programació C és relativament fàcil. La lògica és bastant simple darrere de la funció memcpy(). Per implementar la funció memcpy(), heu de escriure l'adreça d'origen i l'adreça de destinació a char*(1 byte). Un cop realitzada la tipificació, ara copieu el contingut de la matriu d'origen a l'adreça de destinació. Hem de compartir les dades byte per byte. Repetiu aquest pas fins que hàgiu completat n unitats, on n són els bytes especificats de les dades a copiar.

Codifiquem la nostra pròpia funció memcpy():

Nota: La funció següent funciona de manera similar a la funció memcpy() real, però molts casos encara no es tenen en compte en aquesta funció definida per l'usuari. Amb la vostra funció memcpy(), podeu decidir condicions específiques que s'inclouran a la funció. Però si no s'especifiquen les condicions, és preferible utilitzar la funció memcpy() definida a la funció de biblioteca.

 //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; } 

Escrivim un codi de controlador per comprovar que el codi anterior funciona correctament si no.

Codi del controlador per provar la funció MemCpy().

Al codi següent, utilitzarem l'arr1 per copiar les dades a l'arr2 mitjançant la funció 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; } 

Sortida: