A função memcpy() também é chamada de função Copiar Bloco de Memória. É usado para fazer uma cópia de um intervalo especificado de caracteres. A função só é capaz de copiar os objetos de um bloco de memória para outro bloco de memória se ambos não se sobrepuserem em nenhum ponto.

Sintaxe

A sintaxe da função memcpy() na linguagem C é a seguinte:

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

A função memcpy() copiará o n caractere especificado do array ou local de origem. Neste caso, é arr1 para o local de destino que é arr2. Tanto arr1 quanto arr2 são ponteiros que apontam para o local de origem e destino, respectivamente.

Parâmetro ou argumentos passados ​​em memcpy()

arr1:é o primeiro parâmetro da função que especifica a localização do bloco de memória de origem. Representa o array que será copiado para o destino.arr2:O segundo parâmetro da função especifica a localização do bloco de memória de destino. Representa o array onde o bloco de memória será copiado.n:Especifica o número de caracteres copiados da origem ao destino.

Retornar

Ele retorna um ponteiro que é o arr1.

Arquivo de cabeçalho

Como a função memcpy() está definida no arquivo de cabeçalho string.h, é necessário incluí-la no código para implementar a função.

 #include 

Vamos ver como implementar a função memcpy() no 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: É necessário definir o último índice como nulo no array copiado, pois a função apenas copia os dados e não inicializa a memória em si. A string espera um valor nulo para encerrar a string.

Fatos importantes a serem considerados antes de implementar memcpy() na programação C:

• A função memcpy() é declarada no arquivo de cabeçalho string.h. Portanto, o programador precisa garantir a inclusão do arquivo no código.
• O tamanho do buffer no qual o conteúdo será copiado deve ser maior que o número de bytes a serem copiados no buffer.
• Não funciona quando os objetos se sobrepõem. O comportamento é indefinido se tentarmos executar a função nos objetos que se sobrepõem.
• É necessário adicionar um caractere nulo ao usar as strings, pois ele não verifica os caracteres nulos de terminação nas strings.
• O comportamento da função não será definido se a função acessar o buffer além do seu tamanho. É melhor verificar o tamanho do buffer usando a função sizeof().
• Não garante que o bloco de memória de destino seja válido na memória do sistema ou não.

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

Saída:

O comportamento do código não está definido porque o novo ponteiro não aponta para nenhum local válido. Portanto, o programa não funcionará corretamente. Em alguns compiladores, também pode retornar um erro. O ponteiro de destino no caso acima é inválido.

• A função memcpy() também não realiza a validação do buffer de origem.

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

Saída:

A saída, neste caso, também é semelhante à do caso acima, onde o destino não foi especificado. A única diferença aqui é que não retornaria nenhum erro de compilação. Ele apenas mostrará um comportamento indefinido, pois o ponteiro de origem não está apontando para nenhum local definido.

• As funções memcpy() funcionam no nível de bytes dos dados. Portanto o valor de n deve estar sempre em bytes para os resultados desejados.
• Na sintaxe da função memcpy(), os ponteiros são declarados void * para o bloco de memória de origem e de destino, o que significa que eles podem ser usados ​​para apontar para qualquer tipo de dado.

Vejamos alguns exemplos de implementação da função memcpy() para diferentes tipos de dados.

Implementando a função memcpy() com dados do 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; } 

Saída:

Aqui inicializamos dois arrays de tamanho 30. O sourcearr[] contém os dados a serem copiados para o destarr. Usamos a função memcpy() para armazenar os dados em destarr[].

Implementando a função memcpy(0 com dados do tipo inteiro

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

Saída:

No código acima, definimos a estrutura. Usamos a função memcpy() duas vezes. Na primeira vez que o usamos para copiar a string em prsn1, na segunda vez usamos para copiar os dados de prsn1 para prsn2.

Defina sua função memcpy() em linguagem de programação C

Implementar a função memcpy() na linguagem de programação C é comparativamente fácil. A lógica por trás da função memcpy() é bastante simples. Para implementar a função memcpy(), você deve converter o endereço de origem e o endereço de destino para char*(1 byte). Depois que a conversão de tipo for realizada, copie agora o conteúdo do array de origem para o endereço de destino. Temos que compartilhar os dados byte por byte. Repita esta etapa até concluir n unidades, onde n são os bytes especificados dos dados a serem copiados.

Vamos codificar nossa própria função memcpy():

Nota: A função abaixo funciona de forma semelhante à função memcpy() real, mas muitos casos ainda não são contabilizados nesta função definida pelo usuário. Usando sua função memcpy(), você pode decidir condições específicas a serem incluídas na função. Mas se as condições não forem especificadas, é preferível usar a função memcpy() definida na função da 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; } 

Vamos escrever um código de driver para verificar se o código acima está funcionando corretamente.

Código do driver para testar a função MemCpy()

No código abaixo usaremos arr1 para copiar os dados para arr2 usando a função MemCpy().

java lê arquivo linha por linha

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

Saída: