De functie memcpy() wordt ook wel de Copy Memory Block-functie genoemd. Het wordt gebruikt om een kopie te maken van een opgegeven reeks tekens. De functie kan de objecten alleen van het ene geheugenblok naar het andere geheugenblok kopiëren als ze elkaar op geen enkel punt overlappen.
Syntaxis
De syntaxis voor de functie memcpy() in C-taal is als volgt:
void *memcpy(void *arr1, const void *arr2, size_t n);
De functie memcpy() kopieert het opgegeven teken n uit de bronarray of locatie. In dit geval is het arr1 naar de bestemmingslocatie arr2. Zowel arr1 als arr2 zijn de verwijzingen die respectievelijk naar de bron- en bestemmingslocatie verwijzen.
Parameter of argumenten doorgegeven in memcpy()
Opbrengst
Het retourneert een pointer die de arr1 is.
Headerbestand
Omdat de functie memcpy() is gedefinieerd in het headerbestand string.h, is het noodzakelijk om deze in de code op te nemen om de functie te implementeren.
#include
Laten we eens kijken hoe we de functie memcpy() in het C-programma kunnen implementeren.
is gelijk aan methode Java
//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; } Opmerking: Het is noodzakelijk om de laatste index in de gekopieerde array op nul in te stellen, omdat de functie alleen de gegevens kopieert en het geheugen zelf niet initialiseert. De string verwacht dat een nulwaarde de string beëindigt.
Belangrijke feiten waarmee u rekening moet houden voordat u memcpy() in C-programmering implementeert:
- De functie memcpy() wordt gedeclareerd in het headerbestand string.h. De programmeur moet er dus voor zorgen dat het bestand in de code wordt opgenomen.
- De grootte van de buffer waarin de inhoud moet worden gekopieerd, moet groter zijn dan het aantal bytes dat naar de buffer moet worden gekopieerd.
- Het werkt niet als de objecten elkaar overlappen. Het gedrag is ongedefinieerd als we de functie proberen uit te voeren op de objecten die elkaar overlappen.
- Het is noodzakelijk om een null-teken toe te voegen bij het gebruik van de strings, omdat er niet wordt gecontroleerd op de afsluitende nul-tekens in de strings.
- Het functiegedrag wordt niet gedefinieerd als de functie toegang krijgt tot de buffer die groter is dan de omvang ervan. Het is beter om de buffergrootte te controleren met behulp van de functie sizeof().
- Het garandeert niet dat het doelgeheugenblok geldig is in het geheugen van het systeem of niet.
#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; } Uitgang:
Het gedrag van de code is niet gedefinieerd omdat de nieuwe aanwijzer niet naar een geldige locatie verwijst. Het programma zal dus niet goed functioneren. Bij sommige compilers kan het ook een fout opleveren. De bestemmingsaanwijzer in het bovenstaande geval is ongeldig.
- De functie memcpy() voert ook niet de validatie van de bronbuffer uit.
#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; } Uitgang:
De uitvoer is in dit geval ook vergelijkbaar met die in het bovenstaande geval, waarbij de bestemming niet was gespecificeerd. Het enige verschil hier is dat er geen compilatiefout wordt geretourneerd. Het zal alleen ongedefinieerd gedrag vertonen omdat de bronaanwijzer niet naar een gedefinieerde locatie wijst.
- De memcpy()-functies werken op byteniveau van de gegevens. Daarom moet de waarde van n altijd in bytes zijn voor de gewenste resultaten.
- In de syntaxis voor de functie memcpy() worden de verwijzingen ongeldig * verklaard voor zowel het bron- als het doelgeheugenblok, wat betekent dat ze kunnen worden gebruikt om naar elk type gegevens te verwijzen.
Laten we enkele voorbeelden bekijken van de implementatie van de memcpy()-functie voor verschillende gegevenstypen.
Implementatie van de functie memcpy() met gegevens van het char-type
#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; } Uitgang:
Java-arraylijst
Hier hebben we twee arrays van grootte 30 geïnitialiseerd. De sourcearr[] bevat de gegevens die naar de destarr moeten worden gekopieerd. We hebben de functie memcpy() gebruikt om de gegevens in destarr[] op te slaan.
Memcpy(0-functie implementeren met gegevens van het gehele type
#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++){> Uitgang:
In de bovenstaande code hebben we de structuur gedefinieerd. We hebben de functie memcpy() twee keer gebruikt. De eerste keer dat we het gebruikten om de string naar prsn1 te kopiëren, gebruikten we het de tweede keer om de gegevens van prsn1 naar prsn2 te kopiëren.
Definieer uw memcpy()-functie in de programmeertaal C
Het implementeren van de functie memcpy() in de programmeertaal C is relatief eenvoudig. De logica achter de functie memcpy() is vrij eenvoudig. Om de functie memcpy() te implementeren, moet u het bronadres en het bestemmingsadres typeren naar char*(1 byte). Zodra de typecasting is uitgevoerd, kopieert u nu de inhoud van de bronarray naar het bestemmingsadres. We moeten de gegevens byte voor byte delen. Herhaal deze stap totdat u n eenheden hebt voltooid, waarbij n de opgegeven bytes is van de gegevens die moeten worden gekopieerd.
Laten we onze eigen memcpy()-functie coderen:
Opmerking: de onderstaande functie werkt op dezelfde manier als de daadwerkelijke memcpy()-functie, maar met veel gevallen wordt nog steeds geen rekening gehouden in deze door de gebruiker gedefinieerde functie. Met behulp van uw memcpy()-functie kunt u bepalen welke specifieke voorwaarden in de functie moeten worden opgenomen. Maar als de voorwaarden niet zijn gespecificeerd, verdient het de voorkeur om de functie memcpy() te gebruiken die is gedefinieerd in de bibliotheekfunctie.
//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; } Laten we een stuurprogrammacode schrijven om te controleren of de bovenstaande code correct werkt.
Stuurprogrammacode om de MemCpy()-functie te testen
In de onderstaande code gebruiken we arr1 om de gegevens naar arr2 te kopiëren met behulp van de functie MemCpy().
rekha filmactrice
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; } Uitgang:
