Ang karaniwang pag-andar ng C library na ginagamit upang pagsamahin ang string ay strcat ().
Pag-andar ng Prototype:
$char * strcat (str1,str2);kung saan ang str1 ay unang stringand str2 ay pangalawang string. Ang pagbalik ng halaga ng pagpapaandar ay ang pointer sa concatenated string.
Ngayon, sa tulong ng halimbawa makikita natin kung paano ginaganap ang pagsasama.
Halimbawa1:
$ strcat (str1,str2);kung saan ang str1 ay si Bella
str2 si Whitmann
pagkatapos ng pagsasama-sama ng string,ang unang string ay magiging
str1 Bella Whitmann
str2 Whitmann
habang ang string2 ay mananatiling pareho.
Halimbawa2:
$ strcat (str2,str1);kung saan ang str1 ay si Bella
str2 si Whitmann
pagkatapos ng pagsasama-sama ng string,concatenated string ay magiging
str1 Bella
str2 Bella Whitmann
habang ang string1 ay mananatiling pareho.
Pagpapahayag sa C Header File
Ang mga pagpapaandar sa paghawak ng string ay idineklara sa ilalim ng headerfile. Kung nais ng isa na gumamit ng karaniwang pag-andar upang mag-concatenate, kailangang isama ang header file na ito.
Samakatuwid, makakamit natin ang string concatenation sa dalawang paraan. Ang isa ay ang paggamit ng Standard C library function at iba pa ay hindi gamit ang C library function. Ang sumusunod ay mga halimbawang programa upang maipakita ang parehong paraan. Ang pagsasama-sama ng string na hindi gumagamit ng pagpapaandar ng C library ay maaaring ipatupad sa maraming paraan.
Tatalakayin din namin iyon sa mga darating na seksyon na may halimbawa.
Pagtatapos ng Dalawang Mga String sa pamamagitan ng Paggamit ng C Library Function
# isama# isama
# tukuyin ang BUF_SIZE 256
intpangunahing()
{
charS1[BUF_SIZE],S2[BUF_SIZE]; / * Dalawang mga buffer ng string * /
printf ('Ipasok ang unang string n'); ] / * I-print ang mensahe sa console para ma-input ng user ang 1st string * /
fgets (S1,BUF_SIZE,si stdin); / * itabi ang input input ng gumagamit sa S1 buffer * /
S1[ strlen (S1)-1] = ' 0';
printf ('Ipasok ang pangalawang string n');/ * I-print ang mensahe sa gumagamit upang mai-input ang 2nd string * /
fgets (S2,BUF_SIZE,si stdin); / * iimbak ang input input ng gumagamit sa S2 buffer * /
S2[ strlen (S2)-1] = ' 0';
strcat (S1,S2); / * Tumawag sa karaniwang pagpapaandar na may mga string ng S1 at S2 * /
printf (' nAng konklusyon na string ay% s n n',S1); / * Output: Ang S1 ay naidugtong sa S2 * /
bumalik ka 0;
}
Mga snapshot ng programa at output:
Pagtatapos ng Dalawang Mga String Nang Hindi Gumagamit ng Pag-andar ng Library
Paggamit para sa loop upang kopyahin ang pangalawang string sa dulo ng unang string.
# isama# isama
# tukuyin ang BUF_SIZE 256
intpangunahing()
{
charS1[BUF_SIZE],S2[BUF_SIZE]; / * Ipahayag ang mga buffer S1, S2 para sa parehong string * /
inthaba= 0,ako,j; / * Kailangan ng mga variable para sa loop traversal * /
printf ('Ipasok ang unang string'); / * I-print ang mensahe ng gumagamit upang ipasok ang unang string * /
fgets (S1,BUF_SIZE,si stdin); / * Ang input string ng gumagamit ay maiimbak sa S1 * /
S1[ strlen (S1)-1] = ' 0';
printf ('Ipasok ang pangalawang string'); / * I-print ang mensahe ng gumagamit upang ipasok ang Pangalawang string * /
fgets (S2,BUF_SIZE,si stdin); / * Ang input string ng gumagamit ay maiimbak sa S2 * /
S2[ strlen (S2)-1] = ' 0';
/ * Tumawid sa unang string upang hanapin ang haba ng S1 * /
para sa(ako=0;S1[ako]! =' 0';ako++)
{
haba=haba+1;
}
/ * haba ay magkakaroon ng pagtatapos ng S1, magsimula mula sa haba at kopyahin ang buong S2 sa S1 * /
para sa(ako=haba,j=0;S2[j]! =' 0';ako++,j++)
{
S1[ako]=S2[j];
S1[ako]=' 0';
}
/ * I-print ang S1, concatenated na resulta * /
printf (' nAng konklusyon na string ay% s n n',S1);
bumalik ka 0;
}
Mga snapshot ng programa at output:
Isa pang Paraan ng Walang Pag-andar sa Library
Pagtatapos gamit ang recursion:
Ang function stringconcatenate () ay gagamitin upang makuha ang haba ng string1. Kung ang S2 ay walang laman pagkatapos ng isang null character ay itatalaga sa S2.
Kung ang null character ay hindi nakatalaga sa S2 kaysa magdagdag ng elemento ng S2 sa dulo ng S1 na S1 [i + j] = S2 [j], pinapataas nito ang halaga ng i sa string.
Ang isang pagpapaandar ay tatawaging sarili nito sa pamamagitan ng pagpasa sa mga nabagong mga string (S1, S2) bilang isang argument. Tatawagin ito nang paulit-ulit hanggang sa walang laman ang S2.
Ang concatenated S1 ay mai-print ng pangunahing () bilang
# isama# isama
# tukuyin ang BUF_SIZE 256
/ * recursive function upang magpatupad ng string concatenation ayon sa nailarawan sa itaas * /
walang bisastringconcatenate(char *S1,char *S2)
{
static intako=0;
static intj;
j= strlen (S1);
kung(!S2[ako])
{
S2[ako]=' 0';
}
iba pa
{
S1[j] =S2[ako];
S1[j+1] = ' 0';
ako++;
stringconcatenate(S1,S2);
}
}
intpangunahing()
{
charS1[BUF_SIZE],S2[BUF_SIZE];
printf ('Ipasok ang halaga ng unang string:'); / * mensahe ng gumagamit upang mai-input ang 1st string * /
fgets (S1,BUF_SIZE,si stdin); / * Pag-input ng unang string ng gumagamit, itabi sa S1 * /
S1[ strlen (S1)-1] = ' 0';
printf ('Ipasok ang halaga ng pangalawang string:'); / * mensahe ng gumagamit upang mai-input ang ika-2 string * /
fgets (S2,BUF_SIZE,si stdin); / * Pag-input ng unang string ng gumagamit, itabi sa S2 * /
S2[ strlen (S2)-1] = ' 0';
stringconcatenate(S1,S2); / * Tumawag sa pagpapaandar gamit ang S1, S2 bilang mga parameter * /
printf ('kombinasyon ng mga string ='% s ' n',S1);
bumalik ka 0;
}
Mga snapshot ng programa at output:
Pagtatapos sa pamamagitan ng Paggamit ng Mga Pag-andar
Ang function na strconcatenate () ay tinawag ng pangunahing () upang pagsamahin ang dalawang mga string.
Nakukuha ng pagpapaandar ang haba ng string1 sa pamamagitan ng paggamit ng stringlen (string1).
Idugtong ang mga elemento ng string2 [i] sa string1 [i + j]. Ang hakbang na ito ay uulitin hanggang sa walang laman ang string. Dito, isinasama namin ang string2 hanggang string1 sa dulo ng string1.
Ang nag-uugnay na string (string 1) ay matatanggap ng katapusan kapag ang lahat ng mga pag-ulit ng para sa loop ay gaganapin.
Ang pangunahing () naka-print ang concatenated string S1
# isama# isama
# tukuyin ang BUF_SIZE 256
/ * pagpapaandar upang magpatupad ng string concatenation alinsunod sa itaas na paglalarawan * /
walang bisastrconcatenate(char *string1, char*string2)
{
intako;
intj= strlen (string1);
para sa(ako=0;lubid2[ako];ako++)
{
string1[ako+j]=string2[ako];
}
string1[ako+j]= ' 0';
}
intpangunahing()
{
charstring1[BUF_SIZE],string2[BUF_SIZE];
printf ('Ipasok ang unang string:'); / * Mensahe ng gumagamit para sa 1st string * /
fgets (string1,BUF_SIZE,si stdin); / * Pag-input ng pangalawang string ng gumagamit, na nakaimbak sa string1 * /
string1[ strlen (string1)-1] = ' 0';
printf ('Ipasok ang pangalawang string:'); / * Mensahe ng gumagamit para sa ika-2 string * /
fgets (string2,BUF_SIZE,si stdin); / * Pag-input ng pangalawang string ng gumagamit, na nakaimbak sa string2 * /
string2[ strlen (string2)-1] = ' 0';
strconcatenate(string1,string2); / * Tawagin ang pagpapaandar na may string1 at string2 bilang mga argumento * /
printf ('Resultant string =% s' n',string1);
bumalik ka 0;
}
Mga snapshot ng programa at output:
Strat Concatenation sa pamamagitan ng Paggamit ng memcpy
Sa pamamagitan ng paggamit ng memcpy () function, ang pagsasama ng string ay ginagawa sa pamamagitan ng pagkopya ng salita sa pamamagitan ng salita mula sa isang string buffer hanggang sa dulo ng isa pang string buffer kung saan ang laki ng salita ay 4 bytes na isinasaalang-alang na tumatakbo kami sa 32 bit machine habang ginagawa namin ang string concatenation ng gamit ang string concatenation sa pamamagitan ng paggamit ng strcat () function, concatenation ay ginagawa sa pamamagitan ng pagkopya ng byte byte mula sa isang string buffer patungo sa isa pang string buffer.
Ang diskarte na ito ay mahusay sa pagganap.
Ang tanging pagsasaalang-alang lamang habang gumagamit ng memcpy ay ang mag-ingat sa ‘ 0’.
C programa upang makamit ang strcat na may memcpy:
# isama# isama
# tukuyin ang BUF_SIZE 256
Walang bisa strcat_memcpy(char *S1, char *S2)
{
inthaba1,haba2;
haba1= strlen (S1);
haba2= strlen (S2);
memcpy (S1+haba1,S2,haba2);
}
intpangunahing()
{
charstring1[BUF_SIZE],string2[BUF_SIZE];
printf ('Ipasok ang unang string:'); / * Mensahe ng gumagamit para sa 1st string * /
fgets (string1,BUF_SIZE,si stdin); / * Pag-input ng pangalawang string ng gumagamit, na nakaimbak sa string1 * /
string1[ strlen (string1)-1] = ' 0';
printf ('Ipasok ang pangalawang string:'); / * Mensahe ng gumagamit para sa ika-2 string * /
fgets (string2,BUF_SIZE,si stdin); / * Pag-input ng pangalawang string ng gumagamit, na nakaimbak sa string2 * /
string2[ strlen (string2)-1] = ' 0';
strcat_memcpy(string1,string2); / * Tawagin ang pagpapaandar na may string1 at string2 bilang mga argumento * /
printf ('Resultant string =% s' n',string1);
bumalik ka 0;
}
Mga snapshot ng programa at output:
Konklusyon:
Sa lahat ng talakayang ito maaari nating tapusin ang pagsasabwatan ng string sa C. Nakita namin ang maraming mga halimbawa at halimbawang programa para sa pagsasama-sama ng string. Maaalala namin ang mga pangunahing item: Mayroong dalawang paraan, ang isa ay may pamantayan sa C at iba pa ay ang paraan na tinukoy ng gumagamit. Ang tinukoy ng gumagamit ay maaaring karagdagang ng maraming mga uri, nakasalalay sa kung paano nais ng gumagamit na magpatupad ng string concatenation.