La función memcpy() también se denomina función Copiar bloque de memoria. Se utiliza para hacer una copia de un rango específico de caracteres. La función solo puede copiar los objetos de un bloque de memoria a otro bloque de memoria si ambos no se superponen en ningún punto.

Sintaxis

La sintaxis de la función memcpy() en lenguaje C es la siguiente:

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

La función memcpy() copiará el n carácter especificado de la matriz o ubicación de origen. En este caso, es arr1 a la ubicación de destino que es arr2. Tanto arr1 como arr2 son punteros que apuntan a la ubicación de origen y destino, respectivamente.

Parámetro o argumentos pasados ​​en memcpy()

arr1:es el primer parámetro de la función que especifica la ubicación del bloque de memoria de origen. Representa la matriz que se copiará al destino.arr2:El segundo parámetro de la función especifica la ubicación del bloque de memoria de destino. Representa la matriz donde se copiará el bloque de memoria.norte:Especifica la cantidad de caracteres copiados desde el origen al destino.

Devolver

Devuelve un puntero que es arr1.

Archivo de cabecera

Dado que la función memcpy() está definida en el archivo de encabezado string.h, es necesario incluirla en el código para implementar la función.

ejemplos de sistemas operativos

 #include 

Veamos cómo implementar la función memcpy() en el 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: Es necesario establecer el último índice como nulo en la matriz copiada ya que la función solo copia los datos y no inicializa la memoria en sí. La cadena espera un valor nulo para terminar la cadena.

Datos importantes que se deben tener en cuenta antes de implementar memcpy() en la programación en C:

• La función memcpy() se declara en el archivo de encabezado string.h. Por lo tanto, el programador debe asegurarse de incluir el archivo en el código.
• El tamaño del búfer en el que se copiará el contenido debe ser mayor que el número de bytes que se copiarán en el búfer.
• No funciona cuando los objetos se superponen. El comportamiento no está definido si intentamos realizar la función en los objetos que se superponen.
• Es necesario agregar un carácter nulo cuando se utilizan las cadenas, ya que no verifica los caracteres nulos finales en las cadenas.
• El comportamiento de la función no se definirá si la función accederá al búfer más allá de su tamaño. Es mejor verificar el tamaño del búfer usando la función sizeof().
• No garantiza que el bloque de memoria de destino sea válido en la memoria 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; } 

Producción:

El comportamiento del código no está definido porque el nuevo puntero no apunta a ninguna ubicación válida. Por lo tanto, el programa no funcionará correctamente. En algunos compiladores, también puede devolver un error. El puntero de destino en el caso anterior no es válido.

• La función memcpy() tampoco realiza la validación del búfer de origen.

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

Producción:

El resultado, en este caso, también es similar al del caso anterior, donde no se especificó el destino. La única diferencia aquí es que no devolverá ningún error de compilación. Simplemente mostrará un comportamiento indefinido ya que el puntero de origen no apunta a ninguna ubicación definida.

• Las funciones memcpy() funcionan en el nivel de bytes de los datos. Por lo tanto, el valor de n siempre debe estar en bytes para obtener los resultados deseados.
• En la sintaxis de la función memcpy(), los punteros se declaran nulos * tanto para el bloque de memoria de origen como para el de destino, lo que significa que se pueden utilizar para apuntar a cualquier tipo de datos.

Veamos algunos ejemplos que implementan la función memcpy() para diferentes tipos de datos.

Implementando la función memcpy() con datos de tipo 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; } 

Producción:

Aquí hemos inicializado dos matrices de tamaño 30. sourcearr[] contiene los datos que se copiarán en destarr. Usamos la función memcpy() para almacenar los datos en destarr[].

Implementación de la función memcpy (0 con datos de tipo entero)

 #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++){>

Producción:

En el código anterior, hemos definido la estructura. Hemos utilizado la función memcpy() dos veces. La primera vez que lo usamos para copiar la cadena en prsn1, lo usamos la segunda vez para copiar los datos de prsn1 a prsn2.

Defina su función memcpy() en el lenguaje de programación C

Implementar la función memcpy() en el lenguaje de programación C es comparativamente fácil. La lógica detrás de la función memcpy() es bastante simple. Para implementar la función memcpy(), debe encasillar la dirección de origen y la dirección de destino en char*(1 byte). Una vez realizado el encasillamiento, copie el contenido de la matriz de origen a la dirección de destino. Tenemos que compartir los datos byte a byte. Repita este paso hasta que haya completado n unidades, donde n son los bytes especificados de los datos que se copiarán.

Codifiquemos nuestra propia función memcpy():

Nota: La siguiente función funciona de manera similar a la función memcpy() real, pero muchos casos aún no se tienen en cuenta en esta función definida por el usuario. Usando su función memcpy(), puede decidir condiciones específicas que se incluirán en la función. Pero si no se especifican las condiciones, se prefiere utilizar la función memcpy() definida en la función de la 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; } 

Escribamos un código de controlador para verificar que el código anterior funcione correctamente.

Código de controlador para probar la función MemCpy()

En el siguiente código usaremos arr1 para copiar los datos en arr2 usando la función 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; } 

Producción: