Funktionen memcpy() kaldes også Copy Memory Block-funktionen. Det bruges til at lave en kopi af et bestemt antal tegn. Funktionen er kun i stand til at kopiere objekterne fra en hukommelsesblok til en anden hukommelsesblok, hvis de begge ikke overlapper på noget tidspunkt.

Syntaks

Syntaksen for memcpy()-funktionen i C-sprog er som følger:

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

Funktionen memcpy() kopierer det n specificerede tegn fra kildearrayet eller placeringen. I dette tilfælde er det arr1 til destinationsstedet, der er arr2. Både arr1 og arr2 er de pointere, der peger på henholdsvis kilde- og destinationsplaceringen.

Parameter eller argumenter sendt i memcpy()

arr1:det er den første parameter i funktionen, der specificerer placeringen af ​​kildehukommelsesblokken. Det repræsenterer det array, der vil blive kopieret til destinationen.arr2:Den anden parameter i funktionen angiver placeringen af ​​destinationshukommelsesblokken. Det repræsenterer det array, hvor hukommelsesblokken vil blive kopieret.n:Den angiver antallet af tegn, der kopieres fra kilde til destination.

Vend tilbage

Det returnerer en pointer, der er arr1.

Header-fil

Da funktionen memcpy() er defineret i string.h header-filen, er det nødvendigt at inkludere den i koden for at implementere funktionen.

 #include 

Lad os se, hvordan man implementerer memcpy()-funktionen i C-programmet.

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

Bemærk: Det er nødvendigt at sætte det sidste indeks som null i det kopierede array, da funktionen kun kopierer dataene og ikke initialiserer selve hukommelsen. Strengen forventer en nulværdi for at afslutte strengen.

Vigtige fakta, der skal tages højde for før implementering af memcpy() i C-programmering:

• Funktionen memcpy() er erklæret i string.h header-filen. Så programmøren skal sørge for at inkludere filen i koden.
• Størrelsen af ​​den buffer, hvori indholdet skal kopieres, skal være større end antallet af bytes, der skal kopieres ind i bufferen.
• Det virker ikke, når objekterne overlapper hinanden. Adfærden er udefineret, hvis vi forsøger at udføre funktionen på de objekter, der overlapper hinanden.
• Det er nødvendigt at tilføje et nul-tegn, når du bruger strengene, da det ikke tjekker for de afsluttende nul-tegn i strengene.
• Funktionens adfærd vil ikke blive defineret, hvis funktionen vil få adgang til bufferen ud over dens størrelse. Det er bedre at kontrollere bufferstørrelsen ved hjælp af funktionen sizeof().
• Det sikrer ikke, at destinationshukommelsesblokken er gyldig i systemets hukommelse eller ej.

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

Produktion:

binær søgepython

Kodens adfærd er ikke defineret, fordi den nye markør ikke peger på nogen gyldig placering. Derfor vil programmet ikke fungere korrekt. I nogle compilere kan det også returnere en fejl. Destinationsmarkøren i ovenstående tilfælde er ugyldig.

• Funktionen memcpy() udfører heller ikke valideringen af ​​kildebufferen.

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

Produktion:

Outputtet, i dette tilfælde, svarer også til det i ovenstående tilfælde, hvor destinationen ikke var angivet. Den eneste forskel her er, at det ikke ville returnere nogen kompileringsfejl. Det vil bare vise udefineret adfærd, da kildemarkøren ikke peger på nogen defineret placering.

• Funktionerne memcpy() fungerer på dataens byteniveau. Derfor bør værdien af ​​n altid være i bytes for ønskede resultater.
• I syntaksen for memcpy()-funktionen erklæres pointerne ugyldige * for både kilde- og destinationshukommelsesblokken, hvilket betyder, at de kan bruges til at pege mod enhver type data.

Lad os se nogle eksempler på implementering af memcpy()-funktionen for forskellige datatyper.

Implementering af memcpy()-funktionen med data af 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; } 

Produktion:

Her har vi initialiseret to arrays af størrelse 30. sourcearr[] indeholder de data, der skal kopieres ind i destarr. Vi brugte funktionen memcpy() til at gemme dataene i destarr[].

Implementering af memcpy(0-funktion med heltalstypedata

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

Produktion:

I ovenstående kode har vi defineret strukturen. Vi har brugt memcpy()-funktionen to gange. Første gang vi brugte den til at kopiere strengen til prsn1, brugte vi den anden gang til at kopiere data fra prsn1 til prsn2.

Definer din memcpy() funktion i programmeringssproget C

Implementering af memcpy()-funktionen i C-programmeringssproget er forholdsvis let. Logikken er ret enkel bag memcpy()-funktionen. For at implementere memcpy()-funktionen skal du skrive kildeadressen og destinationsadressen til char*(1 byte). Når typecastingen er udført, kopierer du nu indholdet fra kildearrayet til destinationsadressen. Vi er nødt til at dele data byte for byte. Gentag dette trin, indtil du har fuldført n enheder, hvor n er de specificerede bytes af de data, der skal kopieres.

Lad os kode vores egen memcpy() funktion:

Bemærk: Funktionen nedenfor fungerer på samme måde som den faktiske memcpy()-funktion, men mange tilfælde er stadig ikke taget højde for i denne brugerdefinerede funktion. Ved at bruge din memcpy()-funktion kan du bestemme specifikke betingelser, der skal inkluderes i funktionen. Men hvis betingelserne ikke er specificeret, foretrækkes det at bruge funktionen memcpy() defineret i biblioteksfunktionen.

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

Lad os skrive en driverkode for at kontrollere, at ovenstående kode fungerer korrekt på ikke.

instansiering i java

Driverkode til at teste MemCpy() funktion

I koden nedenfor vil vi bruge arr1 til at kopiere dataene ind i arr2 ved at bruge MemCpy()-funktionen.

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

Produktion: