Sintaxe:
Caracteres* forte (Caracteres*local_de_destino, const Caracteres*source_string);Compreendendo strcpy ():
O único propósito da função strcpy () é copiar uma string da origem 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 de origem. 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 à função do chamador.
O ponto importante a notar aqui é que a função strcpy () não acrescenta 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 seja maior do que a string de origem, é responsabilidade total do programador.
Exemplos:
Agora, veremos vários exemplos para entender a função strcpy ():
- strcpy () - Operação normal (exemplo1.c)
- strcpy () - Caso-1 (exemplo2.c)
- strcpy () - Caso-2 (exemplo3.c)
- strcpy () - Caso-3 (exemplo4.c)
- strcpy () - Versão definida pelo usuário (exemplo5.c)
- strcpy () - versão definida pelo usuário otimizada (exemplo6.c)
strcpy () - Operação normal (exemplo1.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 do 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
inta Principal()
{
Caracteressource_str[] = 'www.linuxhint.com';
Caracteresdestination_str[30];
printf ('Antes de chamar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
printf (' tString de Destino =% s n n',destination_str);
forte (destination_str,source_str);
printf ('Depois de executar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
printf (' tString de Destino =% s n n',destination_str);
Retorna 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 verificará se o destino tem espaço suficiente.
- Isso pode ser perigoso em software incorporado porque o strcpy () 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. Em seguida, declaramos outro array de caracteres, ou seja, 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. Pela saída abaixo, podemos ver que strcpy () não reclama. Nesse 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 o array de destino. Eventualmente, a função strcpy () sobrescreverá os endereços de memória que não estão alocados ao array de destino. É por isso que a função strcpy () acabará 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
inta Principal()
{
Caracteressource_str[] = 'www.linuxhint.com';
Caracteresdestination_str[5];
printf ('Antes de chamar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
printf (' tString de Destino =% s n n',destination_str);
forte (destination_str,source_str);
printf ('Depois de executar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
printf (' tString 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]);
Retorna 0;
}
strcpy () - Caso-2 (exemplo3.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 no array de destino e imprimir o array inteiro para provar que os bytes 19 a 26 não foram alterados no array de destino. É por isso que vemos a última saída como:
#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.
* /
inta Principal()
{
Caracteressource_str[] = 'www.linuxhint.com';
Caracteresdestination_str[26] = 'I_AM_A_DESTINATION_STRING';
printf ('Antes de chamar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
printf (' tString de Destino =% s n n',destination_str);
forte (destination_str,source_str);
printf ('Depois de executar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
printf (' tString de Destino =% s n n',destination_str);
/ * imprimir string de destino usando for loop * /
printf ('Imprime a string de destino caractere por caractere: n n');
printf (' tString de destino = ');
para(inteu=0;eu<25;eu++)
{
printf ('% c',destination_str[eu]);
}
printf (' n n');
Retorna 0;
}
strcpy () - Caso-3 (exemplo4.c):
Consideramos esse 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
inta Principal()
{
Caracteressource_str[] = 'www.linuxhint.com';
printf ('Antes de chamar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
/ * Nunca chame strcpy () com literal de string como destino.
O programa irá travar.
* /
forte ('destination_str',source_str);
printf ('Depois de executar a função strcpy (): n n');
printf (' tString de origem =% s n',source_str);
Retorna 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 ().
#incluirCaracteres *strcpy_user_defined(Caracteres *dest, const Caracteres *src);
/ * Versão definida pelo usuário da função strcpy () * /
Caracteres *strcpy_user_defined(Caracteres *dest, const Caracteres *src)
{
Caracteres *dest_backup=dest;
enquanto(*src! = ' 0') / * Repita 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 * /
Retornadest_backup;
}
inta Principal()
{
Caracteressource_str[] = 'www.linuxhint.com';
Caracteresdestination_str[30];
printf ('Antes de chamar a função de cópia de string definida pelo usuário: n n');
printf (' tString de origem =% s n',source_str);
printf (' tString 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 (' tString de origem =% s n',source_str);
printf (' tString de Destino =% s n n',destination_str);
Retorna 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 de strcpy ().
#incluirCaracteres *strcpy_user_defined(Caracteres *dest, const Caracteres *src);
/ * Versão otimizada da função strcpy () definida pelo usuário * /
Caracteres *strcpy_user_defined(Caracteres *dest, const Caracteres *src)
{
Caracteres *dest_backup=dest;
enquanto(*dest++ = *src++)
;
Retornadest_backup;
}
inta Principal()
{
Caracteressource_str[] = 'www.linuxhint.com';
Caracteresdestination_str[30];
printf ('Antes de chamar a função de cópia de string definida pelo usuário: n n');
printf (' tString de origem =% s n',source_str);
printf (' tString 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 (' tString de origem =% s n',source_str);
printf (' tString de Destino =% s n n',destination_str);
Retorna 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 bug de software sério 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.