C Concaténation des cordes
La fonction de bibliothèque standard C qui est utilisée pour concaténer la chaîne est strcat ().
Prototype de fonction:
$ char * 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, avec l'aide de l'exemple, nous verrons comment la concaténation est effectuée.
Exemple 1:
$ strcat (Str1, Str2);où Str1 est «Bella»
STR2 est «Whitmann»
Après la concaténation de la chaîne, la première chaîne sera
Str1 "Bella Whitmann"
str2 «Whitmann»
tandis que String2 restera le même.
Exemple2:
$ strcat (str2, str1);où Str1 est «Bella»
STR2 est «Whitmann»
Après la concaténation de la corde, 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 traitement des chaînes sont déclarées sous lefile 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 atteindre la concaténation des cordes de deux manières. L'une consiste à utiliser la fonction standard C de la bibliothèque et l'autre sans utiliser la fonction de bibliothèque C. Voici des exemples de programmes pour démontrer les deux moyens. La concaténation des cordes sans utiliser la fonction de bibliothèque C peut être implémentée de plusieurs manières.
Nous en discuterons également dans les sections à venir avec exemple.
Concaténation de deux chaînes en utilisant la fonction de bibliothèque C
#inclure#inclure
#define buf_size 256
int main()
char s1 [buf_size], s2 [buf_size]; / * Deux tampons de chaîne * /
printf ("Entrez la première chaîne \ n"); ] / * Imprimez le message à la console pour que l'utilisateur puisse saisir la 1ère chaîne * /
fgets (s1, buf_size, stdin); / * Stockez la chaîne d'entrée utilisateur dans le tampon S1 * /
S1 [strlen (s1) -1] = '\ 0';
printf ("Entrez la deuxième chaîne \ n"); / * Imprimez le message à l'utilisateur pour saisir la 2ème chaîne * /
fgets (s2, buf_size, stdin); / * Stockez la chaîne d'entrée utilisateur dans le tampon S2 * /
S2 [strlen (s2) -1] = '\ 0';
Strcat (S1, S2); / * Appelez la fonction standard avec les chaînes S1 et S2 * /
printf ("\ n La chaîne concaténée est% s \ n \ n", s1); / * Sortie: S1 est ajouté avec S2 * /
retour 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 «pour» pour copier la deuxième chaîne à la fin de la première chaîne.
#inclure#inclure
#define buf_size 256
int main()
char s1 [buf_size], s2 [buf_size]; / * Déclarer les tampons S1, S2 pour les deux chaînes * /
int length = 0, i, j; / * Variables nécessaires pour la traversée de boucle * /
printf ("Entrez la première chaîne"); / * Imprimez le message utilisateur pour entrer la première chaîne * /
fgets (s1, buf_size, stdin); / * La chaîne d'entrée utilisateur sera stockée dans S1 * /
S1 [strlen (s1) -1] = '\ 0';
printf ("Entrez la deuxième chaîne"); / * Imprimez le message utilisateur pour entrer la deuxième chaîne * /
fgets (s2, buf_size, stdin); / * La chaîne d'entrée utilisateur sera stockée dans S2 * /
S2 [strlen (s2) -1] = '\ 0';
/ * Traverse première chaîne pour trouver la longueur de S1 * /
pour (i = 0; s1 [i]!= '\ 0'; i ++)
longueur = longueur + 1;
/ * la longueur aura la fin du S1, commencez à partir de la longueur et copiez l'ensemble S2 dans S1 * /
pour (i = longueur, j = 0; s2 [j]!= '\ 0'; i ++, j ++)
S1 [i] = S2 [J];
S1 [i] = '\ 0';
/ * Imprimez le S1, Résultat concaténé * /
printf ("\ n La chaîne concaténée est% s \ n \ n", s1);
retour 0;
Instantanés du programme et de la sortie:
Une autre façon de sans fonction de bibliothèque
Concaténation à l'aide de la récursivité:
La fonction StringConCatenate () sera utilisée pour obtenir la longueur de String1. Si S2 est vide, un caractère nul sera affecté à S2.
Si le caractère nul n'est pas affecté à S2 que sur 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 sera appelée elle-même en passant les cordes réformé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
#inclure#inclure
#define buf_size 256
/ * fonction récursive pour implémenter la concaténation des chaînes selon la description ci-dessus * /
void StringConCatenate (char * s1, char * s2)
statique int i = 0;
statique Int J;
j = strlen (s1);
si(!S2 [i])
S2 [i] = '\ 0';
autre
S1 [J] = S2 [i];
S1 [J + 1] = '\ 0';
i ++;
StringConCatenate (S1, S2);
int main()
char s1 [buf_size], s2 [buf_size];
printf ("Entrez la valeur de la première chaîne:"); / * Message utilisateur pour saisir la 1ère chaîne * /
fgets (s1, buf_size, stdin); / * Entrée utilisateur première chaîne, stocker en s1 * /
S1 [strlen (s1) -1] = '\ 0';
printf ("Entrez la valeur de la deuxième chaîne:"); / * Message utilisateur pour saisir la 2ème chaîne * /
fgets (s2, buf_size, stdin); / * Entrée utilisateur première chaîne, stocker en s2 * /
S2 [strlen (s2) -1] = '\ 0';
StringConCatenate (S1, S2); / * Appelez la fonction avec S1, S2 comme paramètres * /
printf ("combinaison de cordes = '% s' \ n", s1);
retour 0;
Instantanés du programme et de la sortie:
Concaténation en utilisant des fonctions
La fonction strConcatenate () est appelée par le main () pour combiner deux cordes.
La fonction obtient la longueur de String1 en utilisant Stringlen (String1).
Adjointe 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 jouons à la chaîne2 à string1 à la fin de String1.
La chaîne concaténée (chaîne 1) sera reçue d'ici la fin lorsque toutes les itérations de la boucle seront effectuées.
Le main () imprime la chaîne concaténée S1
#inclure#inclure
#define buf_size 256
/ * Fonction pour implémenter la concaténation des chaînes selon la description ci-dessus * /
void strConcatenate (char * string1, char * string2)
int i;
int j = strlen (string1);
pour (i = 0; chaîne 2 [i]; i ++)
String1 [i + j] = string2 [i];
String1 [i + j] = '\ 0';
int main()
char String1 [buf_size], string2 [buf_size];
printf ("Entrez la première chaîne:"); / * Message utilisateur pour la 1ère chaîne * /
fgets (string1, buf_size, stdin); / * Entrée utilisateur Deuxième chaîne, stockée dans String1 * /
String1 [strlen (string1) -1] = '\ 0';
printf ("Entrez la deuxième chaîne:"); / * Message utilisateur pour 2e chaîne * /
fgets (string2, buf_size, stdin); / * Entrée utilisateur Deuxième chaîne, stockée dans String2 * /
String2 [strlen (string2) -1] = '\ 0';
strConCatenate (String1, String2); / * Appelez la fonction avec String1 et String2 comme arguments * /
printf ("string résultat =% s '\ n", string1);
retour 0;
Instantanés du programme et de la sortie:
Concaténation de cordes en utilisant memcpy
En utilisant la fonction memcpy (), la concaténation de la chaîne est effectuée 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 pendant que nous faisons la concaténation de la chaîne par la concaténation par la string par la concaténation par la string par la concaténation par la string par la concaténation par la string par la concaténation par la concaténation par la chaîne par la concaténation par la chaîne par la concaténation par la string par la concaténation par la chaîne par la concaténation par la string par la concaténation par la corde par En utilisant la concaténation de chaîne en utilisant la fonction strcat (), la concaténation se fait en copiant l'octet par octet d'un tampon de chaîne à un autre tampon de chaîne.
Cette approche est efficace aux performances.
La seule considération lors de l'utilisation de MEMCPY est de prendre soin de '\ 0'.
C Programme pour réaliser le strcat avec memcpy:
#inclure#inclure
#define buf_size 256
Void strcat_memcpy (char * s1, char * s2)
int length1, longueur2;
length1 = strlen (s1);
length2 = strlen (s2);
memcpy (s1 + longueur1, s2, longueur2);
int main()
char String1 [buf_size], string2 [buf_size];
printf ("Entrez la première chaîne:"); / * Message utilisateur pour la 1ère chaîne * /
fgets (string1, buf_size, stdin); / * Entrée utilisateur Deuxième chaîne, stockée dans String1 * /
String1 [strlen (string1) -1] = '\ 0';
printf ("Entrez la deuxième chaîne:"); / * Message utilisateur pour 2e chaîne * /
fgets (string2, buf_size, stdin); / * Entrée utilisateur Deuxième chaîne, stockée dans String2 * /
String2 [strlen (string2) -1] = '\ 0';
strcat_memcpy (string1, string2); / * Appelez la fonction avec String1 et String2 comme arguments * /
printf ("string résultat =% s '\ n", string1);
retour 0;
Instantanés du programme et de la sortie:
Conclusion:
Avec toute cette discussion, nous pouvons conclure la concaténation des cordes en C. Nous avons vu de nombreux exemples et échantillons de programmes pour la concaténation des cordes. Nous nous souviendrons des éléments principaux: il y a deux façons, une avec la norme C et l'autre est une manière définie par l'utilisateur. L'utilisateur défini peut être en outre de nombreux types, dépend de la façon dont les utilisateurs souhaitent implémenter la concaténation des chaînes.