logo

TechCodeview

memcpy() C-ben

A memcpy() függvényt Memóriablokk másolása függvénynek is nevezik. Egy meghatározott karaktertartomány másolatának készítésére szolgál. A funkció csak akkor tudja átmásolni az objektumokat egyik memóriablokkból egy másik memóriablokkba, ha egyik helyen sem fedi egymást.

Szintaxis

A memcpy() függvény szintaxisa C nyelvben a következő:

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

A memcpy() függvény kimásolja az n megadott karaktert a forrástömbből vagy helyről. Ebben az esetben az arr1 a célhelyre az arr2. Az arr1 és az arr2 is azok a mutatók, amelyek a forrás- és a célhelyre mutatnak.

A memcpy()-ben átadott paraméter vagy argumentumok

    arr1:ez az első paraméter a függvényben, amely megadja a forrás memóriablokk helyét. Azt a tömböt jelöli, amely a célhelyre lesz másolva.arr2:A függvény második paramétere határozza meg a cél memóriablokk helyét. Azt a tömböt jelöli, ahová a memóriablokkot másolni fogják.n:Meghatározza a forrásból a célhelyre másolt karakterek számát.

Visszatérés

Egy mutatót ad vissza, ami az arr1.

Fejléc fájl

Mivel a memcpy() függvény a string.h fejlécfájlban van definiálva, a függvény megvalósításához szükséges a kódban szerepeltetni.

 #include

Nézzük meg, hogyan valósítsuk meg a memcpy() függvényt a C programban.

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

Megjegyzés: Az utolsó indexet nullára kell állítani a másolt tömbben, mivel a függvény csak az adatokat másolja, magát a memóriát nem inicializálja. A karakterlánc null értéket vár a karakterlánc befejezéséhez.

Fontos tények, amelyeket figyelembe kell venni a memcpy() végrehajtása előtt a C programozásban:

  • A memcpy() függvény a string.h fejlécfájlban van deklarálva. Tehát a programozónak gondoskodnia kell arról, hogy a fájl szerepeljen a kódban.
  • A puffer méretének, amelyben a tartalmat másolni kell, nagyobbnak kell lennie, mint a pufferbe másolandó bájtok száma.
  • Nem működik, ha az objektumok átfedik egymást. A viselkedés definiálatlan, ha a funkciót az átfedő objektumokon próbáljuk végrehajtani.
  • A karakterláncok használatakor egy null karaktert kell hozzáadni, mivel ez nem ellenőrzi, hogy vannak-e befejező null karakterek a karakterláncokban.
  • A függvény viselkedése nem lesz definiálva, ha a függvény a méreten túlmenően hozzáfér a pufferhez. A puffer méretét jobb a sizeof() függvénnyel ellenőrizni.
  • Nem biztosítja, hogy a cél memóriablokk érvényes legyen a rendszer memóriájában vagy sem.
 #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; }

Kimenet:

memcpy() C-ben

A kód viselkedése nincs meghatározva, mert az új mutató nem mutat egyetlen érvényes helyre sem. Emiatt a program nem fog megfelelően működni. Egyes fordítóknál ez is hibát jelezhet. A célmutató a fenti esetben érvénytelen.

  • A memcpy() függvény szintén nem végzi el a forráspuffer érvényesítését.
 #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; }

Kimenet:

memcpy() C-ben

A kimenet ebben az esetben is hasonló a fenti esethez, ahol a célállomás nem volt megadva. Az egyetlen különbség itt az, hogy nem ad vissza fordítási hibát. Csak meghatározatlan viselkedést fog mutatni, mivel a forrásmutató nem mutat semmilyen meghatározott helyre.

  • A memcpy() függvények az adatok bájt szintjén működnek. Ezért az n értékének mindig bájtban kell lennie a kívánt eredmény eléréséhez.
  • A memcpy() függvény szintaxisában a mutatók érvénytelennek vannak nyilvánítva * mind a forrás, mind a cél memóriablokk esetében, ami azt jelenti, hogy bármilyen típusú adatra mutathatnak.

Lássunk néhány példát a memcpy() függvény megvalósítására különböző adattípusokhoz.

A memcpy() függvény megvalósítása char típusú adatokkal

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

Kimenet:

memcpy() C-ben

Itt két 30-as méretű tömböt inicializáltunk. A sourcearr[] tartalmazza a destarr-ba másolandó adatokat. A memcpy() függvényt használtuk az adatok tárolására a destarr[]-ban.

A memcpy(0 függvény megvalósítása egész típusú adatokkal

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

Kimenet:

memcpy() C-ben

A fenti kódban definiáltuk a szerkezetet. Kétszer használtuk a memcpy() függvényt. Az első alkalommal, amikor a karakterláncot a prsn1-be másoltuk, másodszor az adatok átmásolására használtuk a prsn1-ből a prsn2-be.

Határozza meg a memcpy() függvényt a C programozási nyelvben

A memcpy() függvény megvalósítása a C programozási nyelvben viszonylag egyszerű. A memcpy() függvény mögött meglehetősen egyszerű a logika. A memcpy() függvény megvalósításához a forráscímet és a célcímet char*(1 bájt) értékre kell begépelnie. A típusküldés végrehajtása után másolja át a tartalmat a forrástömbből a célcímre. Az adatokat bájtonként meg kell osztanunk. Addig ismételje ezt a lépést, amíg el nem végez n egységet, ahol n a másolandó adatok megadott bájtja.

Kódoljuk a saját memcpy() függvényünket:

Megjegyzés: Az alábbi függvény a tényleges memcpy() függvényhez hasonlóan működik, de sok esetet még mindig nem vett figyelembe ez a felhasználó által definiált függvény. A memcpy() függvény segítségével meghatározhatja, hogy a függvénybe bekerüljön bizonyos feltételek. De ha a feltételek nincsenek megadva, akkor célszerű a könyvtárfüggvényben meghatározott memcpy() függvényt használni.

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

Írjunk egy illesztőprogram kódot annak ellenőrzésére, hogy a fenti kód megfelelően működik-e.

Illesztőprogram kód a MemCpy() függvény teszteléséhez

Az alábbi kódban az arr1-et használjuk, hogy az adatokat az arr2-be másoljuk a MemCpy() függvény segítségével.

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

Kimenet:

memcpy() C-ben