Phenquestions
Syntax:
char * strcpy (char * destination_location, const char * source_string);Förstå strcpy ():
Det enda syftet med funktionen strcpy () är att kopiera en sträng från källa till destination. Låt oss nu titta på ovanstående syntax för strcpy () -funktionen. Funktionen strcpy () kan acceptera två parametrar -
- char * destination
- const char * källa
Källan är konstant här för att säkerställa att funktionen strcpy () inte kan ändra källsträngen. Funktionen strcpy () kopierar alla tecken (inklusive NULL-tecknet i slutet av strängen) från källsträngen till destinationen. När kopieringen är klar från källa till destination, returnerar strcpy () -funktionen adressen till destinationen tillbaka till den som ringer.
Den viktiga punkten att lägga märke till här är att funktionen strcpy () inte lägger till källsträngen med målsträngen. Det ersätter snarare målets innehåll med innehållet i källsträngen.
Dessutom utför strcpy () inga kontroller för att säkerställa att målets storlek är mer än källsträngen, det är helt programmerarens ansvar.
Exempel:
Nu kommer vi att se flera exempel för att förstå funktionen strcpy ():
- strcpy () - Normal drift (exempel1.c)
- strcpy () - Fall-1 (exempel2.c)
- strcpy () - Fall-2 (exempel3.c)
- strcpy () - Fall-3 (exempel4.c)
- strcpy () - Användardefinierad version (exempel5.c)
- strcpy () - Användardefinierad version optimerad (exempel 6.c)
strcpy () - Normal drift (exempel1.c):
Detta exempelprogram visar hur man utför en normal strängkopiering med strcpy () -funktionen i C-programmeringsspråket. Observera att målsträngens längd är 30 (char destination_str [30];), vilket är större än längden på källsträngen (längd är 18 inklusive NULL-tecknet) så att destinationen kan rymma alla tecken från källsträng.
#omfatta#omfatta
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [30];
printf ("Innan du ringer till strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
strcpy (destination_str, source_str);
printf ("Efter körning av strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
returnera 0;
strcpy () - Fall-1 (exempel2.c):
Syftet med detta exempelprogram är att tydligt förklara vad som händer när målsträngens längd är mindre än källsträngens längd. I sådana fall kommer destinationsplatsen inte att ha tillräckligt med mellanslag / byte för att rymma alla tecken (inklusive NULL-tecken) från källsträngen. Två saker, bör du alltid komma ihåg:
- Funktionen strcpy () kommer inte att kontrollera om destinationen har tillräckligt med utrymme.
- Detta kan vara farligt i inbäddad programvara eftersom strcpy () kommer att ersätta minnesområdet utanför destinationsgränsen.
Låt oss titta på exempelprogrammet. Vi har deklarerat source_str och initialiserat det till “www.linuxhint.com ”, vilket tar 18 byte i minnet att lagra, inklusive Null-karaktären i slutet av strängen. Sedan har vi förklarat en annan teckenuppsättning i.e. destination_str med storleken endast 5. Så destination_str kan inte innehålla källsträngen med en total storlek på 18 byte.
Men ändå ringer vi till strcpy () -funktionen för att kopiera källsträngen till destinationssträngen. Från nedanstående utdata kan vi se att strcpy () inte klagade alls. I det här fallet börjar strcpy () -funktionen att kopiera tecknet från källsträngen (tills den hittar NULL-tecknet i källsträngen) till destinationsadressen (även om destinationsgränsen överskrider). Det betyder att strcpy () -funktionen inte gör någon gränskontroll för destinationsmatrisen. Så småningom kommer strcpy () -funktionen att skriva över de minnesadresser som inte allokeras till destinationsmatrisen. Det är därför som strcpy () -funktionen slutar skriva över minnesplatserna som kan tilldelas en annan variabel.
I det här exemplet kan vi se från utdata nedan att strcpy () -funktionen skriver över själva källsträngen. Programmerare bör alltid vara försiktiga med sådant beteende.
#omfatta#omfatta
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [5];
printf ("Innan du ringer till strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
strcpy (destination_str, source_str);
printf ("Efter körning av strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
// printf ("Källadress =% u (0x% x) \ n", & source_str [0], & source_str [0]);
// printf ("Destination Address =% u (0x% x) \ n", & destination_str [0], & destination_str [0]);
returnera 0;
strcpy () - Fall-2 (exempel3.c):
Detta program illustrerar situationen när målsträngstorleken är större än källsträngstorleken och målsträngen redan har initierats med något värde. I det här exemplet har vi initierat:
- source_str till “www.linuxhint.com ”[storlek = 17 + 1 = 18]
- destination_str till “I_AM_A_DESTINATION_STRING” [size = 25 + 1 = 26]
Funktionen strcpy () kopierar alla 17 tecken och NULL-tecknet från källsträngen till destinationssträngen. Men det kommer inte att ersätta / ändra de återstående byten (Byte 19 till 26, en baserad) i destinationsmatrisen. Vi har använt för loop för att iterera över destinationsmatrisen och skriva ut hela matrisen för att bevisa att bytes-19 till 26 är oförändrade i destinationsmatrisen. Det är därför vi ser den sista produktionen som:
“Www.linuxhint.com_STRING ”.
#omfatta#omfatta
/ * Detta program illustrerar situationen när:
målsträngstorlek> källsträngstorlek
och vi kör strcpy () -funktionen för att kopiera
källsträng till destination.
Obs! Målsträngstorleken bör alltid
vara större än eller lika med källsträngen.
* /
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [26] = "I_AM_A_DESTINATION_STRING";
printf ("Innan du ringer till strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
strcpy (destination_str, source_str);
printf ("Efter körning av strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
/ * skriv ut destinationssträng med för loop * /
printf ("Skriv ut destinationssträngen char med char: \ n \ n");
printf ("\ tDestination String =");
för (int i = 0; i<25;i++)
printf ("% c", destination_str [i]);
printf ("\ n \ n");
returnera 0;
strcpy () - Fall-3 (exempel4.c):
Vi har betraktat detta program som ett exempel för att visa att vi aldrig ska ringa strcpy () med en sträng bokstavlig som destination. Detta kommer att orsaka odefinierat beteende och så småningom kommer programmet att krascha.
#omfatta#omfatta
int main ()
char source_str [] = "www.linuxhint.com ";
printf ("Innan du ringer till strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
/ * Ring aldrig strcpy () med strängen bokstavlig som destination.
Programmet kommer att krascha.
* /
strcpy ("destination_str", source_str);
printf ("Efter körning av strcpy () -funktionen: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
returnera 0;
strcpy () - Användardefinierad version (exempel5.c):
I detta exempelprogram har vi visat hur man skriver en användardefinierad version av strcpy () -funktionen.
#omfattachar * strcpy_user_defined (char * dest, const char * src);
/ * Användardefinierad version av strcpy () -funktionen * /
char * strcpy_user_defined (char * dest, const char * src)
char * dest_backup = dest;
medan (* src != '\ 0') / * Iterera tills '\ 0' hittas.* /
* dest = * src; / * Kopiera källtecken till destination * /
src ++; / * Öka källpekaren * /
dest ++; / * Öka målpekaren * /
* dest = '\ 0'; / * Infoga '\ 0' i destinationen uttryckligen * /
returnera dest_backup;
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [30];
printf ("Innan du ringer användardefinierad strängkopiefunktion: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
/ * Ringer användardefinierad strängkopieringsfunktion * /
strcpy_user_defined (destination_str, source_str);
printf ("Efter körning av användardefinierad strängkopiefunktion: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
returnera 0;
strcpy () - Användardefinierad version optimerad (exempel 6.c):
Nu, i detta exempelprogram, ska vi optimera den användardefinierade versionen av strcpy ().
#omfattachar * strcpy_user_defined (char * dest, const char * src);
/ * Optimerad version av användardefinierad strcpy () -funktion * /
char * strcpy_user_defined (char * dest, const char * src)
char * dest_backup = dest;
medan (* dest ++ = * src ++)
;
returnera dest_backup;
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [30];
printf ("Innan du ringer användardefinierad strängkopiefunktion: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
/ * Ringer användardefinierad strängkopieringsfunktion * /
strcpy_user_defined (destination_str, source_str);
printf ("Efter körning av användardefinierad strängkopiefunktion: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tDestination String =% s \ n \ n", destination_str);
returnera 0;
Slutsats:
Strcpy () -funktionen är en mycket populär och praktisk biblioteksfunktion för att utföra strängkopiering i C-programmeringsspråket. Detta används främst för att kopiera strängen från en plats till en annan plats. Vi vill dock upprepa att strcpy () -funktionen inte gör gränskontrollen för destinationsmatrisen, vilket kan leda till en allvarlig programvarufel om den ignoreras. Det är alltid programmerarens ansvar att se till att destinationsmatrisen har tillräckligt med utrymme för att rymma alla tecken från källsträngen inklusive NULL-tecknet.
