Syntax:
röding* strcpy (röding*destination_location, konst röding*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å syntaxen ovan för funktionen strcpy (). Strcpy () -funktionen kan acceptera två parametrar -
- char * destination
- const char * källa
Källan är en konstant här för att säkerställa att strcpy () -funktionen inte kan ändra källsträngen. Strcpy () -funktionen kopierar alla tecken (inklusive NULL -tecknet i slutet av strängen) från källsträngen till destinationen. När kopieringsoperationen är klar från källa till destination returnerar funktionen strcpy () adressen till destinationen tillbaka till den som ringer.
Den viktiga punkten att notera här är att funktionen strcpy () inte lägger till källsträngen med målsträngen. Det ersätter snarare innehållet i destinationen med innehållet i källsträngen.
Strcpy () -funktionen utför inte heller några 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 ()-Case-1 (exempel2.c)
- strcpy ()-Case-2 (exempel3.c)
- strcpy ()-Case-3 (exempel4.c)
- strcpy () - Användardefinierad version (exempel5.c)
- strcpy () - Användardefinierad version optimerad (exempel6.c)
strcpy () - Normal drift (exempel1.c):
Detta exempelprogram visar hur man utför en normal strängkopiering med funktionen strcpy () i programmeringsspråket C. Observera att längden på destinationssträngen är 30 (char destination_str [30];), vilket är större än längden på källsträngen (längden är 18 inklusive NULL -tecknet) så att destinationen kan rymma alla tecken från källsträng.
#omfatta
#omfatta
inthuvud()
{
rödingsource_str[] = 'www.linuxhint.com';
rödingdestination_str[30];
printf ('Innan du ringer strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
strcpy (destination_str,source_str);
printf ('Efter att ha kört strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
lämna tillbaka 0;
}
strcpy ()-Case-1 (exempel2.c):
Avsikten 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 har destinationsplatsen inte tillräckligt med mellanslag/byte för att rymma alla tecken (inklusive NULL -tecken) från källsträngen. Två saker du alltid bör tänka på:
- Strcpy () -funktionen kontrollerar inte om destinationen har tillräckligt med utrymme.
- Detta kan vara farligt i inbäddad programvara eftersom strcpy () kommer att ersätta minnesområdet bortom destinationens gräns.
Låt oss titta på exempelprogrammet. Vi har deklarerat source_str och initierat det till www.linuxhint.com , vilket tar 18 byte i minnet att lagra, inklusive Null -tecknet i slutet av strängen. Sedan har vi deklarerat en annan teckenmatris, dvs. destination_str med storleken endast 5. Så destination_str kan inte hålla källsträngen med en total storlek på 18 byte.
Men vi ringer fortfarande strcpy () -funktionen för att kopiera källsträngen till målsträngen. Från nedanstående utmatning kan vi se att strcpy () inte alls klagade. I det här fallet kommer strcpy () -funktionen att börja kopiera tecknet från källsträngen (tills det 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 destinationsmatris. Så småningom kommer strcpy () -funktionen att skriva över minnesadresserna som inte är allokerade till destinationsmatrisen. Det är därför som strcpy () -funktionen kommer att skriva över minnesplatserna som kan tilldelas en annan variabel.
I det här exemplet kan vi se från nedanstående utdata, att funktionen strcpy () skriver över själva källsträngen. Programmerare bör alltid vara försiktiga med sådant beteende.
#omfatta#omfatta
inthuvud()
{
rödingsource_str[] = 'www.linuxhint.com';
rödingdestination_str[5];
printf ('Innan du ringer strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
strcpy (destination_str,source_str);
printf ('Efter att ha kört strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
// printf ('Källadress = %u (0x %x) n', & source_str [0], & source_str [0]);
// printf ('Destinationsadress = %u (0x %x) n', & destination_str [0], & destination_str [0]);
lämna tillbaka 0;
}
strcpy ()-Case-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 [storlek = 25+1 = 26]
Strcpy () -funktionen kopierar alla 17 tecken och NULL -tecknet från källsträngen till målsträngen. Men det kommer inte att ersätta/ändra de återstående byte (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 arrayen för att bevisa att bytes-19 till 26 är oförändrade i destinationsmatrisen. Det är därför vi ser den sista utmatningen som:
#omfatta#omfatta
/* Detta program illustrerar situationen när:
målsträngstorlek> källsträngstorlek
och vi kör funktionen strcpy () för att kopiera
källsträng till destinationen.
Obs! Målsträngens storlek ska alltid
vara större än eller lika med källsträngen.
* /
inthuvud()
{
rödingsource_str[] = 'www.linuxhint.com';
rödingdestination_str[26] = 'I_AM_A_DESTINATION_STRING';
printf ('Innan du ringer strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
strcpy (destination_str,source_str);
printf ('Efter att ha kört strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
/* skriv ut destinationssträng med loop*/
printf ('Skriv ut målsträngen char by char: n n');
printf (' tDestination String = ');
för(inti=0;i<25;i++)
{
printf ('% c',destination_str[i]);
}
printf (' n n');
lämna tillbaka 0;
}
strcpy ()-Case-3 (exempel4.c):
Vi har betraktat detta program som ett exempel för att visa att vi aldrig ska kalla strcpy () med en sträng bokstavlig som destination. Detta kommer att orsaka odefinierat beteende och så småningom kommer programmet att krascha.
#omfatta#omfatta
inthuvud()
{
rödingsource_str[] = 'www.linuxhint.com';
printf ('Innan du ringer strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
/* Ring aldrig strcpy () med strängbokstav som destination.
Programmet kommer att krascha.
* /
strcpy ('destination_str',source_str);
printf ('Efter att ha kört strcpy () -funktionen: n n');
printf (' tKällsträng = %s n',source_str);
lämna tillbaka 0;
}
strcpy () - Användardefinierad version (exempel5.c):
I detta exempelprogram har vi visat hur man skriver en användardefinierad version av strcpy () -funktionen.
#omfattaröding *strcpy_user_defined(röding *dest, konst röding *src);
/ * Användardefinierad version av funktionen strcpy () */
röding *strcpy_user_defined(röding *dest, konst röding *src)
{
röding *dest_backup=dest;
medan(*src! = ' 0') /* Iterera tills ' 0' hittas.*/
{
*dest= *src; / * Kopiera källkod till destination */
src++; / * Öka källpekaren */
dest++; / * Öka målpekaren */
}
*dest= ' 0'; /* Infoga ' 0' i destinationen uttryckligen*/
lämna tillbakadest_backup;
}
inthuvud()
{
rödingsource_str[] = 'www.linuxhint.com';
rödingdestination_str[30];
printf ('Innan du ringer användardefinierad strängkopieringsfunktion: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
/ * Ringer användardefinierad strängkopieringsfunktion */
strcpy_user_defined(destination_str,source_str);
printf ('Efter att ha utfört användardefinierad strängkopieringsfunktion: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
lämna tillbaka 0;
}
strcpy () - Användardefinierad version optimerad (exempel6.c):
Nu, i detta exempelprogram, ska vi optimera den användardefinierade versionen av strcpy ().
#omfattaröding *strcpy_user_defined(röding *dest, konst röding *src);
/ * Optimerad version av användardefinierad strcpy () -funktion */
röding *strcpy_user_defined(röding *dest, konst röding *src)
{
röding *dest_backup=dest;
medan(*dest++ = *src++)
;
lämna tillbakadest_backup;
}
inthuvud()
{
rödingsource_str[] = 'www.linuxhint.com';
rödingdestination_str[30];
printf ('Innan du ringer användardefinierad strängkopieringsfunktion: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
/ * Ringer användardefinierad strängkopieringsfunktion */
strcpy_user_defined(destination_str,source_str);
printf ('Efter att ha utfört användardefinierad strängkopieringsfunktion: n n');
printf (' tKällsträng = %s n',source_str);
printf (' tDestinationssträng = %s n n',destination_str);
lämna tillbaka 0;
}
Slutsats :
Strcpy () -funktionen är en mycket populär och praktisk biblioteksfunktion för att utföra strängkopiering i programmeringsspråket C. Detta används främst för att kopiera strängen från en plats till en annan plats. Vi vill dock upprepa det faktum att strcpy () -funktionen inte gör gränskontrollen för destinationsmatrisen, vilket kan leda till en allvarlig mjukvarufel om den ignoreras. Det är alltid programmerarens ansvar att se till att målmatrisen har tillräckligt med utrymme för att hålla alla tecken från källsträngen inklusive NULL -tecknet.