Funkciju memcpy () sauc arī par funkciju Copy Memory Block. To izmanto, lai izveidotu noteikta rakstzīmju diapazona kopiju. Funkcija var kopēt objektus no viena atmiņas bloka uz citu atmiņas bloku tikai tad, ja tie abi nevienā vietā nepārklājas.

Sintakse

Funkcijas memcpy () sintakse C valodā ir šāda:

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

Funkcija memcpy() kopēs norādīto rakstzīmi n no avota masīva vai atrašanās vietas. Šajā gadījumā arr1 uz galamērķa vietu ir arr2. Gan arr1, gan arr2 ir norādes, kas norāda attiecīgi uz avota un galamērķa atrašanās vietu.

Parametrs vai argumenti, kas nodoti memcpy()

arr1:tas ir pirmais parametrs funkcijā, kas norāda avota atmiņas bloka atrašanās vietu. Tas apzīmē masīvu, kas tiks kopēts uz galamērķi.arr2:Otrais funkcijas parametrs norāda galamērķa atmiņas bloka atrašanās vietu. Tas apzīmē masīvu, kurā tiks kopēts atmiņas bloks.n:Tas norāda no avota uz galamērķi kopēto rakstzīmju skaitu.

Atgriezties

Tas atgriež rādītāju, kas ir arr1.

Galvenes fails

Tā kā funkcija memcpy() ir definēta galvenes failā string.h, tā ir jāiekļauj kodā, lai ieviestu funkciju.

 #include 

Ļaujiet mums redzēt, kā ieviest memcpy () funkciju programmā 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; } 

Piezīme: Kopētajā masīvā pēdējais indekss ir jāiestata kā null, jo funkcija tikai kopē datus un neinicializē pašu atmiņu. Virkne sagaida nulles vērtību, lai pārtrauktu virkni.

Svarīgi fakti, kas jāņem vērā pirms memcpy () ieviešanas programmā C:

• Funkcija memcpy() ir deklarēta galvenes failā string.h. Tāpēc programmētājam ir jānodrošina faila iekļaušana kodā.
• Bufera lielumam, kurā saturs tiks kopēts, ir jābūt lielākam par buferī kopējamo baitu skaitu.
• Tas nedarbojas, ja objekti pārklājas. Uzvedība nav definēta, ja mēs cenšamies veikt funkciju objektiem, kas pārklājas.
• Lietojot virknes, ir jāpievieno nulles rakstzīme, jo tā nepārbauda, ​​vai virknēs nav beigu nulles rakstzīmes.
• Funkcijas darbība netiks definēta, ja funkcija piekļūs buferim, kas pārsniedz tā lielumu. Labāk ir pārbaudīt bufera lielumu, izmantojot funkciju sizeof().
• Tas nenodrošina, vai galamērķa atmiņas bloks ir derīgs sistēmas atmiņā vai nē.

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

Izvade:

Koda darbība nav definēta, jo jaunais rādītājs nenorāda uz nevienu derīgu vietu. Tādējādi programma nedarbosies pareizi. Dažos kompilatoros tas var arī atgriezt kļūdu. Iepriekš minētajā gadījumā galamērķa rādītājs nav derīgs.

• Funkcija memcpy () arī neveic avota bufera validāciju.

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

Izvade:

Izvade arī šajā gadījumā ir līdzīga tai iepriekš minētajā gadījumā, kad galamērķis nebija norādīts. Vienīgā atšķirība šeit ir tāda, ka tas neatgriezīs kompilācijas kļūdu. Tas tikai parādīs nedefinētu darbību, jo avota rādītājs nenorāda uz noteiktu vietu.

• Funkcijas memcpy () darbojas datu baitu līmenī. Tāpēc, lai iegūtu vēlamos rezultātus, n vērtībai vienmēr jābūt baitos.
• Funkcijas memcpy() sintaksē norādes tiek pasludinātas par spēkā neesošām * gan avota, gan mērķa atmiņas blokam, kas nozīmē, ka tās var izmantot, lai norādītu uz jebkura veida datiem.

Apskatīsim dažus piemērus, kas ievieš funkciju memcpy () dažādiem datu tipiem.

bash cilpai no 1. līdz 10

Funkcijas memcpy() ieviešana ar char tipa datiem

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

Izvade:

Šeit mēs esam inicializējuši divus masīvus ar izmēru 30. sourcearr[] satur datus, kas jākopē destarr. Mēs izmantojām funkciju memcpy (), lai saglabātu datus destarr[].

Funkcijas memcpy(0) ieviešana ar vesela skaitļa tipa datiem

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

Izvade:

Iepriekš minētajā kodā mēs esam definējuši struktūru. Mēs esam izmantojuši funkciju memcpy () divas reizes. Pirmo reizi, kad mēs to izmantojām, lai kopētu virkni uz prsn1, mēs to izmantojām otro reizi, lai kopētu datus no prsn1 uz prsn2.

Definējiet savu memcpy() funkciju C programmēšanas valodā

Funkcijas memcpy () ieviešana programmēšanas valodā C ir salīdzinoši vienkārša. Funkcijas memcpy () loģika ir diezgan vienkārša. Lai ieviestu funkciju memcpy(), jums jāievada avota adrese un galamērķa adrese uz char* (1 baits). Kad ir veikta tipa apraide, tagad kopējiet saturu no avota masīva uz mērķa adresi. Mums ir jādalās ar datiem pa baitam. Atkārtojiet šo darbību, līdz esat pabeidzis n vienības, kur n ir norādītie kopējamo datu baiti.

Kodēsim savu memcpy() funkciju:

Piezīme. Tālāk norādītā funkcija darbojas līdzīgi faktiskajai funkcijai memcpy(), taču daudzi gadījumi joprojām nav ņemti vērā šajā lietotāja definētajā funkcijā. Izmantojot funkciju memcpy(), varat izlemt, kādi nosacījumi jāiekļauj funkcijā. Bet, ja nosacījumi nav norādīti, ieteicams izmantot bibliotēkas funkcijā definēto funkciju memcpy ().

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

Uzrakstīsim draivera kodu, lai pārbaudītu, vai iepriekš minētais kods nedarbojas pareizi.

Draivera kods, lai pārbaudītu funkciju MemCpy()

Tālāk esošajā kodā mēs izmantosim arr1, lai kopētu datus arr2, izmantojot funkciju 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; } 

Izvade: