La funzione memcpy() è anche chiamata funzione Copia blocco di memoria. Viene utilizzato per creare una copia di un intervallo di caratteri specificato. La funzione è in grado di copiare gli oggetti da un blocco di memoria a un altro blocco di memoria solo se entrambi non si sovrappongono in nessun punto.
Sintassi
La sintassi per la funzione memcpy() nel linguaggio C è la seguente:
void *memcpy(void *arr1, const void *arr2, size_t n);
La funzione memcpy() copierà il carattere n specificato dall'array o dalla posizione di origine. In questo caso, è arr1 la posizione di destinazione che è arr2. Sia arr1 che arr2 sono i puntatori che puntano rispettivamente alla posizione di origine e di destinazione.
Parametro o argomenti passati in memcpy()
Ritorno
Restituisce un puntatore che è arr1.
File di intestazione
Poiché la funzione memcpy() è definita nel file di intestazione string.h, è necessario includerla nel codice per implementare la funzione.
#include
Vediamo come implementare la funzione memcpy() nel programma 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: è necessario impostare l'ultimo indice come null nell'array copiato poiché la funzione copia solo i dati e non inizializza la memoria stessa. La stringa prevede un valore nullo per terminare la stringa.
Fatti importanti da tenere in considerazione prima di implementare memcpy() nella programmazione C:
- La funzione memcpy() è dichiarata nel file di intestazione string.h. Quindi il programmatore deve assicurarsi di includere il file nel codice.
- La dimensione del buffer in cui copiare il contenuto deve essere maggiore del numero di byte da copiare nel buffer.
- Non funziona quando gli oggetti si sovrappongono. Il comportamento è indefinito se proviamo ad eseguire la funzione sugli oggetti che si sovrappongono.
- È necessario aggiungere un carattere null quando si utilizzano le stringhe poiché non controlla i caratteri null finali nelle stringhe.
- Il comportamento della funzione non verrà definito se la funzione accederà al buffer oltre la sua dimensione. È meglio controllare la dimensione del buffer utilizzando la funzione sizeof().
- Non garantisce che il blocco di memoria di destinazione sia valido nella memoria del sistema o meno.
#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; } Produzione:
semplice programma Java
Il comportamento del codice non è definito perché il nuovo puntatore non punta ad alcuna posizione valida. Pertanto, il programma non funzionerà correttamente. In alcuni compilatori potrebbe anche restituire un errore. Il puntatore di destinazione nel caso precedente non è valido.
- Inoltre, la funzione memcpy() non esegue la convalida del buffer di origine.
#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; } Produzione:
L'output, anche in questo caso, è simile a quello del caso precedente, dove non era specificata la destinazione. L'unica differenza qui è che non restituirebbe alcun errore di compilazione. Mostrerà semplicemente un comportamento indefinito poiché il puntatore sorgente non punta a nessuna posizione definita.
- Le funzioni memcpy() lavorano a livello di byte dei dati. Pertanto il valore di n dovrebbe essere sempre in byte per i risultati desiderati.
- Nella sintassi della funzione memcpy(), i puntatori sono dichiarati void * sia per il blocco di memoria sorgente che per quello di destinazione, il che significa che possono essere utilizzati per puntare verso qualsiasi tipo di dati.
Vediamo alcuni esempi di implementazione della funzione memcpy() per diversi tipi di dati.
Implementazione della funzione memcpy() con dati di 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; } Produzione:
Qui abbiamo inizializzato due array di dimensione 30. sourcearr[] contiene i dati da copiare in destarr. Abbiamo utilizzato la funzione memcpy() per memorizzare i dati in destarr[].
Implementazione della funzione memcpy(0 con dati di tipo intero
#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++){> Produzione:
Nel codice precedente, abbiamo definito la struttura. Abbiamo utilizzato la funzione memcpy() due volte. La prima volta che l'abbiamo usato per copiare la stringa in prsn1, lo abbiamo usato la seconda volta per copiare i dati da prsn1 a prsn2.
Definisci la tua funzione memcpy() nel linguaggio di programmazione C
Implementare la funzione memcpy() nel linguaggio di programmazione C è relativamente semplice. La logica dietro la funzione memcpy() è abbastanza semplice. Per implementare la funzione memcpy(), è necessario digitare l'indirizzo di origine e l'indirizzo di destinazione in char*(1 byte). Una volta eseguito il typecasting, ora copia il contenuto dall'array di origine all'indirizzo di destinazione. Dobbiamo condividere i dati byte per byte. Ripetere questo passaggio finché non vengono completate n unità, dove n sono i byte specificati dei dati da copiare.
Codifichiamo la nostra funzione memcpy():
Nota: la funzione seguente funziona in modo simile alla funzione memcpy() effettiva, ma molti casi non vengono ancora presi in considerazione in questa funzione definita dall'utente. Utilizzando la funzione memcpy(), puoi decidere condizioni specifiche da includere nella funzione. Ma se le condizioni non sono specificate, è preferibile utilizzare la funzione memcpy() definita nella funzione di libreria.
//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; } Scriviamo un codice driver per verificare che il codice precedente funzioni correttamente in caso contrario.
attraversamento dell'albero in ordine
Codice driver per testare la funzione MemCpy()
Nel codice seguente utilizzeremo arr1 per copiare i dati in arr2 utilizzando la funzione 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; } Produzione:
