Die Funktion memcpy() wird auch als Funktion „Speicherblock kopieren“ bezeichnet. Es wird verwendet, um eine Kopie eines bestimmten Zeichenbereichs zu erstellen. Die Funktion ist nur dann in der Lage, die Objekte von einem Speicherblock in einen anderen Speicherblock zu kopieren, wenn sich beide an keiner Stelle überlappen.
Syntax
Die Syntax für die Funktion memcpy() in der Sprache C lautet wie folgt:
void *memcpy(void *arr1, const void *arr2, size_t n);
Die Funktion memcpy() kopiert die n angegebenen Zeichen aus dem Quellarray oder Speicherort. In diesem Fall ist es arr1 zum Zielort, der arr2 ist. Sowohl arr1 als auch arr2 sind die Zeiger, die auf den Quell- bzw. Zielort verweisen.
In memcpy() übergebene Parameter oder Argumente
Zurückkehren
Es gibt einen Zeiger zurück, der arr1 ist.
Header-Datei
Da die Funktion memcpy() in der Header-Datei string.h definiert ist, ist es notwendig, sie in den Code aufzunehmen, um die Funktion zu implementieren.
#include
Sehen wir uns an, wie die Funktion memcpy() in einem C-Programm implementiert wird.
//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; } Hinweis: Es ist notwendig, den letzten Index im kopierten Array auf Null zu setzen, da die Funktion nur die Daten kopiert und den Speicher selbst nicht initialisiert. Die Zeichenfolge erwartet einen Nullwert, um die Zeichenfolge zu beenden.
Wichtige Fakten, die vor der Implementierung von memcpy() in der C-Programmierung berücksichtigt werden müssen:
- Die Funktion memcpy() wird in der Header-Datei string.h deklariert. Daher muss der Programmierer sicherstellen, dass die Datei in den Code einbezogen wird.
- Die Größe des Puffers, in den der Inhalt kopiert werden soll, muss größer sein als die Anzahl der Bytes, die in den Puffer kopiert werden sollen.
- Es funktioniert nicht, wenn sich die Objekte überlappen. Das Verhalten ist undefiniert, wenn wir versuchen, die Funktion für die überlappenden Objekte auszuführen.
- Bei der Verwendung der Zeichenfolgen muss ein Nullzeichen hinzugefügt werden, da nicht nach abschließenden Nullzeichen in den Zeichenfolgen gesucht wird.
- Das Funktionsverhalten wird nicht definiert, wenn die Funktion über ihre Größe hinaus auf den Puffer zugreift. Es ist besser, die Puffergröße mit der Funktion sizeof() zu überprüfen.
- Es stellt nicht sicher, dass der Zielspeicherblock im Speicher des Systems gültig ist oder nicht.
#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; } Ausgabe:
Das Verhalten des Codes ist nicht definiert, da der neue Zeiger nicht auf eine gültige Position zeigt. Daher wird das Programm nicht ordnungsgemäß funktionieren. Bei einigen Compilern kann es auch zu einem Fehler kommen. Der Zielzeiger ist im obigen Fall ungültig.
- Die Funktion memcpy() führt auch keine Validierung des Quellpuffers durch.
#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; } Ausgabe:
Die Ausgabe ähnelt in diesem Fall auch der im obigen Fall, bei dem das Ziel nicht angegeben wurde. Der einzige Unterschied besteht darin, dass kein Kompilierungsfehler zurückgegeben wird. Es zeigt lediglich undefiniertes Verhalten, da der Quellzeiger nicht auf einen definierten Ort zeigt.
- Die memcpy()-Funktionen arbeiten auf der Byteebene der Daten. Daher sollte der Wert von n für die gewünschten Ergebnisse immer in Bytes angegeben werden.
- In der Syntax für die Funktion memcpy() werden die Zeiger sowohl für den Quell- als auch den Zielspeicherblock als void * deklariert, was bedeutet, dass sie verwendet werden können, um auf jede Art von Daten zu zeigen.
Sehen wir uns einige Beispiele an, in denen die Funktion memcpy() für verschiedene Datentypen implementiert wird.
Implementieren der Funktion memcpy() mit Daten vom Typ 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; } Ausgabe:
Hier haben wir zwei Arrays der Größe 30 initialisiert. Das sourcearr[] enthält die Daten, die in das destarr kopiert werden sollen. Wir haben die Funktion memcpy() verwendet, um die Daten in destarr[] zu speichern.
Implementierung der memcpy(0-Funktion mit Daten vom Typ Integer
#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++){> Ausgabe:
Im obigen Code haben wir die Struktur definiert. Wir haben die Funktion memcpy() zweimal verwendet. Beim ersten Mal haben wir es verwendet, um die Zeichenfolge in prsn1 zu kopieren, und beim zweiten Mal haben wir es verwendet, um die Daten von prsn1 nach prsn2 zu kopieren.
Definieren Sie Ihre memcpy()-Funktion in der Programmiersprache C
Die Implementierung der memcpy()-Funktion in der Programmiersprache C ist vergleichsweise einfach. Die Logik hinter der Funktion memcpy() ist recht einfach. Um die memcpy()-Funktion zu implementieren, müssen Sie die Quelladresse und die Zieladresse in char*(1 Byte) umwandeln. Nachdem die Typumwandlung durchgeführt wurde, kopieren Sie nun den Inhalt vom Quellarray an die Zieladresse. Wir müssen die Daten Byte für Byte teilen. Wiederholen Sie diesen Schritt, bis Sie n Einheiten abgeschlossen haben, wobei n die angegebenen Bytes der zu kopierenden Daten sind.
Lassen Sie uns unsere eigene memcpy()-Funktion codieren:
Hinweis: Die folgende Funktion funktioniert ähnlich wie die eigentliche memcpy()-Funktion, viele Fälle werden jedoch in dieser benutzerdefinierten Funktion noch nicht berücksichtigt. Mit Ihrer memcpy()-Funktion können Sie bestimmte Bedingungen festlegen, die in die Funktion einbezogen werden sollen. Wenn die Bedingungen jedoch nicht angegeben sind, wird vorzugsweise die in der Bibliotheksfunktion definierte Funktion memcpy() verwendet.
//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; } Lassen Sie uns einen Treibercode schreiben, um zu überprüfen, ob der obige Code ordnungsgemäß funktioniert.
Treibercode zum Testen der MemCpy()-Funktion
Im folgenden Code verwenden wir arr1, um die Daten mithilfe der Funktion MemCpy() in arr2 zu kopieren.
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; } Ausgabe:
