Die standardmäßige C-Bibliotheksfunktion, die verwendet wird, um Strings zu verketten, ist strcat().
Funktionsprototyp:
$verkohlen * strcat (str1,str2);wobei str1 die erste Zeichenfolge und str2 die zweite Zeichenfolge ist. Rückgabewert der Funktion ist der Zeiger auf den verketteten String.
Anhand eines Beispiels werden wir nun sehen, wie die Verkettung durchgeführt wird.
Beispiel 1:
$ strcat (str1,str2);wo str1 ist Bella
str2 ist Whitmann
nach Verkettung der Zeichenfolge,erste Zeichenfolge wird sein
str1 Bella Whitmann
str2 Whitmann
während string2 gleich bleibt.
Beispiel2:
$ strcat (str2,str1);wo str1 ist Bella
str2 ist Whitmann
nach Verkettung der Zeichenfolge,verkettete Zeichenfolge wird
str1 Bella
str2 Bella Whitmann
während string1 gleich bleibt.
Deklaration in C-Header-Datei
String-Handling-Funktionen werden unter headerfile deklariert. Wenn man die Standardfunktion zum Verketten verwenden möchte, muss diese Header-Datei eingebunden werden.
Daher können wir die Stringverkettung auf zwei Arten erreichen. Eine ist mit der Verwendung der Standard-C-Bibliotheksfunktion und eine andere ohne die Verwendung der C-Bibliotheksfunktion. Im Folgenden finden Sie Beispielprogramme, um beide Möglichkeiten zu demonstrieren. Die Verkettung von Zeichenfolgen ohne Verwendung der C-Bibliotheksfunktion kann auf verschiedene Weise implementiert werden.
Auch das werden wir in den kommenden Abschnitten mit Beispielen besprechen.
Verkettung von zwei Strings mithilfe der C-Bibliotheksfunktion
#enthalten#enthalten
#define BUF_SIZE 256
inthauptsächlich()
{
verkohlenS1[BUF_SIZE],S2[BUF_SIZE]; /* Zwei String-Puffer */
druckenf ('Geben Sie die erste Zeichenfolge ein '); ] /* Nachricht an die Konsole ausgeben, damit der Benutzer die erste Zeichenfolge eingeben kann*/
fgets (S1,BUF_SIZE,stdin); /* Speichern Sie die Benutzereingabezeichenfolge im S1-Puffer */
S1[ strlen (S1)-1] = ' 0';
druckenf ('Geben Sie die zweite Zeichenfolge ein ');/* Nachricht an den Benutzer ausgeben, um die zweite Zeichenfolge einzugeben*/
fgets (S2,BUF_SIZE,stdin); /* Speichern Sie die Benutzereingabezeichenfolge im S2-Puffer */
S2[ strlen (S2)-1] = ' 0';
strcat (S1,S2); /*Standardfunktion mit S1- und S2-Strings aufrufen */
druckenf (' Verketteter String ist %s ',S1); /*Ausgabe : S1 wird mit S2 angehängt */
Rückkehr 0;
}
Momentaufnahmen des Programms und der Ausgabe:
Verkettung von zwei Strings ohne Verwendung der Bibliotheksfunktion
Verwenden der for-Schleife, um den zweiten String am Ende des ersten Strings zu kopieren.
#enthalten#enthalten
#define BUF_SIZE 256
inthauptsächlich()
{
verkohlenS1[BUF_SIZE],S2[BUF_SIZE]; /* Deklarieren Sie die Puffer S1, S2 für beide Strings*/
intLänge= 0,ich,J; /*Variablen für Schleifendurchquerung benötigt*/
druckenf ('Geben Sie die erste Zeichenfolge ein'); /* Benutzernachricht ausgeben, um die erste Zeichenfolge einzugeben */
fgets (S1,BUF_SIZE,stdin); /* Benutzereingabestring wird in S1 gespeichert*/
S1[ strlen (S1)-1] = ' 0';
druckenf ('Geben Sie die zweite Zeichenfolge ein'); /* Benutzernachricht ausgeben, um die zweite Zeichenfolge einzugeben */
fgets (S2,BUF_SIZE,stdin); /* Benutzereingabestring wird in S2 gespeichert*/
S2[ strlen (S2)-1] = ' 0';
/* Erste Zeichenkette durchlaufen, um die Länge von S1 zu finden*/
zum(ich=0;S1[ich]! =' 0';ich++)
{
Länge=Länge+1;
}
/*Länge wird das Ende von S1 haben, von Länge beginnen und das ganze S2 in S1 kopieren*/
zum(ich=Länge,J=0;S2[J]! =' 0';ich++,J++)
{
S1[ich]=S2[J];
S1[ich]=' 0';
}
/*Drucken Sie das S1 , verkettete Ergebnis */
druckenf (' Verketteter String ist %s ',S1);
Rückkehr 0;
}
Momentaufnahmen des Programms und der Ausgabe:
Eine andere Möglichkeit ohne Bibliotheksfunktion
Verkettung mit Rekursion:
Die Funktion stringconcatenate() wird verwendet, um die Länge von string1 zu ermitteln. Wenn S2 leer ist, wird S2 ein Nullzeichen zugewiesen.
Wenn S2 kein Nullzeichen zugewiesen wird, als Element von S2 am Ende von S1 hinzufügen, das heißt S1[i+j]=S2[j], erhöht dies den Wert von i in der Zeichenfolge.
Eine Funktion wird selbst aufgerufen, indem die reformierten Strings (S1, S2) als Argument übergeben werden. Es wird immer wieder aufgerufen, bis der S2 leer ist.
Das verkettete S1 wird von main() als . ausgegeben
#enthalten#enthalten
#define BUF_SIZE 256
/* rekursive Funktion zum Implementieren der Stringverkettung gemäß obiger Beschreibung */
LeereStringkonkatenat(verkohlen *S1,verkohlen *S2)
{
statisch intich=0;
statisch intJ;
J= strlen (S1);
wenn(!S2[ich])
{
S2[ich]=' 0';
}
anders
{
S1[J] =S2[ich];
S1[J+1] = ' 0';
ich++;
Stringkonkatenat(S1,S2);
}
}
inthauptsächlich()
{
verkohlenS1[BUF_SIZE],S2[BUF_SIZE];
druckenf ('Geben Sie den Wert der ersten Zeichenfolge ein:'); /* Benutzernachricht zur Eingabe der ersten Zeichenfolge */
fgets (S1,BUF_SIZE,stdin); /* Benutzereingabe erste Zeichenfolge, in S1 speichern */
S1[ strlen (S1)-1] = ' 0';
druckenf ('Geben Sie den Wert des zweiten Strings ein:'); /* Benutzernachricht zur Eingabe der zweiten Zeichenfolge */
fgets (S2,BUF_SIZE,stdin); /* Benutzereingabe erste Zeichenfolge, in S2 speichern */
S2[ strlen (S2)-1] = ' 0';
Stringkonkatenat(S1,S2); /* Aufruf der Funktion mit S1,S2 als Parameter */
druckenf ('Kombination von Zeichenfolgen ='%s' ',S1);
Rückkehr 0;
}
Momentaufnahmen des Programms und der Ausgabe:
Verkettung durch Verwendung von Funktionen
Die Funktion strconcetenate() wird von main() aufgerufen, um zwei Strings zu kombinieren.
Die Funktion erhält die Länge von string1 mithilfe von stringlen(string1).
Verbinden Sie die Elemente von string2[i] in string1[i+j]. Dieser Schritt wird wiederholt, bis die Zeichenfolge leer ist. Hier fügen wir string2 am Ende von string1 an string1 an.
Die verkettete Zeichenfolge (Zeichenfolge 1) wird am Ende empfangen, wenn alle Iterationen der for-Schleife ausgeführt werden.
main() druckt den verketteten String S1
#enthalten#enthalten
#define BUF_SIZE 256
/* Funktion zum Implementieren der Stringverkettung gemäß obiger Beschreibung */
Leerestrkonkatenat(verkohlen *Zeichenfolge1, verkohlen*Schnur2)
{
intich;
intJ= strlen (Zeichenfolge1);
zum(ich=0;Schnur2[ich];ich++)
{
Zeichenfolge1[ich+J]=Schnur2[ich];
}
Zeichenfolge1[ich+J]= ' 0';
}
inthauptsächlich()
{
verkohlenZeichenfolge1[BUF_SIZE],Schnur2[BUF_SIZE];
druckenf ('Geben Sie die erste Zeichenfolge ein:'); /* Benutzernachricht für 1. String */
fgets (Zeichenfolge1,BUF_SIZE,stdin); /* Benutzereingabe zweiter String , gespeichert in string1 */
Zeichenfolge1[ strlen (Zeichenfolge1)-1] = ' 0';
druckenf ('Geben Sie die zweite Zeichenfolge ein:'); /* Benutzernachricht für 2. String */
fgets (Schnur2,BUF_SIZE,stdin); /* Benutzereingabe zweiter String , gespeichert in string2 */
Schnur2[ strlen (Schnur2)-1] = ' 0';
strkonkatenat(Zeichenfolge1,Schnur2); /* Rufen Sie die Funktion mit string1 und string2 als Argumente auf*/
druckenf ('Resultierende Zeichenfolge = %s' ',Zeichenfolge1);
Rückkehr 0;
}
Momentaufnahmen des Programms und der Ausgabe:
String-Verkettung mit memcpy
Mit der Funktion memcpy() wird die Verkettung von Strings durchgeführt, indem Wort für Wort von einem String-Puffer an das Ende eines anderen String-Puffers kopiert wird, wobei die Wortgröße 4 Byte beträgt, wenn man bedenkt, dass wir auf einem 32-Bit-Rechner laufen, während wir die String-Verkettung durch Verwenden der String-Verkettung Mit der Funktion strcat() wird die Verkettung durch Kopieren von Byte für Byte von einem String-Puffer in einen anderen String-Puffer durchgeführt.
Dieser Ansatz ist leistungseffizient.
Die einzige Überlegung bei der Verwendung von memcpy ist, auf ‚ ‘ zu achten.
C-Programm, um die Strcat mit memcpy zu erreichen:
#enthalten#enthalten
#define BUF_SIZE 256
Leere strcat_memcpy(verkohlen *S1, verkohlen *S2)
{
intLänge1,Länge2;
Länge1= strlen (S1);
Länge2= strlen (S2);
memcpy (S1+Länge1,S2,Länge2);
}
inthauptsächlich()
{
verkohlenZeichenfolge1[BUF_SIZE],Schnur2[BUF_SIZE];
druckenf ('Geben Sie die erste Zeichenfolge ein:'); /* Benutzernachricht für 1. String */
fgets (Zeichenfolge1,BUF_SIZE,stdin); /* Benutzereingabe zweiter String , gespeichert in string1 */
Zeichenfolge1[ strlen (Zeichenfolge1)-1] = ' 0';
druckenf ('Geben Sie die zweite Zeichenfolge ein:'); /* Benutzernachricht für 2. String */
fgets (Schnur2,BUF_SIZE,stdin); /* Benutzereingabe zweiter String , gespeichert in string2 */
Schnur2[ strlen (Schnur2)-1] = ' 0';
strcat_memcpy(Zeichenfolge1,Schnur2); /* Rufen Sie die Funktion mit string1 und string2 als Argumente auf*/
druckenf ('Resultierende Zeichenfolge = %s' ',Zeichenfolge1);
Rückkehr 0;
}
Momentaufnahmen des Programms und der Ausgabe:
Abschluss:
Mit all dieser Diskussion können wir die String-Verkettung in C abschließen. Wir haben viele Beispiele und Beispielprogramme für die String-Verkettung gesehen. Wir erinnern uns an die wichtigsten Punkte: Es gibt zwei Möglichkeiten, eine mit C-Standard und eine andere benutzerdefiniert. Benutzerdefiniert kann außerdem viele Typen haben, abhängig davon, wie der Benutzer die Stringverkettung implementieren möchte.