Funkce memcpy() se také nazývá funkce Kopírovat paměťový blok. Používá se k vytvoření kopie zadaného rozsahu znaků. Funkce je schopna zkopírovat objekty z jednoho paměťového bloku do jiného paměťového bloku pouze tehdy, pokud se oba v žádném bodě nepřekrývají.
Syntax
Syntaxe funkce memcpy() v jazyce C je následující:
void *memcpy(void *arr1, const void *arr2, size_t n);
Funkce memcpy() zkopíruje zadaný znak n ze zdrojového pole nebo umístění. V tomto případě je to arr1 do cílového umístění, které je arr2. Jak arr1, tak arr2 jsou ukazatele, které ukazují na zdrojové a cílové umístění.
Parametr nebo argumenty předané v memcpy()
Vrátit se
Vrací ukazatel, kterým je arr1.
Soubor záhlaví
Protože funkce memcpy() je definována v hlavičkovém souboru string.h, je nutné ji zahrnout do kódu, aby byla funkce implementována.
středové tlačítko css
#include
Podívejme se, jak implementovat funkci memcpy() v programu 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; } Poznámka: V zkopírovaném poli je nutné nastavit poslední index jako null, protože funkce pouze zkopíruje data a neinicializuje samotnou paměť. Řetězec očekává nulovou hodnotu, která řetězec ukončí.
Důležitá fakta, která je třeba vzít v úvahu před implementací memcpy() v programování C:
- Funkce memcpy() je deklarována v záhlaví souboru string.h. Programátor tedy musí zajistit, aby soubor zahrnul do kódu.
- Velikost vyrovnávací paměti, do které se má obsah zkopírovat, musí být větší než počet bajtů, které se mají zkopírovat do vyrovnávací paměti.
- Nefunguje, když se objekty překrývají. Chování je nedefinované, pokud se pokusíme provést funkci na objektech, které se překrývají.
- Při použití řetězců je nutné přidat znak null, protože nekontroluje koncové znaky null v řetězcích.
- Chování funkce nebude definováno, pokud funkce bude přistupovat k vyrovnávací paměti přesahující její velikost. Je lepší zkontrolovat velikost vyrovnávací paměti pomocí funkce sizeof().
- Nezajišťuje, zda je cílový paměťový blok platný v paměti systému nebo ne.
#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; } Výstup:
Chování kódu není definováno, protože nový ukazatel neukazuje na žádné platné umístění. Program proto nebude správně fungovat. V některých kompilátorech může také vrátit chybu. Cílový ukazatel ve výše uvedeném případě je neplatný.
- Funkce memcpy() také neprovádí ověření zdrojové vyrovnávací paměti.
#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; } Výstup:
Výstup je v tomto případě také podobný jako ve výše uvedeném případě, kde nebylo určeno místo určení. Jediný rozdíl je v tom, že by to nevrátilo žádnou chybu kompilace. Ukáže pouze nedefinované chování, protože zdrojový ukazatel neukazuje na žádné definované místo.
- Funkce memcpy() pracují na úrovni bajtů dat. Proto by hodnota n měla být vždy v bajtech pro požadované výsledky.
- V syntaxi funkce memcpy() jsou ukazatele deklarovány jako void * pro zdrojový i cílový blok paměti, což znamená, že je lze použít k ukazování na jakýkoli typ dat.
Podívejme se na některé příklady implementace funkce memcpy() pro různé datové typy.
java obsahuje podřetězec
Implementace funkce memcpy() s daty typu 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; } Výstup:
Zde jsme inicializovali dvě pole o velikosti 30. Sourcearr[] obsahuje data, která mají být zkopírována do destarr. K uložení dat do destarr[] jsme použili funkci memcpy().
Implementace funkce memcpy(0 s celočíselnými daty
#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
'); 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[]='Ashwin'; //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 ( &prsn2, &prsn1, sizeof(prsn1) ); //print the stored data //display the value stored after copying the data //from prsn1 to prsn2 printf ('person2: %s, %d
', 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) && (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) && (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; } </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++){> Výstup:
Ve výše uvedeném kódu jsme definovali strukturu. Funkci memcpy() jsme použili dvakrát. Poprvé jsme jej použili ke zkopírování řetězce do prsn1, podruhé jsme jej použili ke zkopírování dat z prsn1 do prsn2.
Definujte svou funkci memcpy() v programovacím jazyce C
Implementace funkce memcpy() v programovacím jazyce C je poměrně snadná. Logika funkce memcpy() je poměrně jednoduchá. Chcete-li implementovat funkci memcpy(), musíte zdrojovou adresu a cílovou adresu přetypovat na char*(1 byte). Jakmile je typové obsazení provedeno, zkopírujte nyní obsah ze zdrojového pole na cílovou adresu. Musíme sdílet data byte po byte. Tento krok opakujte, dokud nedokončíte n jednotek, kde n jsou zadané bajty dat ke kopírování.
Pojďme si nakódovat vlastní funkci memcpy():
Poznámka: Níže uvedená funkce funguje podobně jako skutečná funkce memcpy(), ale mnoho případů stále není zohledněno v této uživatelsky definované funkci. Pomocí funkce memcpy() můžete rozhodnout o konkrétních podmínkách, které budou zahrnuty do funkce. Pokud však podmínky nejsou specifikovány, je výhodné použít funkci memcpy() definovanou ve funkci knihovny.
//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; } Pojďme napsat kód ovladače, abychom zkontrolovali, že výše uvedený kód funguje správně na not.
Kód ovladače pro testování funkce MemCpy().
V níže uvedeném kódu použijeme arr1 ke zkopírování dat do arr2 pomocí funkce MemCpy().
bash pro smyčku
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; } Výstup:
