הפונקציה memcpy() נקראת גם הפונקציה Copy Memory Block. הוא משמש ליצירת עותק של טווח מוגדר של תווים. הפונקציה מסוגלת להעתיק את האובייקטים מבלוק זיכרון אחד לבלוק זיכרון אחר אם שניהם אינם חופפים בשום נקודה.

לזרוק ב-java טיפול חריג

תחביר

התחביר עבור הפונקציה memcpy() בשפת C הוא כדלקמן:

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

הפונקציה memcpy() תעתיק את התו n שצוין ממערך המקור או המיקום. במקרה זה, arr1 למיקום היעד הוא arr2. גם arr1 וגם arr2 הם המצביעים המצביעים על מיקום המקור והיעד, בהתאמה.

פרמטר או ארגומנטים שהועברו ב-memcpy()

arr1:זה הפרמטר הראשון בפונקציה שמציין את המיקום של בלוק זיכרון המקור. הוא מייצג את המערך שיועתק ליעד.arr2:הפרמטר השני בפונקציה מציין את המיקום של בלוק זיכרון היעד. הוא מייצג את המערך שבו יועתק בלוק הזיכרון.n:הוא מציין את מספר התווים שהועתקו ממקור ליעד.

לַחֲזוֹר

זה מחזיר מצביע שהוא arr1.

קובץ הכותרת

מכיוון שהפונקציה memcpy() מוגדרת בקובץ הכותרת string.h, יש צורך לכלול אותה בקוד כדי ליישם את הפונקציה.

 #include 

הבה נראה כיצד ליישם את הפונקציה memcpy() בתוכנית 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; } 

הערה: יש צורך להגדיר את האינדקס האחרון כ-null במערך המועתק מכיוון שהפונקציה מעתיקה רק את הנתונים ואינה מאתחלת את הזיכרון עצמו. המחרוזת מצפה לערך null כדי לסיים את המחרוזת.

עובדות חשובות שיש לתת עליהן את הדעת לפני יישום memcpy() בתכנות C:

• הפונקציה memcpy() מוצהרת בקובץ הכותרת string.h. אז המתכנת צריך להבטיח לכלול את הקובץ בקוד.
• גודל המאגר שבו יש להעתיק את התוכן חייב להיות גדול ממספר הבתים שיש להעתיק למאגר.
• זה לא עובד כאשר האובייקטים חופפים. ההתנהגות אינה מוגדרת אם ננסה לבצע את הפונקציה על האובייקטים החופפים.
• יש צורך להוסיף תו null בעת שימוש במחרוזות מכיוון שהוא אינו בודק את תווי ה-null המסתיימים במחרוזות.
• התנהגות הפונקציה לא תוגדר אם הפונקציה תיגש למאגר מעבר לגודל שלו. עדיף לבדוק את גודל המאגר באמצעות הפונקציה sizeof() .
• זה לא מבטיח שבלוק זיכרון היעד תקף בזיכרון של המערכת או לא.

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

תְפוּקָה:

התנהגות הקוד אינה מוגדרת מכיוון שהמצביע החדש אינו מצביע על מיקום חוקי כלשהו. לפיכך, התוכנית לא תפעל כראוי. בחלק מהמהדרים, הוא עשוי גם להחזיר שגיאה. מצביע היעד במקרה הנ'ל אינו חוקי.

• הפונקציה memcpy() גם לא מבצעת את האימות של מאגר המקור.

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

תְפוּקָה:

הפלט, במקרה זה, דומה גם לזו שבמקרה לעיל, שבו היעד לא צוין. ההבדל היחיד כאן הוא שזה לא יחזיר שום שגיאת קומפילציה. זה פשוט יראה התנהגות לא מוגדרת מכיוון שמצביע המקור אינו מצביע על שום מיקום מוגדר.

• הפונקציות memcpy() פועלות ברמת הבייטים של הנתונים. לכן הערך של n צריך להיות תמיד בבתים לתוצאות רצויות.
• בתחביר של הפונקציה memcpy() המצביעים מוכרזים כ-void * הן עבור בלוק המקור והן עבור בלוק זיכרון היעד, מה שאומר שניתן להשתמש בהם כדי להצביע לעבר כל סוג של נתונים.

הבה נראה כמה דוגמאות ליישום הפונקציה memcpy() עבור סוגי נתונים שונים.

יישום הפונקציה memcpy() עם נתונים מסוג 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; } 

תְפוּקָה:

כאן אתחלנו שני מערכים בגודל 30. ה-sourcearr[] מכיל את הנתונים שיש להעתיק ל-destarr. השתמשנו בפונקציה memcpy() כדי לאחסן את הנתונים ב-destarr[].

יישום פונקציית memcpy(0 עם נתונים מסוג מספר שלם

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

תְפוּקָה:

פקודת chown

בקוד לעיל, הגדרנו את המבנה. השתמשנו בפונקציה memcpy() פעמיים. בפעם הראשונה שהשתמשנו בו כדי להעתיק את המחרוזת ל-prsn1, השתמשנו בו בפעם השנייה כדי להעתיק את הנתונים מה-prsn1 ל-prsn2.

הגדר את הפונקציה memcpy() שלך בשפת תכנות C

יישום הפונקציה memcpy() בשפת התכנות C קל יחסית. ההיגיון די פשוט מאחורי הפונקציה memcpy() . כדי ליישם את הפונקציה memcpy(), עליך להקליד את כתובת המקור ואת כתובת היעד ל-char*(1 byte). לאחר ביצוע ה-typecasting, כעת העתק את התוכן ממערך המקור לכתובת היעד. עלינו לחלוק את הנתונים בייט אחר בייט. חזור על שלב זה עד שתסיים n יחידות, כאשר n הוא הבתים שצוינו של הנתונים שיש להעתיק.

תן לנו לקודד את הפונקציה memcpy() שלנו:

הערה: הפונקציה שלהלן פועלת באופן דומה לפונקציה memcpy() בפועל, אך מקרים רבים עדיין אינם מובאים בחשבון בפונקציה המוגדרת על ידי המשתמש. באמצעות הפונקציה memcpy() שלך, אתה יכול להחליט על תנאים ספציפיים שייכללו בפונקציה. אבל אם התנאים לא מצוינים, עדיף להשתמש בפונקציה 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; } 

תן לנו לכתוב קוד מנהל התקן כדי לבדוק שהקוד שלמעלה פועל כראוי ב-not.

קוד מנהל ההתקן לבדיקת פונקציית MemCpy()

בקוד שלהלן נשתמש ב- arr1 כדי להעתיק את הנתונים ל- arr2 באמצעות הפונקציה 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; } 

תְפוּקָה: