C String -Verkettung
Die Standard -C -Bibliotheksfunktion, die zur Verkettung von String verwendet wird, ist strcat ().
Funktionsprototyp:
$ char *strcat (str1, str2);wobei Str1 erster String und Str2 ist zweiter Zeichenfolge ist. Der Rückgabewert der Funktion ist der Zeiger auf die verkettete Zeichenfolge.
Mit Hilfe von Beispiel werden wir nun sehen, wie die Verkettung durchgeführt wird.
Beispiel 1:
$ strcat (str1, str2);wo Str1 "Bella" ist
STR2 ist "Whitmann"
Nach der Verkettung der String wird der erste String sein
STR1 "Bella Whitmann"
STR2 "Whitmann"
während String2 gleich bleibt.
Beispiel2:
$ strcat (str2, str1);wo Str1 "Bella" ist
STR2 ist "Whitmann"
Nach der Verkettung der String wird eine verkettete Zeichenfolge sein
STR1 "Bella"
STR2 "Bella Whitmann"
während String1 gleich bleibt.
Deklaration in der C -Header -Datei
Die Fachfunktionen der String werden unter Headerfile deklariert. Wenn man die Standardfunktion zur Verkettung verwenden möchte, muss diese Header -Datei enthalten sein.
Daher können wir auf zwei Arten eine String -Verkettung erreichen. Einer ist mit der Verwendung der Standard -C -Bibliotheksfunktion und anderer ohne Verwendung der C -Bibliotheksfunktion. Im Folgenden finden Sie Beispielprogramme, um beide Wege zu demonstrieren. String -Verkettung ohne Verwendung von C -Bibliotheksfunktion kann auf verschiedene Weise implementiert werden.
Wir werden dies auch in den kommenden Abschnitten mit Beispiels erörtern.
Verkettung von zwei Zeichenfolgen unter Verwendung der C -Bibliotheksfunktion
#enthalten#enthalten
#define buf_size 256
int main ()
char s1 [buf_size], s2 [buf_size]; / * Zwei String -Puffer *//
printf ("die erste Zeichenfolge \ n" eingeben); ] /* Meldung an die Konsole drucken, damit der Benutzer 1. Zeichenfolge eingibt* /
fGets (S1, buf_size, stdin); / * Speichern Sie die Benutzereingangszeichenfolge in S1 -Puffer */
S1 [strlen (s1) -1] = '\ 0';
printf ("Die zweite Zeichenfolge \ n eingeben");/* Drucken Sie die Nachricht an den Benutzer, um die 2. Zeichenfolge einzugeben*/
fGets (S2, buf_size, stdin); / * Speichern Sie die Benutzereingangszeichenfolge in S2 -Puffer */
S2 [strlen (s2) -1] = '\ 0';
Strcat (S1, S2); / *Rufen Sie die Standardfunktion mit S1- und S2 -Saiten auf */
printf ("\ n verkettete String ist %s \ n \ n", S1); / *Ausgabe: S1 wird mit S2 */angehängt
Rückkehr 0;
Schnappschüsse des Programms und der Ausgabe:
Verkettung von zwei Zeichenfolgen ohne Verwendung der Bibliotheksfunktion
Verwenden Sie "für" Schleifen, um die zweite Zeichenfolge am Ende der ersten Zeichenfolge zu kopieren.
#enthalten#enthalten
#define buf_size 256
int main ()
char s1 [buf_size], s2 [buf_size]; /* Deklarieren Sie die Puffer S1, S2 für beide Zeichenfolge*/
int länge = 0, i, j; /*Variablen, die für die Schleifentraversal benötigt werden*/
printf ("die erste Zeichenfolge eingeben"); / * Benutzernachricht drucken, um die erste Zeichenfolge einzugeben */
fGets (S1, buf_size, stdin); /* Benutzereingangszeichenfolge wird in S1*/gespeichert
S1 [strlen (s1) -1] = '\ 0';
printf ("die zweite Zeichenfolge eingeben"); / * Benutzernachricht drucken, um die zweite Zeichenfolge einzugeben */
fGets (S2, buf_size, stdin); /* Benutzereingangszeichenfolge wird in S2*/gespeichert
S2 [strlen (s2) -1] = '\ 0';
/* TRAVERSE ERSTE SIND, um die Länge von S1*/zu finden
für (i = 0; S1 [i]!= '\ 0'; i ++)
Länge = Länge+1;
/*Die Länge hat das Ende des S1, beginnt von der Länge und kopiert den gesamten S2 in S1*/
für (i = Länge, j = 0; S2 [j]!= '\ 0'; i ++, J ++)
S1 [i] = S2 [j];
S1 [i] = '\ 0';
/ *Drucken Sie den S1, verkettiertes Ergebnis */
printf ("\ n verkettete String ist %s \ n \ n", S1);
Rückkehr 0;
Schnappschüsse des Programms und der Ausgabe:
Eine andere Möglichkeit ohne Bibliotheksfunktion
Verkettung mit Rekursion:
Die FunktionsstringConcatenate () wird verwendet, um die Länge von String1 zu erhalten. Wenn S2 leer ist, wird S2 ein Nullzeichen zugeordnet.
Wenn Nullzeichen S2 nicht zugeordnet ist, als das Element von S2 am Ende von S1 hinzuzufügen, nämlich S1 [i+j] = S2 [j], erhöht dies den Wert von I in der Zeichenfolge.
Eine Funktion wird sich durch die Übergabe der reformierten Zeichenfolgen (S1, S2) als Argument bezeichnet. Es wird immer wieder aufgerufen, bis der S2 leer ist.
Der verkettete S1 wird von main () als gedruckt
#enthalten#enthalten
#define buf_size 256
/ * rekursive Funktion zur Implementierung der String -Verkettung gemäß der obigen Beschreibung */
void StringConcatenate (char *s1, char *s2)
statische int i = 0;
statische Int J;
J = Strlen (S1);
Wenn(!S2 [i])
S2 [i] = '\ 0';
anders
S1 [j] = S2 [i];
S1 [j+1] = '\ 0';
i ++;
StringConcatenate (S1, S2);
int main ()
char s1 [buf_size], s2 [buf_size];
printf ("den Wert der ersten Zeichenfolge eingeben:"); / * Benutzernachricht zum Eingeben der 1. Zeichenfolge */
fGets (S1, buf_size, stdin); / * Benutzereingabe Erste Zeichenfolge, speichern Sie in S1 */
S1 [strlen (s1) -1] = '\ 0';
printf ("den Wert der zweiten Zeichenfolge eingeben:"); / * Benutzernachricht zum 2nd String */eingeben */
fGets (S2, buf_size, stdin); / * Benutzereingabe Erste Zeichenfolge, speichern Sie in S2 */
S2 [strlen (s2) -1] = '\ 0';
StringConcatenate (S1, S2); / * Ruf die Funktion mit S1, S2 als Parameter */auf
printf ("Kombination von Strings = '%s' \ n", S1);
Rückkehr 0;
Schnappschüsse des Programms und der Ausgabe:
Verkettung durch Verwendung von Funktionen
Die Funktion strconcatenate () wird vom Main () aufgerufen, um zwei Zeichenfolgen zu kombinieren.
Die Funktion erhält die Länge von String1 mithilfe von StringLen (String1).
An die Elemente von String2 [i] in String1 [i+j] angrenzen. Dieser Schritt wird wiederholt, bis die Zeichenfolge leer ist. Hier enden wir am Ende von String1 an String2 an String1.
Die verkettete Zeichenfolge (Zeichenfolge 1) wird am Ende empfangen, wenn alle Iterationen von für die Schleife durchgeführt werden.
Der Main () druckt die verkettete String S1
#enthalten#enthalten
#define buf_size 256
/ * Funktion zum Implementieren der String -Verkettung gemäß der obigen Beschreibung */
void strconcatenate (char *string1, char *string2)
int i;
int j = strlen (String1);
für (i = 0; String 2 [i]; i ++)
String1 [i+j] = string2 [i];
String1 [i+j] = '\ 0';
int main ()
char string1 [buf_size], string2 [buf_size];
printf ("die erste Zeichenfolge eingeben:"); / * Benutzernachricht für 1. Zeichenfolge */
fGets (string1, buf_size, stdin); / * Benutzereingabe zweite Zeichenfolge, in String1 */gespeichert
String1 [strlen (string1) -1] = '\ 0';
printf ("die zweite Zeichenfolge eingeben:"); / * Benutzernachricht für die 2. Zeichenfolge */
fGets (string2, buf_size, stdin); / * Benutzereingabe zweite Zeichenfolge, in String2 */gespeichert
String2 [strlen (string2) -1] = '\ 0';
StrConcatenate (String1, String2); /* Rufen Sie die Funktion mit String1 und String2 als Argumente auf*/
printf ("resultant String = %s '\ n", String1);
Rückkehr 0;
Schnappschüsse des Programms und der Ausgabe:
String -Verkettung mit Memcpy
Durch die Verwendung von Memcpy () -Funktion erfolgt die Verkettung der String durch Kopieren von Wort nach Wort von einem Stringpuffer bis zum Ende eines anderen String -Puffer Verwenden der String -Verkettung mithilfe der Funktion von Strcat () erfolgt die Verkettung durch Kopieren von Byte durch Byte von einem String -Puffer zu einem anderen String -Puffer.
Dieser Ansatz ist effizientem Leistung.
Die einzige Überlegung bei der Verwendung von memcpy besteht darin, sich um '\ 0' zu kümmern.
C -Programm, um die STRCAT mit Memcpy zu erreichen:
#enthalten#enthalten
#define buf_size 256
Void strcat_memcpy (char *s1, char *s2)
int Länge1, Länge2;
Länge1 = Strlen (S1);
Länge2 = Strlen (S2);
memcpy (S1+Länge1, S2, Länge2);
int main ()
char string1 [buf_size], string2 [buf_size];
printf ("die erste Zeichenfolge eingeben:"); / * Benutzernachricht für 1. Zeichenfolge */
fGets (string1, buf_size, stdin); / * Benutzereingabe zweite Zeichenfolge, in String1 */gespeichert
String1 [strlen (string1) -1] = '\ 0';
printf ("die zweite Zeichenfolge eingeben:"); / * Benutzernachricht für die 2. Zeichenfolge */
fGets (string2, buf_size, stdin); / * Benutzereingabe zweite Zeichenfolge, in String2 */gespeichert
String2 [strlen (string2) -1] = '\ 0';
Strcat_Memcpy (String1, String2); /* Rufen Sie die Funktion mit String1 und String2 als Argumente auf*/
printf ("resultant String = %s '\ n", String1);
Rückkehr 0;
Schnappschüsse 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 werden uns an die Hauptelemente erinnern: Es gibt zwei Möglichkeiten, eine mit C -Standard und andere ist benutzerdefinierter Weg. Benutzer definiert kann weiter von vielen Typen sein, hängt davon ab, wie der Benutzer String -Verkettung implementieren möchte.