Syntaxe:
carboniser* strcpy (carboniser*lieu de destination, const carboniser*chaîne_source);Comprendre strcpy() :
Le seul but de la fonction strcpy() est de copier une chaîne de la source à la destination. Examinons maintenant la syntaxe ci-dessus de la fonction strcpy(). La fonction strcpy() est capable d'accepter deux paramètres -
- caractère * destination
- const char * source
La source est une constante ici pour garantir que la fonction strcpy() ne peut pas modifier la chaîne source. La fonction strcpy() copie tous les caractères (y compris le caractère NULL à la fin de la chaîne) de la chaîne source vers la destination. Une fois l'opération de copie terminée de la source à la destination, la fonction strcpy() renvoie l'adresse de la destination à la fonction appelante.
Le point important à noter ici est que la fonction strcpy() n'ajoute pas la chaîne source à la chaîne de destination. Il remplace plutôt le contenu de la destination par le contenu de la chaîne source.
De plus, la fonction strcpy() n'effectue aucune vérification pour s'assurer que la taille de la destination est supérieure à la chaîne source, elle est entièrement sous la responsabilité du programmeur.
Exemples:
Maintenant, nous allons voir plusieurs exemples pour comprendre la fonction strcpy() :
- strcpy() - Fonctionnement normal (exemple1.c)
- strcpy() – Cas-1 (exemple2.c)
- strcpy() – Cas-2 (exemple3.c)
- strcpy() – Cas-3 (exemple4.c)
- strcpy() - Version définie par l'utilisateur (exemple5.c)
- strcpy () - Version définie par l'utilisateur optimisée (exemple6.c)
strcpy() - Fonctionnement normal (exemple1.c) :
Cet exemple de programme montre comment effectuer une opération de copie de chaîne normale à l'aide de la fonction strcpy() dans le langage de programmation C. Veuillez noter que la longueur de la chaîne de destination est de 30 (char destination_str[30]; ), ce qui est supérieur à la longueur de la chaîne source (la longueur est de 18, y compris le caractère NULL) afin que la destination puisse accueillir tous les caractères du chaîne source.
#comprendre
#comprendre
entierprincipale()
{
carboniserchaîne_source[] = 'www.linuxhint.com';
carboniserchaîne_destination[30];
imprimer ('Avant d'appeler la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
strcpy (chaîne_destination,chaîne_source);
imprimer ('Après avoir exécuté la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
revenir 0;
}
strcpy() – Cas-1 (exemple2.c) :
Le but de cet exemple de programme est d'expliquer clairement ce qui se passe lorsque la longueur de la chaîne de destination est inférieure à la longueur de la chaîne source. Dans de tels cas, l'emplacement de destination n'aura pas suffisamment d'espaces/octets pour accueillir tous les caractères (y compris le caractère NULL) de la chaîne source. Deux choses que vous devez toujours garder à l'esprit :
- La fonction strcpy() ne vérifiera pas si la destination dispose de suffisamment d'espace.
- Cela pourrait être dangereux dans les logiciels embarqués car strcpy() remplacera la zone mémoire au-delà des limites de la destination.
Regardons l'exemple de programme. Nous avons déclaré source_str et l'avons initialisé à www.linuxhint.com , qui prendra 18 octets en mémoire pour être stocké, y compris le caractère Null à la fin de la chaîne. Ensuite, nous avons déclaré un autre tableau de caractères, c'est-à-dire destination_str avec une taille de seulement 5. Ainsi, destination_str ne peut pas contenir la chaîne source avec une taille totale de 18 octets.
Mais, toujours, nous appelons la fonction strcpy() pour copier la chaîne source dans la chaîne de destination. D'après la sortie ci-dessous, nous pouvons voir que strcpy() ne s'est pas plaint du tout. Dans ce cas, la fonction strcpy() commencera à copier le caractère de la chaîne source (jusqu'à ce qu'elle trouve le caractère NULL dans la chaîne source) vers l'adresse de destination (même si la limite de destination dépasse). Cela signifie que la fonction strcpy() ne fait aucune vérification des limites pour le tableau de destination. Finalement, la fonction strcpy() écrasera les adresses mémoire qui ne sont pas allouées au tableau de destination. C'est pourquoi la fonction strcpy() finira par écraser les emplacements mémoire qui pourraient être alloués à une variable différente.
Dans cet exemple, nous pouvons voir à partir de la sortie ci-dessous, que la fonction strcpy() écrase la chaîne source elle-même. Les programmeurs doivent toujours être prudents avec un tel comportement.
#comprendre#comprendre
entierprincipale()
{
carboniserchaîne_source[] = 'www.linuxhint.com';
carboniserchaîne_destination[5];
imprimer ('Avant d'appeler la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
strcpy (chaîne_destination,chaîne_source);
imprimer ('Après avoir exécuté la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
//printf('Adresse source = %u (0x%x) ', &source_str[0], &source_str[0]);
//printf('Adresse de destination = %u (0x%x) ', &destination_str[0], &destination_str[0]);
revenir 0;
}
strcpy() – Cas-2 (exemple3.c) :
Ce programme illustre la situation lorsque la taille de la chaîne de destination est supérieure à la taille de la chaîne source et que la chaîne de destination est déjà initialisée avec une certaine valeur. Dans cet exemple, nous avons initialisé :
- chaîne_source à www.linuxhint.com [taille = 17+1 = 18]
- destination_str à I_AM_A_DESTINATION_STRING [taille = 25+1 = 26]
La fonction strcpy() copiera tous les 17 caractères et le caractère NULL de la chaîne source vers la chaîne de destination. Mais, il ne remplacera/modifiera pas les octets restants (octet 19 à 26, basé sur un) dans le tableau de destination. Nous avons utilisé la boucle for pour parcourir le tableau de destination et imprimer l'ensemble du tableau pour prouver que les octets 19 à 26 sont inchangés dans le tableau de destination. C'est pourquoi nous voyons la dernière sortie comme:
#comprendre#comprendre
/* Ce programme illustre la situation lorsque :
taille de la chaîne de destination > taille de la chaîne source
et nous exécutons la fonction strcpy() pour copier le
chaîne source à destination.
Remarque : La taille de la chaîne de destination doit toujours
être supérieur ou égal à la chaîne source.
* /
entierprincipale()
{
carboniserchaîne_source[] = 'www.linuxhint.com';
carboniserchaîne_destination[26] = 'I_AM_A_DESTINATION_STRING';
imprimer ('Avant d'appeler la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
strcpy (chaîne_destination,chaîne_source);
imprimer ('Après avoir exécuté la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
/* affiche la chaîne de destination en utilisant la boucle for*/
imprimer ('Imprime la chaîne de destination char par char : ');
imprimer (' Chaîne de destination = ');
pour(entierje=0;je<25;je++)
{
imprimer ('%c',chaîne_destination[je]);
}
imprimer (' ');
revenir 0;
}
strcpy() – Cas-3 (exemple4.c) :
Nous avons considéré ce programme comme un exemple pour montrer que nous ne devrions jamais appeler strcpy() avec une chaîne littérale comme destination. Cela provoquera un comportement indéfini et éventuellement, le programme se bloquera.
#comprendre#comprendre
entierprincipale()
{
carboniserchaîne_source[] = 'www.linuxhint.com';
imprimer ('Avant d'appeler la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
/* Ne jamais appeler strcpy() avec un littéral de chaîne comme destination.
Le programme va planter.
* /
strcpy ('destination_str',chaîne_source);
imprimer ('Après avoir exécuté la fonction strcpy() : ');
imprimer (' Chaîne source = %s ',chaîne_source);
revenir 0;
}
strcpy() - Version définie par l'utilisateur (exemple5.c) :
Dans cet exemple de programme, nous avons montré comment écrire une version définie par l'utilisateur de la fonction strcpy().
#comprendrecarboniser *strcpy_user_defined(carboniser *destin, const carboniser *src);
/* Version définie par l'utilisateur de la fonction strcpy() */
carboniser *strcpy_user_defined(carboniser *destin, const carboniser *src)
{
carboniser *dest_sauvegarde=destin;
tandis que(*src! = ' 0') /* Itérer jusqu'à ce que ' ' soit trouvé.*/
{
*destin= *src; /* Copier le caractère source vers la destination */
src++ ; /* Incrémenter le pointeur source */
destin++ ; /* Incrémenter le pointeur de destination */
}
*destin= ' 0'; /* Insérer ' ' dans la destination explicitement*/
revenirdest_sauvegarde;
}
entierprincipale()
{
carboniserchaîne_source[] = 'www.linuxhint.com';
carboniserchaîne_destination[30];
imprimer ('Avant d'appeler la fonction de copie de chaîne définie par l'utilisateur : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
/* Appel de la fonction de copie de chaîne définie par l'utilisateur */
strcpy_user_defined(chaîne_destination,chaîne_source);
imprimer ('Après avoir exécuté la fonction de copie de chaîne définie par l'utilisateur : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
revenir 0;
}
strcpy () - Version définie par l'utilisateur optimisée (exemple6.c):
Maintenant, dans cet exemple de programme, nous allons optimiser la version définie par l'utilisateur de strcpy().
#comprendrecarboniser *strcpy_user_defined(carboniser *destin, const carboniser *src);
/* Version optimisée de la fonction strcpy() définie par l'utilisateur */
carboniser *strcpy_user_defined(carboniser *destin, const carboniser *src)
{
carboniser *dest_sauvegarde=destin;
tandis que(*destin++ = *src++)
;
revenirdest_sauvegarde;
}
entierprincipale()
{
carboniserchaîne_source[] = 'www.linuxhint.com';
carboniserchaîne_destination[30];
imprimer ('Avant d'appeler la fonction de copie de chaîne définie par l'utilisateur : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
/* Appel de la fonction de copie de chaîne définie par l'utilisateur */
strcpy_user_defined(chaîne_destination,chaîne_source);
imprimer ('Après avoir exécuté la fonction de copie de chaîne définie par l'utilisateur : ');
imprimer (' Chaîne source = %s ',chaîne_source);
imprimer (' Chaîne de destination = %s ',chaîne_destination);
revenir 0;
}
Conclusion :
La fonction strcpy() est une fonction de bibliothèque très populaire et pratique pour effectuer l'opération de copie de chaîne dans le langage de programmation C. Ceci est principalement utilisé pour copier la chaîne d'un emplacement à un autre emplacement. Cependant, nous souhaitons réitérer le fait que la fonction strcpy() ne vérifie pas les limites du tableau de destination, ce qui pourrait conduire à un grave bogue logiciel si elle est ignorée. Il est toujours de la responsabilité du programmeur de s'assurer que le tableau de destination dispose de suffisamment d'espace pour contenir tous les caractères de la chaîne source, y compris le caractère NULL.