C CONTATENATION String
Standardowa funkcja biblioteki C, która jest używana do ciągnięcia ciągów jest strcat ().
Prototyp funkcji:
$ char *strcat (str1, str2);gdzie STR1 jest pierwszym ciągiem i Str2 to drugi ciąg. Wartość zwracana funkcji to wskaźnik do połączonego ciągu.
Teraz, z pomocą przykładu.
Przykład 1:
$ strcat (str1, str2);gdzie STR1 to „Bella”
STR2 to „Whitmann”
Po połączeniu ciągu, pierwszy ciąg będzie
STR1 „Bella Whitmann”
str2 „Whitmann”
podczas gdy String2 pozostanie taki sam.
Przykład 2:
$ strcat (str2, str1);gdzie STR1 to „Bella”
STR2 to „Whitmann”
Po połączeniu ciągów, połączony ciąg będzie
STR1 „Bella”
STR2 „Bella Whitmann”
podczas gdy String1 pozostanie taki sam.
Deklaracja w pliku nagłówka C
Funkcje obsługi strun są zadeklarowane pod plikami nagłówka. Jeśli ktoś chce użyć standardowej funkcji do połączenia, ten plik nagłówka musi zostać uwzględniony.
Dlatego możemy osiągnąć połączenie ciągów na dwa sposoby. Jednym z nich jest użycie standardowej funkcji biblioteki C, a druga bez użycia funkcji biblioteki C. Poniżej przedstawiono programy, aby wykazać oba sposoby. Contagenation bez korzystania z funkcji biblioteki C można zaimplementować na wiele sposobów.
Omówimy to również w nadchodzących sekcjach z przykładem.
Konatenacja dwóch ciągów za pomocą funkcji biblioteki C
#włączać#włączać
#Define BUF_SIZE 256
int main ()
char s1 [buf_size], s2 [buf_size]; / * Dwa bufory sznurków */
printf („Wprowadź pierwszy ciąg \ n”); ] /* Wydrukuj wiadomość do konsoli, aby użytkownik wprowadził 1. ciąg* /
Zmienia się (S1, buf_size, stdin); / * Przechowuj ciąg wejściowy użytkownika w buforze S1 */
S1 [strlen (s1) -1] = '\ 0';
printf („Wprowadź drugi ciąg \ n”);/* Wydrukuj komunikat użytkownika, aby wprowadzić 2. ciąg*/
Zmienia się (S2, buf_size, stdin); / * Przechowuj ciąg wejściowy użytkownika w buforze S2 */
S2 [strlen (s2) -1] = '\ 0';
strcat (s1, s2); / *Wywołaj funkcję standardową z ciągami S1 i S2 */
printf („\ n Conatenated String to %s \ n \ n”, s1); / *Wyjście: S1 zostaje dołączone do S2 */
powrót 0;
Migawki programu i wyjścia:
Konatenacja dwóch ciągów bez korzystania z funkcji biblioteki
Za pomocą pętli „for” do skopiowania drugiego ciągu na końcu pierwszego ciągu.
#włączać#włączać
#Define BUF_SIZE 256
int main ()
char s1 [buf_size], s2 [buf_size]; /* Deklaruj bufory S1, S2 dla zarówno ciągu*/
int długość = 0, i, j; /*Zmienne potrzebne do przemieszczania pętli*/
printf („Wprowadź pierwszy ciąg”); / * Wydrukuj komunikat użytkownika, aby wprowadzić pierwszy ciąg */
Zmienia się (S1, buf_size, stdin); /* ciąg wejściowy użytkownika będzie przechowywany w S1*/
S1 [strlen (s1) -1] = '\ 0';
printf („Wprowadź drugi ciąg”); / * Wydrukuj komunikat użytkownika, aby wprowadzić drugi ciąg */
Zmienia się (S2, buf_size, stdin); /* ciąg wejściowy użytkownika będzie przechowywany w S2*/
S2 [strlen (s2) -1] = '\ 0';
/* Traverse Pierwszy ciąg, aby znaleźć długość S1*/
dla (i = 0; s1 [i]!= '\ 0'; i ++)
długość = długość+1;
/*Długość będzie miała koniec S1, zacznij od długości i skopiuj cały S2 do S1*/
dla (i = długość, j = 0; s2 [j]!= '\ 0'; i ++, j ++)
S1 [i] = s2 [j];
S1 [i] = '\ 0';
/ *Wydrukuj S1, wynik skonektenowany */
printf („\ n Conatenated String to %s \ n \ n”, s1);
powrót 0;
Migawki programu i wyjścia:
Inny sposób bez funkcji biblioteki
Konatenacja za pomocą rekurencji:
Funkcja stringConcatenate () zostanie użyta do uzyskania długości String1. Jeśli S2 jest pusty, do S2 zostanie przypisany znak zerowy.
Jeśli znak zerowy nie jest przypisany do S2, niż dodaj element S2 na końcu S1, czyli S1 [i+j] = s2 [j], zwiększa to wartość i w ciągu.
Funkcja zostanie nazywana, przekazując reformowane struny (S1, S2) jako argument. Będzie powołany raz po raz, aż S2 będzie pusty.
Połączony S1 zostanie wydrukowany przez Main ()
#włączać#włączać
#Define BUF_SIZE 256
/ * Funkcja rekurencyjna w celu zaimplementowania ciągnika ciągów zgodnie z powyższym opisem */
void stringConcatenate (char *s1, char *s2)
static int i = 0;
Static int J;
j = strlen (s1);
Jeśli(!S2 [i])
S2 [i] = '\ 0';
w przeciwnym razie
S1 [j] = s2 [i];
S1 [j+1] = '\ 0';
i ++;
StringConcatenate (S1, S2);
int main ()
char s1 [buf_size], s2 [buf_size];
printf („Wprowadź wartość pierwszego ciągu:”); / * Komunikat użytkownika do wprowadzenia 1. ciągu */
Zmienia się (S1, buf_size, stdin); / * Wejście użytkownika Pierwszy ciąg, przechowuj w S1 */
S1 [strlen (s1) -1] = '\ 0';
printf („Wprowadź wartość drugiego ciągu:”); / * Komunikat użytkownika do wprowadzenia 2. ciągu */
Zmienia się (S2, buf_size, stdin); / * Wejście użytkownika Pierwszy ciąg, przechowuj w S2 */
S2 [strlen (s2) -1] = '\ 0';
StringConcatenate (S1, S2); / * Wywołać funkcję S1, S2 jako parametry */
printf („kombinacja stringów = '%s' \ n", s1);
powrót 0;
Migawki programu i wyjścia:
Połączenie za pomocą funkcji
Funkcja strconcatenate () jest nazywana przez main () w celu połączenia dwóch ciągów.
Funkcja otrzymuje długość String1 za pomocą Stringlen (String1).
Przyleganie do elementów String2 [i] w String1 [i+j]. Ten krok zostanie powtórzony, aż ciąg będzie pusty. Tutaj przylegamy do String2 do String1 na końcu String1.
Połączony ciąg (ciąg 1) zostanie odebrany do końca, gdy zostaną wykonane wszystkie iteracje pętli.
Main () drukuje połączony ciąg S1
#włączać#włączać
#Define BUF_SIZE 256
/ * funkcja wdrożenia ciągnika ciągów zgodnie z powyższym opisem */
void strconcatenate (char *string1, char *string2)
int i;
int j = strlen (string1);
dla (i = 0; ciąg 2 [i]; i ++)
String1 [i+j] = string2 [i];
String1 [i+j] = '\ 0';
int main ()
char string1 [buf_size], string2 [buf_size];
printf („Wprowadź pierwszy ciąg:”); / * Komunikat użytkownika dla pierwszego ciągu */
zwłoki (String1, buf_size, stdin); / * Wejście użytkownika Drugi ciąg, zapisany w String1 */
string1 [strlen (string1) -1] = '\ 0';
printf („Wprowadź drugi ciąg:”); / * Komunikat użytkownika dla 2. ciągu */
spłaty (String2, buf_size, stdin); / * Wejście użytkownika Drugi ciąg, zapisany w String2 */
string2 [strlen (string2) -1] = '\ 0';
strconcatenate (string1, string2); /* Wywołać funkcję String1 i String2 jako argumenty*/
printf („wynikowy ciąg = %s '\ n”, string1);
powrót 0;
Migawki programu i wyjścia:
Conceatenacja ciągów za pomocą Memcpy
Korzystając z funkcji memcpy (), połączenie łańcucha odbywa się poprzez kopiowanie słowa przez słowo z jednego bufora łańcucha do końca innego bufora łańcucha, w którym rozmiar słowa wynosi 4 bajty, biorąc pod uwagę, że działa na 32 -bitowym komputerze Korzystając z Contarenaation String za pomocą funkcji strcat (), konatenacja odbywa się poprzez kopiowanie bajtu przez bajt z jednego bufora sznurka do innego bufora sznurka.
To podejście jest wydajne.
Jedynym rozważaniem podczas korzystania z MemCPy jest dbanie o „\ 0”.
Program C do osiągnięcia Strcat z MemCPy:
#włączać#włączać
#Define BUF_SIZE 256
Void strcat_memcpy (char *s1, char *s2)
int długość 1, długość2;
długość1 = strlen (s1);
długość2 = strlen (s2);
memcpy (S1+Longe1, S2, Long2);
int main ()
char string1 [buf_size], string2 [buf_size];
printf („Wprowadź pierwszy ciąg:”); / * Komunikat użytkownika dla pierwszego ciągu */
zwłoki (String1, buf_size, stdin); / * Wejście użytkownika Drugi ciąg, zapisany w String1 */
string1 [strlen (string1) -1] = '\ 0';
printf („Wprowadź drugi ciąg:”); / * Komunikat użytkownika dla 2. ciągu */
spłaty (String2, buf_size, stdin); / * Wejście użytkownika Drugi ciąg, zapisany w String2 */
string2 [strlen (string2) -1] = '\ 0';
strcat_memcpy (string1, string2); /* Wywołać funkcję String1 i String2 jako argumenty*/
printf („wynikowy ciąg = %s '\ n”, string1);
powrót 0;
Migawki programu i wyjścia:
Wniosek:
Przy całej tej dyskusji możemy zakończyć ciąg konatenacji w C. Widzieliśmy wiele przykładów i przykładowych programów do łączenia ciągu. Przypomnimy główne elementy: istnieją dwa sposoby, jedno ze standardem C, a drugi to sposób zdefiniowany przez użytkownika. Zdefiniowany użytkownik może być ponadto wielu typów, zależy od tego, w jaki sposób użytkownik chce zaimplementować połączenie ciągów.