Syntax:
char* strcpy (char*umístění_cíle, konst char*source_string);Pochopení strcpy ():
Jediným účelem funkce strcpy () je zkopírovat řetězec ze zdroje do cíle. Nyní se podívejme na výše uvedenou syntaxi funkce strcpy (). Funkce strcpy () je schopna přijmout dva parametry -
- char * destinace
- const char * zdroj
Zdroj je zde konstanta, která zajišťuje, že funkce strcpy () nemůže změnit zdrojový řetězec. Funkce strcpy () zkopíruje všechny znaky (včetně znaku NULL na konci řetězce) ze zdrojového řetězce do cíle. Jakmile je operace kopírování dokončena ze zdroje do cíle, funkce strcpy () vrátí adresu cíle zpět do funkce volajícího.
Zde je důležité si všimnout, že funkce strcpy () nepřipojí zdrojový řetězec k cílovému řetězci. Nahrazuje spíše obsah cíle obsahem zdrojového řetězce.
Funkce strcpy () také neprovádí žádné kontroly, aby se zajistilo, že velikost cíle je větší než zdrojový řetězec, je zcela na zodpovědnosti programátora.
Příklady:
Nyní uvidíme několik příkladů pro pochopení funkce strcpy ():
- strcpy () - normální provoz (příklad1.c)
- strcpy ()-Případ-1 (příklad2.c)
- strcpy ()-Případ-2 (příklad3.c)
- strcpy ()-Případ-3 (příklad4.c)
- strcpy () - uživatelem definovaná verze (příklad5.c)
- strcpy () - verze definovaná uživatelem (příklad6.c)
strcpy () - normální operace (příklad1.c):
Tento ukázkový program ukazuje, jak provést normální operaci kopírování řetězců pomocí funkce strcpy () v programovacím jazyce C. Mějte na paměti, že délka cílového řetězce je 30 (char destination_str [30];), což je větší než délka zdrojového řetězce (délka je 18 včetně znaku NULL), takže do cíle lze umístit všechny znaky z zdrojový řetězec.
#zahrnout
#zahrnout
inthlavní()
{
charsource_str[] = 'www.linuxhint.com';
chardestination_str[30];
printf ('Před voláním funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
strcpy (destination_str,source_str);
printf ('Po provedení funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
vrátit se 0;
}
strcpy ()-Případ-1 (příklad2.c):
Účelem tohoto příkladu programu je jasně vysvětlit, co se stane, když je délka cílového řetězce menší než délka zdrojového řetězce. V takových případech nebude mít cílové umístění dostatek mezer/bajtů pro umístění všech znaků (včetně znaku NULL) ze zdrojového řetězce. Vždy byste měli mít na paměti dvě věci:
- Funkce strcpy () nekontroluje, zda je v cíli dostatek místa.
- Ve vestavěném softwaru to může být nebezpečné, protože strcpy () nahradí oblast paměti za hranicí cíle.
Podívejme se na ukázkový program. Deklarovali jsme source_str a inicializovali jej www.linuxhint.com , což bude trvat 18 bajtů v paměti, včetně znaku Null na konci řetězce. Potom jsme deklarovali další pole znaků, tj. Destination_str o velikosti pouze 5. Cílový_str. Tedy nemůže pojmout zdrojový řetězec o celkové velikosti 18 bajtů.
Ale přesto voláme funkci strcpy (), abychom zkopírovali zdrojový řetězec do cílového řetězce. Z níže uvedeného výstupu vidíme, že strcpy () si vůbec nestěžoval. V tomto případě začne funkce strcpy () kopírovat znak ze zdrojového řetězce (dokud ve zdrojovém řetězci nenajde znak NULL) na cílovou adresu (přestože hranice cíle překračuje). To znamená, že funkce strcpy () neprovádí žádnou kontrolu hranic pro cílové pole. Nakonec funkce strcpy () přepíše adresy paměti, které nejsou přiděleny cílovému poli. To je důvod, proč funkce strcpy () skončí s přepsáním paměťových míst, která mohou být přidělena jiné proměnné.
V tomto příkladu z níže uvedeného výstupu vidíme, že funkce strcpy () přepíše samotný zdrojový řetězec. Programátoři by na takové chování měli být vždy opatrní.
#zahrnout#zahrnout
inthlavní()
{
charsource_str[] = 'www.linuxhint.com';
chardestination_str[5];
printf ('Před voláním funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
strcpy (destination_str,source_str);
printf ('Po provedení funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
// printf ('Adresa zdroje = %u (0x %x) n', & source_str [0], & source_str [0]);
// printf ('Cílová adresa = %u (0x %x) n', & destination_str [0], & destination_str [0]);
vrátit se 0;
}
strcpy ()-Případ-2 (příklad3.c):
Tento program ukazuje situaci, kdy je velikost cílového řetězce větší než velikost zdrojového řetězce a cílový řetězec je již inicializován s nějakou hodnotou. V tomto příkladu jsme inicializovali:
- source_str do www.linuxhint.com [velikost = 17+1 = 18]
- destination_str do I_AM_A_DESTINATION_STRING [velikost = 25+1 = 26]
Funkce strcpy () zkopíruje všech 17 znaků a znak NULL ze zdrojového řetězce do cílového řetězce. Ale nenahradí/nezmění zbývající bajty (bajt 19 až 26, založený na jednom) v cílovém poli. Použili jsme smyčku pro iteraci cílového pole a tisk celého pole, abychom dokázali, že bajty-19 až 26 jsou v cílovém poli nezměněny. Proto vidíme poslední výstup jako:
#zahrnout#zahrnout
/* Tento program ilustruje situaci, když:
velikost cílového řetězce> velikost zdrojového řetězce
a spustíme funkci strcpy () pro zkopírování souboru
zdrojový řetězec do cíle.
Poznámka: Velikost cílového řetězce by měla být vždy
být větší nebo roven zdrojovému řetězci.
* /
inthlavní()
{
charsource_str[] = 'www.linuxhint.com';
chardestination_str[26] = 'I_AM_A_DESTINATION_STRING';
printf ('Před voláním funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
strcpy (destination_str,source_str);
printf ('Po provedení funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
/* vytisknout cílový řetězec pomocí pro smyčku*/
printf ('Vytiskněte cílový řetězec char podle char: n n');
printf (' tCílový řetězec = ');
pro(intjá=0;já<25;já++)
{
printf ('% c',destination_str[já]);
}
printf (' n n');
vrátit se 0;
}
strcpy ()-Případ-3 (příklad4.c):
Tento program jsme považovali za příklad, který ukazuje, že bychom nikdy neměli volat strcpy () s řetězcovým literálem jako cílem. To způsobí nedefinované chování a nakonec program spadne.
#zahrnout#zahrnout
inthlavní()
{
charsource_str[] = 'www.linuxhint.com';
printf ('Před voláním funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
/* Nikdy nevolejte strcpy () s doslovným řetězcem jako cílem.
Program se zhroutí.
* /
strcpy ('destination_str',source_str);
printf ('Po provedení funkce strcpy (): n n');
printf (' tZdrojový řetězec = %s n',source_str);
vrátit se 0;
}
strcpy () - uživatelem definovaná verze (příklad5.c):
V tomto ukázkovém programu jsme ukázali, jak napsat uživatelem definovanou verzi funkce strcpy ().
#zahrnoutchar *strcpy_user_defined(char *dest, konst char *src);
/ * Uživatelem definovaná verze funkce strcpy () */
char *strcpy_user_defined(char *dest, konst char *src)
{
char *dest_backup=dest;
zatímco(*src! = ' 0') /* Opakujte, dokud nenajdete ' 0'.*/
{
*dest= *src; / * Kopírovat zdrojový znak do cíle */
src++; / * Přírůstkový ukazatel zdroje */
dest++; / * Zvýšit ukazatel cíle */
}
*dest= ' 0'; /* Vložte explicitně ' 0' do cíle*/
vrátit sedest_backup;
}
inthlavní()
{
charsource_str[] = 'www.linuxhint.com';
chardestination_str[30];
printf ('Před voláním funkce kopírování řetězců definovaných uživatelem: n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
/ * Volání uživatelem definované funkce kopírování řetězců */
strcpy_user_defined(destination_str,source_str);
printf ('Po provedení funkce kopírování řetězců definovaných uživatelem: n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
vrátit se 0;
}
strcpy () - uživatelsky definovaná verze optimalizovaná (příklad6.c):
V tomto příkladu programu nyní optimalizujeme uživatelem definovanou verzi strcpy ().
#zahrnoutchar *strcpy_user_defined(char *dest, konst char *src);
/ * Optimalizovaná verze uživatelem definované funkce strcpy () */
char *strcpy_user_defined(char *dest, konst char *src)
{
char *dest_backup=dest;
zatímco(*dest++ = *src++)
;
vrátit sedest_backup;
}
inthlavní()
{
charsource_str[] = 'www.linuxhint.com';
chardestination_str[30];
printf ('Před voláním funkce kopírování řetězců definovaných uživatelem: n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
/ * Volání uživatelem definované funkce kopírování řetězců */
strcpy_user_defined(destination_str,source_str);
printf ('Po provedení funkce kopírování řetězců definovaných uživatelem: n n');
printf (' tZdrojový řetězec = %s n',source_str);
printf (' tCílový řetězec = %s n n',destination_str);
vrátit se 0;
}
Závěr :
Funkce strcpy () je velmi populární a praktická knihovní funkce pro provádění operace kopírování řetězců v programovacím jazyce C. To se používá hlavně ke kopírování řetězce z jednoho umístění do jiného. Chceme však zopakovat skutečnost, že funkce strcpy () neprovádí kontrolu hranic pro cílové pole, což by mohlo v případě ignorování vést k závažné softwarové chybě. Vždy je na zodpovědnosti programátora, aby se ujistil, že cílové pole má dostatek místa pro uložení všech znaků ze zdrojového řetězce včetně znaku NULL.