Standardową funkcją biblioteki C, która jest używana do łączenia łańcuchów, jest strcat().
Prototyp funkcji:
$zwęglać * strcat (str1,str2);gdzie str1 to pierwszy ciąg, a str2 to drugi ciąg. Wartość zwracana przez funkcję jest wskaźnikiem do połączonego ciągu.
Teraz za pomocą przykładu zobaczymy, jak przebiega konkatenacja.
Przykład 1:
$ strcat (str1,str2);gdzie str1 to Bella
str2 to Whitmann
po połączeniu łańcucha,pierwszy ciąg będzie
str1 Bella Whitmann
str2 Whitmann
podczas gdy string2 pozostanie taki sam.
Przykład2:
$ strcat (str2,str1);gdzie str1 to Bella
str2 to Whitmann
po połączeniu łańcucha,połączony ciąg będzie
str1 Bella
str2 Bella Whitmann
podczas gdy string1 pozostanie taki sam.
Deklaracja w pliku nagłówkowym C
Funkcje obsługi napisów są deklarowane w pliku nagłówkowym. Jeśli ktoś chce użyć standardowej funkcji do konkatenacji, ten plik nagłówkowy musi być dołączony.
W związku z tym możemy osiągnąć konkatenację ciągów na dwa sposoby. Jedna dotyczy korzystania z funkcji biblioteki Standard C, a druga bez użycia funkcji biblioteki C. Poniżej znajdują się przykładowe programy demonstrujące oba sposoby. Łączenie ciągów bez użycia funkcji z biblioteki C można zaimplementować na wiele sposobów.
Omówimy to również w kolejnych sekcjach z przykładami.
Łączenie dwóch ciągów za pomocą funkcji biblioteki C
#włączać#włączać
#define BUF_SIZE 256
intGłówny()
{
zwęglaćS1[BUF_SIZE],S2[BUF_SIZE]; /* Dwa bufory łańcuchowe */
printf ('Wprowadź pierwszy ciąg '); ] /* Wydrukuj wiadomość do konsoli, aby użytkownik mógł wprowadzić pierwszy ciąg*/
fgets (S1,BUF_SIZE,stdin); /* przechowuj ciąg znaków wejściowych użytkownika w buforze S1 */
S1[ strlen (S1)-1] = ' 0';
printf ('Wprowadź drugi ciąg ');/* Wydrukuj wiadomość do użytkownika, aby wprowadzić drugi ciąg*/
fgets (S2,BUF_SIZE,stdin); /* przechowuj ciąg znaków wejściowych użytkownika w buforze S2 */
S2[ strlen (S2)-1] = ' 0';
strcat (S1,S2); /*Wywołaj funkcję standardową z ciągami S1 i S2 */
printf (' Połączony ciąg to %s ',S1); /*Wyjście: S1 zostaje dodany do S2 */
powrót 0;
}
Migawki programu i wyjścia:
Łączenie dwóch ciągów bez użycia funkcji biblioteki
Używanie pętli for do kopiowania drugiego ciągu na końcu pierwszego ciągu.
#włączać#włączać
#define BUF_SIZE 256
intGłówny()
{
zwęglaćS1[BUF_SIZE],S2[BUF_SIZE]; /* Zadeklaruj bufory S1, S2 dla obu napisów*/
intdługość= 0,i,J; /*Zmienne potrzebne do przechodzenia w pętli*/
printf („Wprowadź pierwszy ciąg”); /* Wydrukuj wiadomość użytkownika, aby wprowadzić pierwszy ciąg */
fgets (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 wiadomość użytkownika, aby wprowadzić drugi ciąg */
fgets (S2,BUF_SIZE,stdin); /* ciąg wejściowy użytkownika będzie przechowywany w S2*/
S2[ strlen (S2)-1] = ' 0';
/* Przemierz 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łe S2 do S1*/
dla(i=długość,J=0;S2[J]! =' 0';i++,J++)
{
S1[i]=S2[J];
S1[i]=' 0';
}
/*Wydrukuj połączony wynik S1 */
printf (' Połączony ciąg to %s ',S1);
powrót 0;
}
Migawki programu i wyjścia:
Inny sposób bez funkcji biblioteki
Konkatenacja za pomocą rekurencji:
Funkcja stringconcatenate() zostanie użyta do pobrania długości string1. Jeśli S2 jest pusty, do S2 zostanie przypisany znak null.
Jeśli znak null nie jest przypisany do S2, to dodaj element S2 na końcu S1, czyli S1[i+j]=S2[j], zwiększa to wartość i w ciągu.
Funkcja zostanie wywołana sama, przekazując zreformowane ciągi (S1,S2) jako argument. Będzie wywoływany raz za razem, dopóki S2 nie będzie pusty.
Połączone S1 zostanie wydrukowane przez main() jako
#włączać#włączać
#define BUF_SIZE 256
/* funkcja rekursywna do implementacji konkatenacji ciągów zgodnie z powyższym opisem */
próżniastringconcatenate(zwęglać *S1,zwęglać *S2)
{
statyczny inti=0;
statyczny intJ;
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);
}
}
intGłówny()
{
zwęglaćS1[BUF_SIZE],S2[BUF_SIZE];
printf ('Wprowadź wartość pierwszego ciągu:'); /* wiadomość użytkownika do wprowadzenia pierwszego ciągu */
fgets (S1,BUF_SIZE,stdin); /* użytkownik wprowadza pierwszy ciąg, zapisuje w S1 */
S1[ strlen (S1)-1] = ' 0';
printf ('Wprowadź wartość drugiego ciągu:'); /* wiadomość użytkownika do wprowadzenia drugiego ciągu */
fgets (S2,BUF_SIZE,stdin); /* użytkownik wprowadza pierwszy ciąg, zapisuje w S2 */
S2[ strlen (S2)-1] = ' 0';
stringconcatenate(S1,S2); /* Wywołanie funkcji z parametrami S1,S2 */
printf ('kombinacja ciągów ='%s' ',S1);
powrót 0;
}
Migawki programu i wyjścia:
Łączenie za pomocą funkcji
Funkcja strconcatenate() jest wywoływana przez main() w celu połączenia dwóch ciągów.
Funkcja pobiera długość string1 za pomocą stringlen(string1).
Dołącz elementy ciągu2[i] w ciągu1[i+j]. Ten krok będzie powtarzany, dopóki ciąg nie będzie pusty. Tutaj dołączamy ciąg2 do ciąg1 na końcu ciągu1.
Połączony ciąg (ciąg 1) zostanie odebrany do końca, gdy zostaną wykonane wszystkie iteracje pętli for.
Main() drukuje połączony ciąg S1
#włączać#włączać
#define BUF_SIZE 256
/* funkcja do zaimplementowania konkatenacji ciągów zgodnie z powyższym opisem */
próżniastrconcatenate(zwęglać *ciąg1, zwęglać*ciąg2)
{
inti;
intJ= strlen (ciąg1);
dla(i=0;strunowy2[i];i++)
{
ciąg1[i+J]=ciąg2[i];
}
ciąg1[i+J]= ' 0';
}
intGłówny()
{
zwęglaćciąg1[BUF_SIZE],ciąg2[BUF_SIZE];
printf ('Wprowadź pierwszy ciąg:'); /* Wiadomość użytkownika dla pierwszego ciągu */
fgets (ciąg1,BUF_SIZE,stdin); /* Użytkownik wprowadza drugi ciąg , przechowywany w ciągu1 */
ciąg1[ strlen (ciąg1)-1] = ' 0';
printf ('Wprowadź drugi ciąg:'); /* Wiadomość użytkownika dla drugiego ciągu */
fgets (ciąg2,BUF_SIZE,stdin); /* Użytkownik wprowadza drugi ciąg , przechowywany w ciągu2 */
ciąg2[ strlen (ciąg2)-1] = ' 0';
strconcatenate(ciąg1,ciąg2); /* Wywołaj funkcję z argumentami ciąg1 i ciąg2*/
printf ('Wynikowy ciąg = %s' ',ciąg1);
powrót 0;
}
Migawki programu i wyjścia:
Łączenie ciągów za pomocą memcpy
Używając funkcji memcpy(), łączenie ciągu odbywa się poprzez kopiowanie słowo po słowie z jednego bufora ciągów do końca innego bufora ciągów, w którym rozmiar słowa wynosi 4 bajty, biorąc pod uwagę, że pracujemy na 32-bitowej maszynie, podczas gdy wykonujemy łączenie ciągów przez używając konkatenacji ciągów za pomocą funkcji strcat(), łączenie odbywa się poprzez kopiowanie bajt po bajcie z jednego bufora ciągów do innego bufora ciągów.
Takie podejście jest wydajne.
Jedynym czynnikiem podczas korzystania z memcpy jest dbanie o „ ”.
Program w C do osiągnięcia strcat z memcpy:
#włączać#włączać
#define BUF_SIZE 256
Unieważnij strcat_memcpy(zwęglać *S1, zwęglać *S2)
{
intdługość1,długość2;
długość1= strlen (S1);
długość2= strlen (S2);
memcpy (S1+długość1,S2,długość2);
}
intGłówny()
{
zwęglaćciąg1[BUF_SIZE],ciąg2[BUF_SIZE];
printf ('Wprowadź pierwszy ciąg:'); /* Wiadomość użytkownika dla pierwszego ciągu */
fgets (ciąg1,BUF_SIZE,stdin); /* Użytkownik wprowadza drugi ciąg , przechowywany w ciągu1 */
ciąg1[ strlen (ciąg1)-1] = ' 0';
printf ('Wprowadź drugi ciąg:'); /* Wiadomość użytkownika dla drugiego ciągu */
fgets (ciąg2,BUF_SIZE,stdin); /* Użytkownik wprowadza drugi ciąg , przechowywany w ciągu2 */
ciąg2[ strlen (ciąg2)-1] = ' 0';
strcat_memcpy(ciąg1,ciąg2); /* Wywołaj funkcję z argumentami ciąg1 i ciąg2*/
printf ('Wynikowy ciąg = %s' ',ciąg1);
powrót 0;
}
Migawki programu i wyjścia:
Wniosek:
Dzięki całej tej dyskusji możemy zakończyć konkatenację łańcuchów w C. Widzieliśmy wiele przykładów i przykładowych programów do łączenia łańcuchów. Przypomnimy główne punkty: Istnieją dwa sposoby, jeden ze standardem C, a drugi to sposób zdefiniowany przez użytkownika. Zdefiniowane przez użytkownika mogą być ponadto wielu typów, w zależności od tego, jak użytkownik chce zaimplementować konkatenację ciągów.