Standard C -biblioteksfunktionen, der bruges til at sammenkæde streng, er strcat ().
Funktionsprototype:
$forkælelse * strcat (str1,str2);hvor str1 er første streng og str2 er anden streng. Funktionens returværdi er markøren til den sammenkædede streng.
Nu vil vi ved hjælp af eksemplet se, hvordan sammenkædning udføres.
Eksempel 1:
$ strcat (str1,str2);hvor str1 er Bella
str2 er Whitmann
efter sammenkædning af streng,første streng vil være
str1 Bella Whitmann
str2 Whitmann
mens string2 forbliver den samme.
Eksempel 2:
$ strcat (str2,str1);hvor str1 er Bella
str2 er Whitmann
efter sammenkædning af streng,sammenkædede streng vil være
str1 Bella
str2 Bella Whitmann
mens string1 forbliver den samme.
Erklæring i C Header File
Strenghåndteringsfunktioner deklareres under headerfil. Hvis man vil bruge standardfunktionen til at sammenkoble, skal denne headerfil inkluderes.
Derfor kan vi opnå streng sammenkædning på to måder. Den ene er ved hjælp af Standard C -biblioteksfunktionen, og den anden er uden at bruge C -biblioteksfunktionen. Følgende er eksempler på programmer til at demonstrere begge måder. Strenge sammenkædning uden brug af C biblioteksfunktion kan implementeres på flere måder.
Vi vil også diskutere det i de kommende afsnit med eksempel.
Sammenkædning af to strenge ved hjælp af C biblioteksfunktion
#omfatte#omfatte
#define BUF_SIZE 256
intvigtigste()
{
forkælelseS1[BUF_SIZE],S2[BUF_SIZE]; / * To strengbuffere */
printf ('Indtast den første streng n'); ] /* Udskriv besked til konsollen, så brugeren kan indtaste 1. streng*/
fgets (S1,BUF_SIZE,stdin); / * gem brugerinputstrengen i S1 -buffer */
S1[ strlen (S1)-1] = ' 0';
printf ('Indtast den anden streng n');/* Udskriv besked til bruger for at indtaste 2. streng*/
fgets (S2,BUF_SIZE,stdin); / * gem brugerinputstrengen i S2 -buffer */
S2[ strlen (S2)-1] = ' 0';
strcat (S1,S2); / *Kald standardfunktionen med S1- og S2 -strenge */
printf (' nSammenkædet streng er %s n n',S1); / *Output: S1 tilføjes med S2 */
Vend tilbage 0;
}
Snapshots af programmet og output:
Sammenkædning af to strenge uden brug af biblioteksfunktion
Brug for loop til at kopiere den anden streng i slutningen af den første streng.
#omfatte#omfatte
#define BUF_SIZE 256
intvigtigste()
{
forkælelseS1[BUF_SIZE],S2[BUF_SIZE]; /* Angiv bufferne S1, S2 for begge strengen*/
intlængde= 0,jeg,j; /*Variabler nødvendige for loop -traversal*/
printf ('Indtast den første streng'); / * Udskriv brugermeddelelse for at indtaste første streng */
fgets (S1,BUF_SIZE,stdin); /* brugerinputstreng gemmes i S1*/
S1[ strlen (S1)-1] = ' 0';
printf ('Indtast den anden streng'); / * Udskriv brugermeddelelse for at indtaste anden streng */
fgets (S2,BUF_SIZE,stdin); /* brugerinputstreng gemmes i S2*/
S2[ strlen (S2)-1] = ' 0';
/* Kryds den første streng for at finde længden af S1*/
til(jeg=0;S1[jeg]! =' 0';jeg++)
{
længde=længde+1;
}
/*længden vil have enden på S1, start fra længden og kopier hele S2 til S1*/
til(jeg=længde,j=0;S2[j]! =' 0';jeg++,j++)
{
S1[jeg]=S2[j];
S1[jeg]=' 0';
}
/ *Udskriv S1, sammenkædede resultat */
printf (' nSammenkædet streng er %s n n',S1);
Vend tilbage 0;
}
Snapshots af programmet og output:
En anden måde uden biblioteksfunktion
Sammenkædning ved hjælp af rekursion:
Funktionen stringconcatenate () bruges til at få længden på string1. Hvis S2 er tom, tildeles et nultegn til S2.
Hvis der ikke er tildelt null tegn til S2 end tilføjelse af element i S2 i slutningen af S1, der er S1 [i+j] = S2 [j], øges dette værdien af i i strengen.
En funktion vil blive kaldt sig selv ved at passere de reformerede strenge (S1, S2) som et argument. Det vil blive kaldt igen og igen, indtil S2 er tom.
Den sammenkædede S1 udskrives af main () som
#omfatte#omfatte
#define BUF_SIZE 256
/ * rekursiv funktion til at implementere streng sammenkædning i henhold til ovenstående beskrivelse */
ugyldigstringconcatenate(forkælelse *S1,forkælelse *S2)
{
statisk intjeg=0;
statisk intj;
j= strlen (S1);
hvis(!S2[jeg])
{
S2[jeg]=' 0';
}
andet
{
S1[j] =S2[jeg];
S1[j+1] = ' 0';
jeg++;
stringconcatenate(S1,S2);
}
}
intvigtigste()
{
forkælelseS1[BUF_SIZE],S2[BUF_SIZE];
printf ('Indtast værdien af den første streng:'); / * brugerbesked for at indtaste 1. streng */
fgets (S1,BUF_SIZE,stdin); / * brugerinput første streng, gem i S1 */
S1[ strlen (S1)-1] = ' 0';
printf ('Indtast værdien af anden streng:'); / * brugerbesked for at indtaste 2. streng */
fgets (S2,BUF_SIZE,stdin); / * brugerinput første streng, gem i S2 */
S2[ strlen (S2)-1] = ' 0';
stringconcatenate(S1,S2); / * Kald funktionen med S1, S2 som parametre */
printf ('kombination af strenge ='%s ' n',S1);
Vend tilbage 0;
}
Snapshots af programmet og output:
Sammenkædning ved hjælp af funktioner
Funktionen strconcatenate () kaldes af main () til at kombinere to strenge.
Funktionen får længden på string1 ved hjælp af stringlen (string1).
Tilslut elementerne i streng2 [i] i streng1 [i+j]. Dette trin gentages, indtil strengen er tom. Her slutter vi strengen2 til streng1 i slutningen af streng1.
Sammenkædet streng (streng 1) vil blive modtaget i slutningen, når alle iterationer af loop for udføres.
Main () udskriver den sammenkædede streng S1
#omfatte#omfatte
#define BUF_SIZE 256
/ * funktion til at implementere streng sammenkædning i henhold til ovenstående beskrivelse */
ugyldigstrconcatenate(forkælelse *streng 1, forkælelse*streng2)
{
intjeg;
intj= strlen (streng 1);
til(jeg=0;snor2[jeg];jeg++)
{
streng 1[jeg+j]=streng2[jeg];
}
streng 1[jeg+j]= ' 0';
}
intvigtigste()
{
forkælelsestreng 1[BUF_SIZE],streng2[BUF_SIZE];
printf ('Indtast den første streng:'); / * Brugerbesked for 1. streng */
fgets (streng 1,BUF_SIZE,stdin); / * Brugerindgang anden streng, gemt i streng1 */
streng 1[ strlen (streng 1)-1] = ' 0';
printf ('Indtast den anden streng:'); / * Brugerbesked til 2. streng */
fgets (streng2,BUF_SIZE,stdin); / * Brugerindgang anden streng, gemt i streng2 */
streng2[ strlen (streng2)-1] = ' 0';
strconcatenate(streng 1,streng2); /* Kald funktionen med string1 og string2 som argumenter*/
printf ('Resulterende streng = %s' n',streng 1);
Vend tilbage 0;
}
Snapshots af programmet og output:
Strenge sammenkædning ved hjælp af memcpy
Ved at bruge memcpy () -funktionen udføres sammenkædning af streng ved at kopiere ord for ord fra en strengbuffer til slutningen af en anden strengbuffer, hvor ordstørrelsen er 4 bytes, da vi kører på en 32 -bit maskine, mens når vi laver streng sammenkædning af ved hjælp af streng sammenkædning ved hjælp af funktionen strcat (), sker sammenkædning ved at kopiere byte for byte fra en strengbuffer til en anden strengbuffer.
Denne fremgangsmåde er ydeevneeffektiv.
Den eneste overvejelse, når du bruger memcpy, er at tage sig af ' 0'.
C -program for at opnå strcat med memcpy:
#omfatte#omfatte
#define BUF_SIZE 256
Ugyldig strcat_memcpy(forkælelse *S1, forkælelse *S2)
{
intlængde 1,længde 2;
længde 1= strlen (S1);
længde 2= strlen (S2);
memcpy (S1+længde 1,S2,længde 2);
}
intvigtigste()
{
forkælelsestreng 1[BUF_SIZE],streng2[BUF_SIZE];
printf ('Indtast den første streng:'); / * Brugerbesked for 1. streng */
fgets (streng 1,BUF_SIZE,stdin); / * Brugerindgang anden streng, gemt i streng1 */
streng 1[ strlen (streng 1)-1] = ' 0';
printf ('Indtast den anden streng:'); / * Brugerbesked til 2. streng */
fgets (streng2,BUF_SIZE,stdin); / * Brugerindgang anden streng, gemt i streng2 */
streng2[ strlen (streng2)-1] = ' 0';
strcat_memcpy(streng 1,streng2); /* Kald funktionen med string1 og string2 som argumenter*/
printf ('Resulterende streng = %s' n',streng 1);
Vend tilbage 0;
}
Snapshots af programmet og output:
Konklusion:
Med hele denne diskussion kan vi afslutte strengen sammenkædning i C. Vi har set mange eksempler og eksempler på programmer til streng sammenkædning. Vi husker hovedelementerne: Der er to måder, en med C -standard og en anden er brugerdefineret måde. Brugerdefineret kan yderligere være af mange typer, afhænger af, hvordan brugeren ønsker at implementere streng sammenkædning.