La fonction de bibliothèque C standard qui est utilisée pour concaténer une chaîne est strcat().
Prototype de fonction :
$carboniser * strcat (str1,str2);où str1 est la première chaîne et str2 est la deuxième chaîne. La valeur de retour de la fonction est le pointeur vers la chaîne concaténée.
Maintenant, à l'aide d'exemples, nous allons voir comment s'effectue la concaténation.
Exemple 1:
$ strcat (str1,str2);où str1 est Bella
str2 est Whitmann
après concaténation de chaîne,la première chaîne sera
str1 Bella Whitmann
str2 Whitmann
tandis que string2 restera le même.
Exemple 2 :
$ strcat (str2,str1);où str1 est Bella
str2 est Whitmann
après concaténation de chaîne,la chaîne concaténée sera
str1 Bella
str2 Bella Whitmann
tandis que string1 restera le même.
Déclaration dans le fichier d'en-tête C
Les fonctions de gestion des chaînes sont déclarées sous le fichier d'en-tête. Si l'on veut utiliser la fonction standard pour concaténer, ce fichier d'en-tête doit être inclus.
Par conséquent, nous pouvons réaliser la concaténation de chaînes de deux manières. L'un consiste à utiliser la fonction de bibliothèque C standard et l'autre sans utiliser la fonction de bibliothèque C. Voici des exemples de programmes pour démontrer les deux manières. La concaténation de chaînes sans utiliser la fonction de bibliothèque C peut être implémentée de plusieurs manières.
Nous en discuterons également dans les prochaines sections avec des exemples.
Concaténation de deux chaînes à l'aide de la fonction de bibliothèque C
#comprendre#comprendre
#define BUF_SIZE 256
entierprincipale()
{
carboniserS1[BUF_SIZE],S2[BUF_SIZE]; /* Deux tampons de chaîne */
imprimer ('Entrez la première chaîne '); ] /* Affiche un message sur la console pour que l'utilisateur saisisse la 1ère chaîne*/
fgets (S1,BUF_SIZE,standard); /* stocker la chaîne d'entrée utilisateur dans le tampon S1 */
S1[ stren (S1)-1] = ' 0';
imprimer ('Entrez la deuxième chaîne ');/* Imprimer le message à l'utilisateur pour saisir la 2ème chaîne*/
fgets (S2,BUF_SIZE,standard); /* stocker la chaîne d'entrée utilisateur dans le tampon S2 */
S2[ stren (S2)-1] = ' 0';
strcat (S1,S2); /*Appelle la fonction standard avec les chaînes S1 et S2 */
imprimer (' La chaîne concaténée est %s ',S1); /*Sortie : S1 est ajouté à S2 */
revenir 0;
}
Instantanés du programme et de la sortie :
Concaténation de deux chaînes sans utiliser la fonction de bibliothèque
Utilisation de la boucle for pour copier la deuxième chaîne à la fin de la première chaîne.
#comprendre#comprendre
#define BUF_SIZE 256
entierprincipale()
{
carboniserS1[BUF_SIZE],S2[BUF_SIZE]; /* Déclare les buffers S1, S2 pour la chaîne*/
entierlongueur= 0,je,j; /*Variables nécessaires pour le parcours de la boucle*/
imprimer ('Entrez la première chaîne'); /* Imprimer le message utilisateur pour saisir la première chaîne */
fgets (S1,BUF_SIZE,standard); /* la chaîne d'entrée utilisateur sera stockée dans S1*/
S1[ stren (S1)-1] = ' 0';
imprimer ('Entrez la deuxième chaîne'); /* Imprimer le message utilisateur pour saisir la deuxième chaîne */
fgets (S2,BUF_SIZE,standard); /* la chaîne d'entrée utilisateur sera stockée dans S2*/
S2[ stren (S2)-1] = ' 0';
/* Parcourt la première chaîne pour trouver la longueur de S1*/
pour(je=0;S1[je]! =' 0';je++)
{
longueur=longueur+1;
}
/*length aura la fin du S1, commencer à partir de length et copier le S2 entier dans S1*/
pour(je=longueur,j=0;S2[j]! =' 0';je++,j++)
{
S1[je]=S2[j];
S1[je]=' 0';
}
/*Imprime le S1 , résultat concaténé */
imprimer (' La chaîne concaténée est %s ',S1);
revenir 0;
}
Instantanés du programme et de la sortie :
Une autre façon de sans fonction de bibliothèque
Concaténation par récursivité :
La fonction stringconcatenate() sera utilisée pour obtenir la longueur de string1. Si S2 est vide, alors un caractère nul sera attribué à S2.
Si le caractère nul n'est pas affecté à S2 alors ajoutez l'élément de S2 à la fin de S1 qui est S1[i+j]=S2[j], cela augmente la valeur de i dans la chaîne.
Une fonction s'appellera elle-même en passant les chaînes reformées (S1,S2) comme argument. Il sera appelé encore et encore jusqu'à ce que le S2 soit vide.
Le S1 concaténé sera imprimé par main() comme
#comprendre#comprendre
#define BUF_SIZE 256
/* fonction récursive pour implémenter la concaténation de chaînes selon la description ci-dessus */
annulerchaîneconcaténer(carboniser *S1,carboniser *S2)
{
statique entierje=0;
statique entierj;
j= stren (S1);
si(!S2[je])
{
S2[je]=' 0';
}
autre
{
S1[j] =S2[je];
S1[j+1] = ' 0';
je++ ;
chaîneconcaténer(S1,S2);
}
}
entierprincipale()
{
carboniserS1[BUF_SIZE],S2[BUF_SIZE];
imprimer ('Entrez la valeur de la première chaîne :'); /* message utilisateur pour saisir la 1ère chaîne */
fgets (S1,BUF_SIZE,standard); /* l'utilisateur saisit la première chaîne, stockée dans S1 */
S1[ stren (S1)-1] = ' 0';
imprimer ('Entrez la valeur de la deuxième chaîne :'); /* message utilisateur pour saisir la 2ème chaîne */
fgets (S2,BUF_SIZE,standard); /* l'utilisateur saisit la première chaîne, stockée dans S2 */
S2[ stren (S2)-1] = ' 0';
chaîneconcaténer(S1,S2); /* Appeler la fonction avec S1,S2 comme paramètres */
imprimer ('combinaison de chaînes ='%s' ',S1);
revenir 0;
}
Instantanés du programme et de la sortie :
Concaténation à l'aide de fonctions
La fonction strconcatenate() est appelée par main() pour combiner deux chaînes.
La fonction obtient la longueur de string1 en utilisant stringlen(string1).
Adjoignez les éléments de string2[i] dans string1[i+j]. Cette étape sera répétée jusqu'à ce que la chaîne soit vide. Ici, nous joignons la chaîne2 à la chaîne1 à la fin de la chaîne1.
La chaîne concaténée (chaîne 1) sera reçue à la fin lorsque toutes les itérations de la boucle for seront effectuées.
Le main() imprime la chaîne concaténée S1
#comprendre#comprendre
#define BUF_SIZE 256
/* fonction pour implémenter la concaténation de chaînes selon la description ci-dessus */
annulerconcaténer(carboniser *chaîne1, carboniser*chaîne2)
{
entierje;
entierj= stren (chaîne1);
pour(je=0;chaîne de caractères2[je];je++)
{
chaîne1[je+j]=chaîne2[je];
}
chaîne1[je+j]= ' 0';
}
entierprincipale()
{
carboniserchaîne1[BUF_SIZE],chaîne2[BUF_SIZE];
imprimer ('Entrez la première chaîne :'); /* Message utilisateur pour la 1ère chaîne */
fgets (chaîne1,BUF_SIZE,standard); /* L'utilisateur saisit la deuxième chaîne, stockée dans string1 */
chaîne1[ stren (chaîne1)-1] = ' 0';
imprimer ('Entrez la deuxième chaîne :'); /* Message utilisateur pour la 2ème chaîne */
fgets (chaîne2,BUF_SIZE,standard); /* L'utilisateur saisit la deuxième chaîne, stockée dans string2 */
chaîne2[ stren (chaîne2)-1] = ' 0';
concaténer(chaîne1,chaîne2); /* Appeler la fonction avec string1 et string2 comme arguments*/
imprimer ('Chaîne résultante = %s' ',chaîne1);
revenir 0;
}
Instantanés du programme et de la sortie :
Concaténation de chaînes à l'aide de memcpy
En utilisant la fonction memcpy(), la concaténation de la chaîne se fait en copiant mot par mot d'un tampon de chaîne à la fin d'un autre tampon de chaîne où la taille du mot est de 4 octets étant donné que nous fonctionnons sur une machine 32 bits tandis que lorsque nous faisons la concaténation de chaîne par en utilisant la concaténation de chaînes en utilisant la fonction strcat(), la concaténation est effectuée en copiant octet par octet d'un tampon de chaîne à un autre tampon de chaîne.
Cette approche est efficace en termes de performances.
La seule considération lors de l'utilisation de memcpy est de prendre soin de ' '.
Programme C pour obtenir le strcat avec memcpy :
#comprendre#comprendre
#define BUF_SIZE 256
Vide strcat_memcpy(carboniser *S1, carboniser *S2)
{
entierlongueur1,longueur2;
longueur1= stren (S1);
longueur2= stren (S2);
memcpy (S1+longueur1,S2,longueur2);
}
entierprincipale()
{
carboniserchaîne1[BUF_SIZE],chaîne2[BUF_SIZE];
imprimer ('Entrez la première chaîne :'); /* Message utilisateur pour la 1ère chaîne */
fgets (chaîne1,BUF_SIZE,standard); /* L'utilisateur saisit la deuxième chaîne, stockée dans string1 */
chaîne1[ stren (chaîne1)-1] = ' 0';
imprimer ('Entrez la deuxième chaîne :'); /* Message utilisateur pour la 2ème chaîne */
fgets (chaîne2,BUF_SIZE,standard); /* L'utilisateur saisit la deuxième chaîne, stockée dans string2 */
chaîne2[ stren (chaîne2)-1] = ' 0';
strcat_memcpy(chaîne1,chaîne2); /* Appeler la fonction avec string1 et string2 comme arguments*/
imprimer ('Chaîne résultante = %s' ',chaîne1);
revenir 0;
}
Instantanés du programme et de la sortie :
Conclusion:
Avec toute cette discussion, nous pouvons conclure la concaténation de chaînes en C. Nous avons vu de nombreux exemples et exemples de programmes pour la concaténation de chaînes. Nous rappellerons les principaux éléments : Il existe deux manières, l'une avec la norme C et l'autre est définie par l'utilisateur. La définition par l'utilisateur peut en outre être de plusieurs types, selon la manière dont l'utilisateur souhaite implémenter la concaténation de chaînes.