Standard C -biblioteksfunktionen som används för att sammanfoga sträng är strcat ().
Funktionsprototyp:
$röding * strcat (str1,str2);där str1 är första sträng och str2 är andra sträng. Returvärdet för funktionen är pekaren till den sammanfogade strängen.
Nu, med hjälp av exempel kommer vi att se hur sammankoppling utförs.
Exempel 1:
$ strcat (str1,str2);där str1 är Bella
str2 är Whitmann
efter sammanfogning av sträng,första strängen blir
str1 Bella Whitmann
str2 Whitmann
medan string2 förblir densamma.
Exempel 2:
$ strcat (str2,str1);där str1 är Bella
str2 är Whitmann
efter sammanfogning av sträng,sammanfogad sträng blir
str1 Bella
str2 Bella Whitmann
medan string1 förblir densamma.
Deklaration i C Header File
Stränghanteringsfunktioner deklareras under rubrikfil. Om man vill använda standardfunktionen för att sammanfoga, måste denna rubrikfil inkluderas.
Därför kan vi åstadkomma strängkoppling på två sätt. Den ena är att använda standard C -biblioteksfunktionen och den andra är utan att använda C -biblioteksfunktionen. Följande är exempelprogram för att visa båda sätten. Stränganslutning utan att använda C -biblioteksfunktionen kan implementeras på flera sätt.
Vi kommer att diskutera det också i kommande avsnitt med exempel.
Sammankoppling av två strängar med hjälp av C -biblioteksfunktionen
#omfatta#omfatta
#define BUF_SIZE 256
inthuvud()
{
rödingS1[BUF_SIZE],S2[BUF_SIZE]; / * Två strängbuffertar */
printf ('Ange den första strängen n'); ] /* Skriv ut meddelande till konsolen för att användaren ska mata in första strängen*/
fgets (S1,BUF_SIZE,stdin); / * lagra användarinmatningssträngen i S1 -buffert */
S1[ strlen (S1)-1] = ' 0';
printf ('Ange den andra strängen n');/* Skriv ut meddelande till användaren för att mata in andra strängen*/
fgets (S2,BUF_SIZE,stdin); / * lagra användarinmatningssträngen i S2 -buffert */
S2[ strlen (S2)-1] = ' 0';
strcat (S1,S2); / *Anropa standardfunktionen med S1- och S2 -strängar */
printf (' nDen sammanlänkade strängen är %s n n',S1); / *Output: S1 läggs till med S2 */
lämna tillbaka 0;
}
Ögonblicksbilder av programmet och utdata:
Sammankoppling av två strängar utan att använda biblioteksfunktion
Använd för loop för att kopiera den andra strängen i slutet av den första strängen.
#omfatta#omfatta
#define BUF_SIZE 256
inthuvud()
{
rödingS1[BUF_SIZE],S2[BUF_SIZE]; /* Deklarera buffertarna S1, S2 för både strängen*/
intlängd= 0,i,j; /*Variabler som behövs för loop -traversal*/
printf ('Ange den första strängen'); / * Skriv ut användarmeddelande för att ange första strängen */
fgets (S1,BUF_SIZE,stdin); /* användarinmatningssträng lagras i S1*/
S1[ strlen (S1)-1] = ' 0';
printf ('Ange den andra strängen'); / * Skriv ut användarmeddelande för att ange andra strängen */
fgets (S2,BUF_SIZE,stdin); /* användarinmatningssträng lagras i S2*/
S2[ strlen (S2)-1] = ' 0';
/* Korsa den första strängen för att hitta längden på S1*/
för(i=0;S1[i]! =' 0';i++)
{
längd=längd+1;
}
/*längden kommer att ha slutet på S1, börja med längden och kopiera hela S2 till S1*/
för(i=längd,j=0;S2[j]! =' 0';i++,j++)
{
S1[i]=S2[j];
S1[i]=' 0';
}
/ *Skriv ut S1, sammanfogat resultat */
printf (' nDen sammanlänkade strängen är %s n n',S1);
lämna tillbaka 0;
}
Ögonblicksbilder av programmet och utdata:
Ett annat sätt utan biblioteksfunktion
Sammankoppling med rekursion:
Funktionen stringconcatenate () kommer att användas för att få längden på string1. Om S2 är tomt tilldelas ett nulltecken till S2.
Om nulltecken inte tilldelas S2 än lägg till element i S2 i slutet av S1 som är S1 [i+j] = S2 [j], ökar detta värdet av i i strängen.
En funktion kommer att kallas sig själv genom att passera de reformerade strängarna (S1, S2) som ett argument. Det kommer att ringas om och om igen tills S2 är tom.
Den sammanfogade S1 kommer att skrivas ut av main () as
#omfatta#omfatta
#define BUF_SIZE 256
/ * rekursiv funktion för att implementera strängkoppling enligt beskrivningen ovan */
tomhetstringconcatenate(röding *S1,röding *S2)
{
statisk inti=0;
statisk intj;
j= strlen (S1);
om(!S2[i])
{
S2[i]=' 0';
}
annan
{
S1[j] =S2[i];
S1[j+1] = ' 0';
i++;
stringconcatenate(S1,S2);
}
}
inthuvud()
{
rödingS1[BUF_SIZE],S2[BUF_SIZE];
printf ('Ange värdet för den första strängen:'); / * användarmeddelande för att mata in första strängen */
fgets (S1,BUF_SIZE,stdin); / * användarinmatning första sträng, lagra i S1 */
S1[ strlen (S1)-1] = ' 0';
printf ('Ange värdet för den andra strängen:'); / * användarmeddelande för att mata in 2: a strängen */
fgets (S2,BUF_SIZE,stdin); / * användarinmatning första sträng, lagra i S2 */
S2[ strlen (S2)-1] = ' 0';
stringconcatenate(S1,S2); / * Anropa funktionen med S1, S2 som parametrar */
printf ('kombination av strängar ='%s ' n',S1);
lämna tillbaka 0;
}
Ögonblicksbilder av programmet och utdata:
Sammankoppling med hjälp av funktioner
Funktionen strconcatenate () kallas av main () för att kombinera två strängar.
Funktionen får strängens längd med stringlen (string1).
Anslut elementen i string2 [i] i string1 [i+j]. Detta steg upprepas tills strängen är tom. Här ansluter vi till string2 till string1 i slutet av string1.
Sammankopplad sträng (sträng 1) kommer att tas emot i slutet när alla iterationer av för loop kommer att utföras.
Main () skriver ut den sammanfogade strängen S1
#omfatta#omfatta
#define BUF_SIZE 256
/ * funktion för att implementera strängkoppling enligt beskrivningen ovan */
tomhetstrconcatenate(röding *sträng1, röding*string2)
{
inti;
intj= strlen (sträng1);
för(i=0;sträng2[i];i++)
{
sträng1[i+j]=string2[i];
}
sträng1[i+j]= ' 0';
}
inthuvud()
{
rödingsträng1[BUF_SIZE],string2[BUF_SIZE];
printf ('Ange den första strängen:'); / * Användarmeddelande för första strängen */
fgets (sträng1,BUF_SIZE,stdin); / * Användarinmatning andra strängen, lagrad i sträng1 */
sträng1[ strlen (sträng1)-1] = ' 0';
printf ('Ange den andra strängen:'); / * Användarmeddelande för andra strängen */
fgets (string2,BUF_SIZE,stdin); / * Användarinmatning andra strängen, lagrad i string2 */
string2[ strlen (string2)-1] = ' 0';
strconcatenate(sträng1,string2); /* Anropa funktionen med string1 och string2 som argument*/
printf ('Resulterande sträng = %s' n',sträng1);
lämna tillbaka 0;
}
Ögonblicksbilder av programmet och utdata:
Sträng sammanfogning genom att använda memcpy
Genom att använda memcpy () -funktionen sker sammankopplingen av strängen genom att kopiera ord för ord från en strängbuffert till slutet av en annan strängbuffert där ordstorleken är 4 byte med tanke på att vi kör på 32 -bitars maskin medan vi gör strängsammanbindning med med hjälp av strängsammanlänkning med hjälp av strcat () -funktionen görs sammanfogning genom att kopiera byte för byte från en strängbuffert till en annan strängbuffert.
Detta tillvägagångssätt är prestandaeffektivt.
Den enda övervägningen när du använder memcpy är att ta hand om ‘ 0’.
C -program för att uppnå strcat med memcpy:
#omfatta#omfatta
#define BUF_SIZE 256
Ogiltig strcat_memcpy(röding *S1, röding *S2)
{
intlängd1,längd2;
längd1= strlen (S1);
längd2= strlen (S2);
memcpy (S1+längd1,S2,längd2);
}
inthuvud()
{
rödingsträng1[BUF_SIZE],string2[BUF_SIZE];
printf ('Ange den första strängen:'); / * Användarmeddelande för första strängen */
fgets (sträng1,BUF_SIZE,stdin); / * Användarinmatning andra strängen, lagrad i sträng1 */
sträng1[ strlen (sträng1)-1] = ' 0';
printf ('Ange den andra strängen:'); / * Användarmeddelande för andra strängen */
fgets (string2,BUF_SIZE,stdin); / * Användarinmatning andra strängen, lagrad i string2 */
string2[ strlen (string2)-1] = ' 0';
strcat_memcpy(sträng1,string2); /* Anropa funktionen med string1 och string2 som argument*/
printf ('Resulterande sträng = %s' n',sträng1);
lämna tillbaka 0;
}
Ögonblicksbilder av programmet och utdata:
Slutsats:
Med all denna diskussion kan vi avsluta stränganslutningen i C. Vi har sett många exempel och exempel på program för stränganslutning. Vi kommer att komma ihåg de viktigaste objekten: Det finns två sätt, ett med C -standard och ett annat är användardefinierat sätt. Användardefinierad kan vidare vara av många typer, beror på hur användaren vill implementera strängkoppling.