Sintaxe:
char * strcpy (char * local_de_destino, const char * source_string);Compreendendo strcpy ():
O único propósito da função strcpy () é copiar uma string da fonte para o destino. Agora, vamos examinar a sintaxe acima da função strcpy (). A função strcpy () é capaz de aceitar dois parâmetros -
- destino char *
- fonte const char *
A fonte é uma constante aqui para garantir que a função strcpy () não possa alterar a string fonte. A função strcpy () copia todos os caracteres (incluindo o caractere NULL no final da string) da string de origem para o destino. Depois que a operação de cópia é concluída da origem ao destino, a função strcpy () retorna o endereço do destino de volta para a função do chamador.
O ponto importante a notar aqui é que a função strcpy () não anexa a string de origem à string de destino. Em vez disso, substitui o conteúdo do destino pelo conteúdo da string de origem.
Além disso, a função strcpy () não executa nenhuma verificação para garantir que o tamanho do destino é maior do que a string de origem, é totalmente responsabilidade do programador.
Exemplos:
Agora, veremos vários exemplos para entender a função strcpy ():
- strcpy () - Operação normal (exemplo 1.c)
- strcpy () - Caso-1 (exemplo2.c)
- strcpy () - Caso 2 (exemplo 3.c)
- strcpy () - Caso 3 (exemplo 4.c)
- strcpy () - Versão definida pelo usuário (exemplo 5.c)
- strcpy () - versão definida pelo usuário otimizada (exemplo 6.c)
strcpy () - Operação normal (exemplo 1.c):
Este programa de exemplo mostra como realizar uma operação normal de cópia de string usando a função strcpy () na linguagem de programação C. Observe que o comprimento da string de destino é 30 (char destination_str [30];), que é maior que o comprimento da string de origem (o comprimento é 18 incluindo o caractere NULL) para que o destino possa acomodar todos os caracteres do string de origem.
#incluir#incluir
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [30];
printf ("Antes de chamar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
strcpy (destino_str, fonte_str);
printf ("Depois de executar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
return 0;
strcpy () - Caso-1 (exemplo2.c):
A intenção deste programa de exemplo é explicar claramente o que acontece quando o comprimento da string de destino é menor que o comprimento da string de origem. Nesses casos, o local de destino não terá espaços / bytes suficientes para acomodar todos os caracteres (incluindo o caractere NULL) da string de origem. Duas coisas você deve sempre ter em mente:
- A função strcpy () não irá verificar se o destino tem espaço suficiente.
- Isso pode ser perigoso em software embutido porque o strcpy () irá substituir a área de memória além do limite do destino.
Vejamos o programa de exemplo. Declaramos source_str e o inicializamos como “www.linuxhint.com ”, que levará 18 bytes na memória para armazenar, incluindo o caractere nulo no final da string. Então, declaramos outro array de caracteres i.e. destination_str com o tamanho de apenas 5. Portanto, o destination_str não pode conter a string de origem com um tamanho total de 18 bytes.
Mas, ainda assim, estamos chamando a função strcpy () para copiar a string de origem para a string de destino. A partir da saída abaixo, podemos ver que strcpy () não apresentou nenhuma reclamação. Neste caso, a função strcpy () começará a copiar o caractere da string de origem (até encontrar o caractere NULL na string 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 () irá sobrescrever os endereços de memória que não estão alocados para a matriz de destino. É por isso que a função strcpy () irá terminar sobrescrevendo 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 () sobrescreve a própria string de origem. Os programadores devem sempre ter cuidado com esse comportamento.
#incluir#incluir
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [5];
printf ("Antes de chamar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
strcpy (destino_str, fonte_str);
printf ("Depois de executar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
// printf ("Endereço de origem =% u (0x% x) \ n", & source_str [0], & source_str [0]);
// printf ("Endereço de destino =% u (0x% x) \ n", & destination_str [0], & destination_str [0]);
return 0;
strcpy () - Caso 2 (exemplo 3.c):
Este programa ilustra a situação quando o tamanho da string de destino é maior que o tamanho da string de origem e a string de destino já foi inicializada com algum valor. Neste exemplo, inicializamos:
- source_str para “www.linuxhint.com ”[tamanho = 17 + 1 = 18]
- destination_str para “I_AM_A_DESTINATION_STRING” [size = 25 + 1 = 26]
A função strcpy () irá copiar todos os 17 caracteres e o caractere NULL 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 for para iterar sobre o array de destino e imprimir todo o array para provar que os bytes-19 a 26 permanecem inalterados no array 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 string de destino> tamanho da string de origem
e executamos a função strcpy () para copiar o
string de origem para destino.
Observação: o tamanho da string de destino deve sempre
ser maior ou igual à string de origem.
* /
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [26] = "I_AM_A_DESTINATION_STRING";
printf ("Antes de chamar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
strcpy (destino_str, fonte_str);
printf ("Depois de executar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
/ * imprimir string de destino usando for loop * /
printf ("Imprimir a string de destino char por char: \ n \ n");
printf ("\ tCadeia de destino =");
para (int i = 0; i<25;i++)
printf ("% c", destination_str [i]);
printf ("\ n \ n");
return 0;
strcpy () - Caso 3 (exemplo 4.c):
Consideramos este programa como um exemplo para mostrar que nunca devemos chamar strcpy () com uma string literal como destino. Isso causará um comportamento indefinido e, eventualmente, o programa irá travar.
#incluir#incluir
int main ()
char source_str [] = "www.linuxhint.com ";
printf ("Antes de chamar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
/ * Nunca chame strcpy () com string literal como destino.
O programa irá travar.
* /
strcpy ("destino_str", fonte_str);
printf ("Depois de executar a função strcpy (): \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
return 0;
strcpy () - Versão definida pelo usuário (exemplo 5.c):
Neste programa de exemplo, mostramos como escrever uma versão definida pelo usuário da função strcpy ().
#incluirchar * 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;
while (* src != '\ 0') / * Iterar até que '\ 0' seja encontrado.* /
* dest = * src; / * Copiar caractere de origem para o destino * /
src ++; / * Incrementar ponteiro de origem * /
dest ++; / * Incrementar ponteiro de destino * /
* dest = '\ 0'; / * Insira '\ 0' no destino explicitamente * /
return dest_backup;
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [30];
printf ("Antes de chamar a função de cópia de string definida pelo usuário: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
/ * Chamando função de cópia de string definida pelo usuário * /
strcpy_user_defined (destination_str, source_str);
printf ("Depois de executar a função de cópia de string definida pelo usuário: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
return 0;
strcpy () - versão definida pelo usuário otimizada (exemplo 6.c):
Agora, neste programa de exemplo, vamos otimizar a versão definida pelo usuário de strcpy ().
#incluirchar * 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;
enquanto (* dest ++ = * src ++)
;
return dest_backup;
int main ()
char source_str [] = "www.linuxhint.com ";
char destination_str [30];
printf ("Antes de chamar a função de cópia de string definida pelo usuário: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
/ * Chamando função de cópia de string definida pelo usuário * /
strcpy_user_defined (destination_str, source_str);
printf ("Depois de executar a função de cópia de string definida pelo usuário: \ n \ n");
printf ("\ tSource String =% s \ n", source_str);
printf ("\ tCadeia de destino =% s \ n \ n", destination_str);
return 0;
Conclusão:
A função strcpy () é uma função de biblioteca muito popular e útil para realizar 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 limite para o array de destino, o que pode levar a um sério bug de software se for ignorado. É sempre responsabilidade do programador garantir que o array de destino tenha espaço suficiente para conter todos os caracteres da string de origem, incluindo o caractere NULL.