Como usar o STRCPY na linguagem C?

Neste artigo, vamos aprender sobre a função strcpy () na linguagem de programação C. A função strcpy () é uma função de biblioteca padrão muito popular para executar a operação de cópia de string na linguagem de programação C C. Existem vários arquivos de cabeçalho padrão na linguagem de programação C para executar operações padrão. A corda.H ”é um desses arquivos de cabeçalho, que fornece várias funções de biblioteca padrão para executar operações de string. A função "strcpy ()" é uma das funções da biblioteca fornecidas por "String.h ".

Sintaxe:

char* strcpy (char* destino_location, const char* fonte_string);

Compreensão strcpy ():

O único objetivo da função strcpy () é copiar uma string de fonte para destino. Agora, vamos olhar para a sintaxe acima da função strcpy (). A função strcpy () é capaz de aceitar dois parâmetros -

• Char * destino
• Const Char * Fonte

A fonte é uma constante aqui para garantir que a função strcpy () não possa alterar a string de origem. A função strcpy () copia todos os caracteres (incluindo o caractere nulo no final da string) da string de origem para o destino. Depois que a operação de cópia é concluída de fonte para destino, a função strcpy () retorna o endereço do destino de volta à função do chamador.

O ponto importante a ser observado aqui é que a função strcpy () não anexa a sequência de origem à sequência de destino. Ele substitui o conteúdo do destino pelo conteúdo da string de origem.

Além disso, a função strcpy () não executa nenhum cheque para garantir que o tamanho do destino seja maior que a sequência de origem, é completamente de responsabilidade do programador.

Exemplos:

Agora, veremos vários exemplos para entender a função strcpy ():

1. strCpy () - Operação normal (Exemplo1.c)
2. strCpy () - case -1 (Exemplo2.c)
3. strcpy () - case -2 (exemplo3.c)
4. strCpy () - Case -3 (Exemplo4.c)
5. strcpy () - versão definida pelo usuário (exemplo5.c)
6. strcpy () - versão definida pelo usuário otimizada (exemplo6.c)

strCpy () - Operação normal (Exemplo1.c):

Este programa de exemplo mostra como executar uma operação normal de cópia de string usando a função strcpy () na linguagem de programação C C. Observe que o comprimento da sequência de destino é 30 (char destination_str [30];), que é maior que o comprimento da sequência de origem (o comprimento é 18, incluindo o caractere nulo) para que o destino possa acomodar todos os caracteres do string de origem.

#incluir
#incluir
int main ()

char fonte_str [] = "www.Linuxhint.com ";
char destino_str [30];
printf ("Antes de chamar strcpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
strCpy (destino_str, fonte_str);
printf ("Depois de executar strCpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
retornar 0;

strCpy () - case -1 (Exemplo2.c):

A intenção deste programa de exemplo é explicar claramente o que acontece quando a duração da sequência de destino é menor que o comprimento da sequência de origem. Nesses casos, o local do destino não terá espaços/bytes suficientes para acomodar todos os personagens (incluindo caracteres nulos) da string de origem. Duas coisas, você sempre deve ter em mente:

1. A função strcpy () não verificará se o destino tem espaço suficiente.
2. Isso pode ser perigoso no software incorporado, porque o strcpy () substituirá a área de memória além do limite do destino.

Vejamos o programa de exemplo. Declaramos fonte_str e inicializamos para “www.Linuxhint.com ”, que receberá 18 bytes na memória para armazenar, incluindo o caractere nulo no final da string. Então, declaramos outra matriz de personagens que eu.e. destino_str com o tamanho de apenas 5. Portanto, o destino_str não pode segurar a sequência de origem com um tamanho total de 18 bytes.

Mas, ainda assim, estamos chamando a função strcpy () para copiar a sequência de origem para a string de destino. Na saída abaixo, podemos ver o strcpy () não reclamou. Nesse caso, a função strcpy () começará a copiar o personagem da sequência de origem (até encontrar o caractere nulo na sequência de origem) para o endereço de destino (mesmo que o limite de destino exceda). Isso significa que a função strcpy () não faz nenhuma verificação de limite para a matriz de destino. Eventualmente, a função strcpy () substituirá os endereços de memória que não são alocados para a matriz de destino. É por isso que a função strcpy () acabará substituindo os locais de memória que podem ser alocados para uma variável diferente.

Neste exemplo, podemos ver na saída abaixo, que a função strcpy () substitui a própria string de origem. Os programadores devem sempre ter cuidado com esse comportamento.

#incluir
#incluir
int main ()

char fonte_str [] = "www.Linuxhint.com ";
char destino_str [5];
printf ("Antes de chamar strcpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
strCpy (destino_str, fonte_str);
printf ("Depois de executar strCpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
// printf ("endereço de origem = %u (0x %x) \ n", & fonte_str [0], & fonte_str [0]);
// printf ("endereço de destino = %u (0x %x) \ n", & destino_str [0], & destino_str [0]);
retornar 0;

strcpy () - case -2 (exemplo3.c):

Este programa ilustra a situação em que o tamanho da string de destino é maior que o tamanho da string de origem e a string de destino já é inicializada com algum valor. Neste exemplo, inicializamos:

• fonte_str para “www.Linuxhint.com ”[tamanho = 17+1 = 18]
• destino_str para “i_am_a_destination_string” [size = 25+1 = 26]

A função strcpy () copiará todos os 17 caracteres e o caractere nulo da string de origem para a string de destino. Mas, ele não substituirá/alterará os bytes restantes (byte 19 a 26, um baseado) na matriz de destino. Usamos o loop para iterar a matriz de destino e imprimir toda a matriz para provar que os bytes-19 a 26 permanecem inalterados na matriz de destino. É por isso que vemos a última saída como:

“Www.Linuxhint.com_string ”.

#incluir
#incluir
/* Este programa ilustra a situação quando:
Tamanho da cadeia de destino> Tamanho da string de origem
e executamos a função strcpy () para copiar o
string de origem para destino.
Nota: o tamanho da sequência de destino deve sempre
ser maior ou igual à corda de origem.
*/
int main ()

char fonte_str [] = "www.Linuxhint.com ";
char destino_str [26] = "i_am_a_destination_string";
printf ("Antes de chamar strcpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
strCpy (destino_str, fonte_str);
printf ("Depois de executar strCpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
/* Imprimir string de destino usando o loop*/
printf ("Imprima a string de destino char por char: \ n \ n");
printf ("\ tDestination string =");
para (int i = 0; i<25;i++)

printf ("%c", destino_str [i]);

printf ("\ n \ n");
retornar 0;

strCpy () - Case -3 (Exemplo4.c):

Consideramos esse programa como um exemplo para mostrar que nunca devemos chamar strcpy () com uma string literal como o destino. Isso causará comportamento indefinido e, eventualmente, o programa falhará.

#incluir
#incluir
int main ()

char fonte_str [] = "www.Linuxhint.com ";
printf ("Antes de chamar strcpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
/* Nunca ligue para strcpy () com string literal como destino.
O programa vai travar.
*/
strcpy ("destino_str", fonte_str);
printf ("Depois de executar strCpy () função: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
retornar 0;

strcpy () - versão definida pelo usuário (exemplo5.c):

Neste programa de exemplo, mostramos como escrever uma versão definida pelo usuário da função strcpy ().

#incluir
char * strcpy_user_defined (char * dest, const char * src);
/ * Versão definida pelo usuário da função strcpy () */
char * strcpy_user_defined (char * dest, const char * src)

char * dest_backup = dest;
enquanto (*src != '\ 0') /* iterar até que '\ 0' seja encontrado.*/

*dest = *src; / * Copiar char de origem para destino */
src ++; / * Incremento ponteiro da fonte */
dest ++; / * Incremento Ponteiro de destino */

*dest = '\ 0'; /* Inserir '\ 0' no destino explicitamente*/
retornar dest_backup;

int main ()

char fonte_str [] = "www.Linuxhint.com ";
char destino_str [30];
printf ("Antes de ligar para o usuário definido pela função de cópia de string: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
/ * Chamada Função de cópia de string definida pelo usuário */
strcpy_user_defined (destino_str, fonte_str);
printf ("Após a execução da função de cópia de string definida pelo usuário: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
retornar 0;

strcpy () - versão definida pelo usuário otimizada (exemplo6.c):

Agora, neste programa de exemplo, vamos otimizar a versão definida pelo usuário do strcpy ().

#incluir
char * strcpy_user_defined (char * dest, const char * src);
/ * Versão otimizada da função strcpy () definida pelo usuário */
char * strcpy_user_defined (char * dest, const char * src)

char * dest_backup = dest;
while ( *dest ++ = *src ++)
;
retornar dest_backup;

int main ()

char fonte_str [] = "www.Linuxhint.com ";
char destino_str [30];
printf ("Antes de ligar para o usuário definido pela função de cópia de string: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
/ * Chamada Função de cópia de string definida pelo usuário */
strcpy_user_defined (destino_str, fonte_str);
printf ("Após a execução da função de cópia de string definida pelo usuário: \ n \ n");
printf ("\ tsource string = %s \ n", fonte_str);
printf ("\ tDestination string = %s \ n \ n", destino_str);
retornar 0;

Conclusão:

A função strcpy () é uma função de biblioteca muito popular e útil para executar a operação de cópia de string na linguagem de programação C. Isso é usado principalmente para copiar a string de um local para outro. No entanto, queremos reiterar o fato de que a função strcpy () não faz a verificação de limites para a matriz de destino, o que pode levar a um bug sério de software se ignorado. É sempre de responsabilidade do programador garantir que a matriz de destino tenha espaço suficiente para manter todos os personagens da string de origem, incluindo o caractere nulo.