TechCodeview

Funktionen memcpy() kallas också funktionen Kopiera minnesblock. Den används för att göra en kopia av ett specificerat teckenintervall. Funktionen kan bara kopiera objekten från ett minnesblock till ett annat minnesblock om de båda inte överlappar varandra vid något tillfälle.

Syntax

Syntaxen för memcpy()-funktionen i C-språket är följande:

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

Funktionen memcpy() kopierar det n specificerade tecknet från källmatrisen eller platsen. I det här fallet är det arr1 till destinationsplatsen som är arr2. Både arr1 och arr2 är pekarna som pekar på källan respektive destinationsplatsen.

kat timpf syster

Parameter eller argument som skickas i memcpy()

arr1:det är den första parametern i funktionen som specificerar platsen för källminnesblocket. Den representerar arrayen som kommer att kopieras till destinationen.arr2:Den andra parametern i funktionen anger platsen för destinationsminnesblocket. Det representerar arrayen dit minnesblocket kommer att kopieras.n:Den anger antalet tecken som kopieras från källa till destination.

Lämna tillbaka

Den returnerar en pekare som är arr1.

Header-fil

Eftersom memcpy()-funktionen är definierad i rubrikfilen string.h, är det nödvändigt att inkludera den i koden för att implementera funktionen.

 #include 

Låt oss se hur man implementerar 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; } 

Obs: Det är nödvändigt att ställa in det sista indexet som null i den kopierade arrayen eftersom funktionen bara kopierar data och inte initialiserar själva minnet. Strängen förväntar sig ett nullvärde för att avsluta strängen.

Viktiga fakta som måste redovisas innan du implementerar memcpy() i C-programmering:

• Funktionen memcpy() deklareras i rubrikfilen string.h. Så programmeraren måste se till att inkludera filen i koden.
• Storleken på bufferten i vilken innehållet ska kopieras måste vara större än antalet byte som ska kopieras in i bufferten.
• Det fungerar inte när objekten överlappar varandra. Beteendet är odefinierat om vi försöker utföra funktionen på de objekt som överlappar varandra.
• Det är nödvändigt att lägga till ett nolltecken när du använder strängarna eftersom det inte letar efter de avslutande nolltecknen i strängarna.
• Funktionens beteende kommer inte att definieras om funktionen kommer åt bufferten utöver dess storlek. Det är bättre att kontrollera buffertstorleken med funktionen sizeof() .
• Det säkerställer inte att destinationsminnesblocket är giltigt i systemets minne eller inte.

 #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:

Kodens beteende är inte definierat eftersom den nya pekaren inte pekar på någon giltig plats. Därför kommer programmet inte att fungera korrekt. I vissa kompilatorer kan det också returnera ett fel. Destinationspekaren i ovanstående fall är ogiltig.

• Funktionen memcpy() utför inte heller valideringen av källbufferten.

 #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:

java kärna java

Utdata, i det här fallet, liknar också den i ovanstående fall, där destinationen inte angavs. Den enda skillnaden här är att det inte skulle returnera något kompileringsfel. Det kommer bara att visa odefinierat beteende eftersom källpekaren inte pekar på någon definierad plats.

• Funktionerna memcpy() fungerar på databytenivån. Därför bör värdet på n alltid vara i byte för önskat resultat.
• I syntaxen för funktionen memcpy() deklareras pekarna ogiltiga * för både käll- och destinationsminnesblocket, vilket betyder att de kan användas för att peka mot vilken typ av data som helst.

Låt oss se några exempel som implementerar memcpy()-funktionen för olika datatyper av data.

Implementering av memcpy()-funktionen med data av char-typ

 #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:

Här har vi initierat två arrayer av storlek 30. sourcearr[] innehåller data som ska kopieras till destarr. Vi använde funktionen memcpy() för att lagra data i destarr[].

Implementering av memcpy(0-funktion med heltalstypdata

 #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 ovanstående kod har vi definierat strukturen. Vi har använt memcpy()-funktionen två gånger. Första gången vi använde den för att kopiera strängen till prsn1, använde vi den andra gången för att kopiera data från prsn1 till prsn2.

Definiera din memcpy() funktion i programmeringsspråket C

Att implementera memcpy()-funktionen i programmeringsspråket C är jämförelsevis lätt. Logiken är ganska enkel bakom memcpy()-funktionen. För att implementera memcpy()-funktionen måste du skriva in källadressen och destinationsadressen till char*(1 byte). När typcastingen är utförd kopierar du nu innehållet från källarrayen till destinationsadressen. Vi måste dela data byte för byte. Upprepa detta steg tills du har slutfört n enheter, där n är de specificerade byten av data som ska kopieras.

Låt oss koda vår egen memcpy() funktion:

Obs: Funktionen nedan fungerar på samma sätt som den faktiska memcpy()-funktionen, men många fall tas fortfarande inte med i denna användardefinierade funktion. Med din memcpy()-funktion kan du bestämma specifika villkor som ska inkluderas i funktionen. Men om villkoren inte är specificerade är det att föredra att använda funktionen memcpy() definierad 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; } 

Låt oss skriva en förarkod för att kontrollera att ovanstående kod fungerar korrekt på inte.

Drivrutinskod för att testa MemCpy()-funktionen

I koden nedan kommer vi att använda arr1 för att kopiera data till arr2 genom att använda MemCpy()-funktionen.

knn

 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: