స్ట్రింగ్‌ను కలపడానికి ఉపయోగించే ప్రామాణిక సి లైబ్రరీ ఫంక్షన్ strcat ().
ఫంక్షన్ నమూనా:
$చార్ * strcat (str1,str2);ఇక్కడ str1 మొదటి స్ట్రింగ్ మరియు str2 రెండవ స్ట్రింగ్. ఫంక్షన్ యొక్క రిటర్న్ వాల్యూ అనేది కన్యాక్టేటెడ్ స్ట్రింగ్‌కు సూచిక.
ఇప్పుడు, ఉదాహరణ సహాయంతో మనం ఏకీకరణ ఎలా జరుగుతుందో చూస్తాము.
ఉదాహరణ 1:
$ strcat (str1,str2);ఇక్కడ str1 బెల్లా
str2 అనేది విట్మన్
స్ట్రింగ్ కలిసిన తరువాత,మొదటి స్ట్రింగ్ ఉంటుంది
str1 బెల్లా విట్మన్
str2 విట్మన్
స్ట్రింగ్ 2 అలాగే ఉంటుంది.
ఉదాహరణ 2:
$ strcat (str2,str1);ఇక్కడ str1 బెల్లా
str2 అనేది విట్మన్
స్ట్రింగ్ కలిసిన తరువాత,సంయోగ స్ట్రింగ్ ఉంటుంది
str1 బెల్లా
str2 బెల్లా విట్మన్
స్ట్రింగ్ 1 అలాగే ఉంటుంది.
సి హెడర్ ఫైల్‌లో ప్రకటన
స్ట్రింగ్ నిర్వహణ విధులు హెడర్‌ఫైల్ కింద ప్రకటించబడ్డాయి. ఒకదానిని కలపడానికి ప్రామాణిక ఫంక్షన్‌ను ఉపయోగించాలనుకుంటే, ఈ హెడర్ ఫైల్‌ను చేర్చడం అవసరం.
అందుచేత, మేము రెండు విధాలుగా స్ట్రింగ్ సంధానాన్ని సాధించవచ్చు. ఒకటి స్టాండర్డ్ సి లైబ్రరీ ఫంక్షన్‌ను ఉపయోగించడం మరియు మరొకటి సి లైబ్రరీ ఫంక్షన్‌ను ఉపయోగించకుండా చేయడం. రెండు మార్గాలను ప్రదర్శించడానికి ఉదాహరణ కార్యక్రమాలు క్రింది విధంగా ఉన్నాయి. సి లైబ్రరీ ఫంక్షన్‌ను ఉపయోగించకుండా స్ట్రింగ్ కాన్కానేషన్‌ను అనేక విధాలుగా అమలు చేయవచ్చు.
మేము దానిని కూడా ఉదాహరణతో రాబోయే విభాగాలలో చర్చిస్తాము.
సి లైబ్రరీ ఫంక్షన్‌ను ఉపయోగించడం ద్వారా రెండు స్ట్రింగ్‌ల సమ్మేళనం
#చేర్చండి#చేర్చండి
#BUF_SIZE 256 ని నిర్వచించండి
intప్రధాన()
{
చార్ఎస్ 1[BUF_SIZE],ఎస్ 2[BUF_SIZE]; / * రెండు స్ట్రింగ్ బఫర్లు */
printf ('మొదటి స్ట్రింగ్‌ని నమోదు చేయండి n'); ] /* వినియోగదారు 1 వ స్ట్రింగ్‌ను ఇన్‌పుట్ చేయడానికి కన్సోల్‌కు సందేశాన్ని ముద్రించండి*/
fgets (ఎస్ 1,BUF_SIZE,stdin); / * వినియోగదారు ఇన్‌పుట్ స్ట్రింగ్‌ను S1 బఫర్‌లో స్టోర్ చేయండి */
ఎస్ 1[ strlen (ఎస్ 1)-1] = ' 0';
printf ('రెండవ స్ట్రింగ్‌ని నమోదు చేయండి n');/* 2 వ స్ట్రింగ్‌ను ఇన్‌పుట్ చేయడానికి యూజర్‌కి సందేశాన్ని ముద్రించండి*/
fgets (ఎస్ 2,BUF_SIZE,stdin); / * వినియోగదారు ఇన్‌పుట్ స్ట్రింగ్‌ను S2 బఫర్‌లో స్టోర్ చేయండి */
ఎస్ 2[ strlen (ఎస్ 2)-1] = ' 0';
strcat (ఎస్ 1,ఎస్ 2); / *S1 మరియు S2 స్ట్రింగ్‌లతో ప్రామాణిక ఫంక్షన్‌కు కాల్ చేయండి */
printf (' nకలిసిన స్ట్రింగ్ %s n n',ఎస్ 1); / *అవుట్‌పుట్: S1 S2 */తో జతచేయబడుతుంది
తిరిగి 0;
}
ప్రోగ్రామ్ యొక్క స్నాప్‌షాట్‌లు మరియు అవుట్‌పుట్:
లైబ్రరీ ఫంక్షన్ ఉపయోగించకుండా రెండు స్ట్రింగ్‌ల సమ్మేళనం
మొదటి స్ట్రింగ్ చివరిలో రెండవ స్ట్రింగ్‌ను కాపీ చేయడానికి లూప్ కోసం ఉపయోగించడం.
#చేర్చండి#చేర్చండి
#BUF_SIZE 256 ని నిర్వచించండి
intప్రధాన()
{
చార్ఎస్ 1[BUF_SIZE],ఎస్ 2[BUF_SIZE]; /* రెండు స్ట్రింగ్ కోసం బఫర్లు S1, S2 ప్రకటించండి*/
intపొడవు= 0,i,జ; /*లూప్ ట్రావెర్సల్ కోసం వేరియబుల్స్ అవసరం*/
printf ('మొదటి స్ట్రింగ్‌ని నమోదు చేయండి'); / * మొదటి స్ట్రింగ్ ఎంటర్ చేయడానికి వినియోగదారు సందేశాన్ని ముద్రించండి */
fgets (ఎస్ 1,BUF_SIZE,stdin); /* వినియోగదారు ఇన్‌పుట్ స్ట్రింగ్ S1*/లో నిల్వ చేయబడుతుంది
ఎస్ 1[ strlen (ఎస్ 1)-1] = ' 0';
printf ('రెండవ స్ట్రింగ్‌ని నమోదు చేయండి'); / * రెండవ స్ట్రింగ్ నమోదు చేయడానికి వినియోగదారు సందేశాన్ని ముద్రించండి */
fgets (ఎస్ 2,BUF_SIZE,stdin); /* వినియోగదారు ఇన్‌పుట్ స్ట్రింగ్ S2*/లో నిల్వ చేయబడుతుంది
ఎస్ 2[ strlen (ఎస్ 2)-1] = ' 0';
/* S1*/పొడవును కనుగొనడానికి మొదటి స్ట్రింగ్‌ని ట్రావెస్ చేయండి
కోసం(i=0;ఎస్ 1[i]! =' 0';i++)
{
పొడవు=పొడవు+1;
}
/*పొడవు S1 ముగింపును కలిగి ఉంటుంది, పొడవు నుండి ప్రారంభించి మొత్తం S2 ని S1*/లోకి కాపీ చేయండి
కోసం(i=పొడవు,జ=0;ఎస్ 2[జ]! =' 0';i++,జ++)
{
ఎస్ 1[i]=ఎస్ 2[జ];
ఎస్ 1[i]=' 0';
}
/ *S1 ప్రింట్ చేయండి, కలిసిన ఫలితం */
printf (' nకలిసిన స్ట్రింగ్ %s n n',ఎస్ 1);
తిరిగి 0;
}
ప్రోగ్రామ్ యొక్క స్నాప్‌షాట్‌లు మరియు అవుట్‌పుట్:
లైబ్రరీ ఫంక్షన్ లేని మరొక మార్గం
పునరావృతాన్ని ఉపయోగించి సమ్మేళనం:
స్ట్రింగ్ 1 పొడవును పొందడానికి స్ట్రింగ్‌కాన్‌కేటనేట్ () ఫంక్షన్ ఉపయోగించబడుతుంది. S2 ఖాళీగా ఉంటే శూన్య అక్షరం S2 కి కేటాయించబడుతుంది.
S1 [i+j] = S2 [j] చివరిలో S2 యొక్క మూలకాన్ని జోడించడం కంటే N2 అక్షరాన్ని S2 కి కేటాయించకపోతే, ఇది స్ట్రింగ్‌లో i విలువను పెంచుతుంది.
సంస్కరణ తీగలను (S1, S2) ఒక వాదనగా పంపడం ద్వారా ఒక ఫంక్షన్‌ని స్వయంగా పిలుస్తారు. S2 ఖాళీ అయ్యే వరకు ఇది మళ్లీ మళ్లీ పిలువబడుతుంది.
కలిసిన S1 ప్రధాన () గా ముద్రించబడుతుంది
#చేర్చండి#చేర్చండి
#BUF_SIZE 256 ని నిర్వచించండి
/ * పై వివరణ ప్రకారం స్ట్రింగ్ కాన్కానేటేషన్ అమలు చేయడానికి పునరావృత ఫంక్షన్ */
శూన్యంstringconcatenate(చార్ *ఎస్ 1,చార్ *ఎస్ 2)
{
స్టాటిక్ inti=0;
స్టాటిక్ intజ;
జ= strlen (ఎస్ 1);
ఉంటే(!ఎస్ 2[i])
{
ఎస్ 2[i]=' 0';
}
లేకపోతే
{
ఎస్ 1[జ] =ఎస్ 2[i];
ఎస్ 1[జ+1] = ' 0';
i++;
stringconcatenate(ఎస్ 1,ఎస్ 2);
}
}
intప్రధాన()
{
చార్ఎస్ 1[BUF_SIZE],ఎస్ 2[BUF_SIZE];
printf ('మొదటి స్ట్రింగ్ విలువను నమోదు చేయండి:'); / * 1 వ స్ట్రింగ్‌ను ఇన్‌పుట్ చేయడానికి వినియోగదారు సందేశం */
fgets (ఎస్ 1,BUF_SIZE,stdin); / * యూజర్ ఇన్‌పుట్ ఫస్ట్ స్ట్రింగ్, S1 */లో స్టోర్ చేయండి
ఎస్ 1[ strlen (ఎస్ 1)-1] = ' 0';
printf ('రెండవ స్ట్రింగ్ విలువను నమోదు చేయండి:'); / * 2 వ స్ట్రింగ్‌ను ఇన్‌పుట్ చేయడానికి వినియోగదారు సందేశం */
fgets (ఎస్ 2,BUF_SIZE,stdin); / * యూజర్ ఇన్‌పుట్ ఫస్ట్ స్ట్రింగ్, S2 */లో స్టోర్ చేయండి
ఎస్ 2[ strlen (ఎస్ 2)-1] = ' 0';
stringconcatenate(ఎస్ 1,ఎస్ 2); / * S1, S2 తో ఫంక్షన్‌ను పారామితులుగా కాల్ చేయండి */
printf ('తీగల కలయిక ='%s ' n',ఎస్ 1);
తిరిగి 0;
}
ప్రోగ్రామ్ యొక్క స్నాప్‌షాట్‌లు మరియు అవుట్‌పుట్:
విధులు ఉపయోగించి సమ్మేళనం
ఫంక్షన్ strconcatenate () రెండు తీగలను కలపడానికి ప్రధాన () ద్వారా పిలువబడుతుంది.
స్ట్రింగ్‌లెన్ (స్ట్రింగ్ 1) ఉపయోగించి ఫంక్షన్ స్ట్రింగ్ 1 పొడవును పొందుతుంది.
స్ట్రింగ్ 1 [i+j] లో స్ట్రింగ్ 2 [i] మూలకాలను కలపండి. స్ట్రింగ్ ఖాళీ అయ్యే వరకు ఈ దశ పునరావృతమవుతుంది. ఇక్కడ, స్ట్రింగ్ 1 చివరలో స్ట్రింగ్ 2 నుండి స్ట్రింగ్ 1 కి స్ట్రింగ్ 2 కి మేము ప్రక్కనే ఉన్నాము.
లూప్ యొక్క అన్ని పునరావృత్తులు ప్రదర్శించబడినప్పుడు ముగింపు స్ట్రింగ్ (స్ట్రింగ్ 1) అందుతుంది.
ప్రధాన () సంశ్లేషణ స్ట్రింగ్ S1 ప్రింట్ చేస్తుంది
#చేర్చండి#చేర్చండి
#BUF_SIZE 256 ని నిర్వచించండి
/ * పై వివరణ ప్రకారం స్ట్రింగ్ కాన్కానేటేషన్ అమలు చేసే ఫంక్షన్ */
శూన్యంstrconcatenate(చార్ *స్ట్రింగ్ 1, చార్*స్ట్రింగ్ 2)
{
inti;
intజ= strlen (స్ట్రింగ్ 1);
కోసం(i=0;స్ట్రింగ్2[i];i++)
{
స్ట్రింగ్ 1[i+జ]=స్ట్రింగ్ 2[i];
}
స్ట్రింగ్ 1[i+జ]= ' 0';
}
intప్రధాన()
{
చార్స్ట్రింగ్ 1[BUF_SIZE],స్ట్రింగ్ 2[BUF_SIZE];
printf ('మొదటి స్ట్రింగ్‌ని నమోదు చేయండి:'); / * 1 వ స్ట్రింగ్ కోసం వినియోగదారు సందేశం */
fgets (స్ట్రింగ్ 1,BUF_SIZE,stdin); / * వినియోగదారు ఇన్‌పుట్ రెండవ స్ట్రింగ్, స్ట్రింగ్ 1 */లో నిల్వ చేయబడింది
స్ట్రింగ్ 1[ strlen (స్ట్రింగ్ 1)-1] = ' 0';
printf ('రెండవ స్ట్రింగ్‌ని నమోదు చేయండి:'); / * 2 వ స్ట్రింగ్ కోసం వినియోగదారు సందేశం */
fgets (స్ట్రింగ్ 2,BUF_SIZE,stdin); / * వినియోగదారు ఇన్‌పుట్ రెండవ స్ట్రింగ్, స్ట్రింగ్ 2 */లో నిల్వ చేయబడింది
స్ట్రింగ్ 2[ strlen (స్ట్రింగ్ 2)-1] = ' 0';
strconcatenate(స్ట్రింగ్ 1,స్ట్రింగ్ 2); /* ఫంక్షన్‌ను స్ట్రింగ్ 1 మరియు స్ట్రింగ్ 2 తో ఆర్గ్యుమెంట్‌లుగా కాల్ చేయండి*/
printf ('ఫలిత స్ట్రింగ్ = %s' n',స్ట్రింగ్ 1);
తిరిగి 0;
}
ప్రోగ్రామ్ యొక్క స్నాప్‌షాట్‌లు మరియు అవుట్‌పుట్:
మెమ్‌క్పీని ఉపయోగించడం ద్వారా స్ట్రింగ్ కాన్కాటనేషన్
Mmcpy () ఫంక్షన్‌ను ఉపయోగించడం ద్వారా, స్ట్రింగ్ కాన్‌కటనేషన్ అనేది ఒక స్ట్రింగ్ బఫర్ నుండి మరొక స్ట్రింగ్ బఫర్ చివర వరకు పదం ద్వారా కాపీ చేయడం ద్వారా వర్డ్ సైజు 4 బైట్‌లు, మనం 32 బిట్ మెషీన్‌లో రన్ అవుతున్నట్లు పరిగణనలోకి తీసుకుంటే strcat () ఫంక్షన్ ఉపయోగించి స్ట్రింగ్ కాంకెటనేషన్ ఉపయోగించి, ఒక స్ట్రింగ్ బఫర్ నుండి మరొక స్ట్రింగ్ బఫర్‌కు బైట్ ద్వారా బైట్ ద్వారా కాపీ చేయడం ద్వారా కాన్కానేటేషన్ జరుగుతుంది.
ఈ విధానం పనితీరు సమర్థవంతంగా ఉంటుంది.
మెమ్‌క్పీని ఉపయోగించేటప్పుడు పరిగణించవలసిన ఏకైక పరిశీలన ' 0' గురించి జాగ్రత్త తీసుకోవడం.
Mmcpy తో strcat సాధించడానికి C ప్రోగ్రామ్:
#చేర్చండి#చేర్చండి
#BUF_SIZE 256 ని నిర్వచించండి
శూన్యమైన strcat_memcpy(చార్ *ఎస్ 1, చార్ *ఎస్ 2)
{
intపొడవు 1,పొడవు 2;
పొడవు 1= strlen (ఎస్ 1);
పొడవు 2= strlen (ఎస్ 2);
మెమ్‌పిపి (ఎస్ 1+పొడవు 1,ఎస్ 2,పొడవు 2);
}
intప్రధాన()
{
చార్స్ట్రింగ్ 1[BUF_SIZE],స్ట్రింగ్ 2[BUF_SIZE];
printf ('మొదటి స్ట్రింగ్‌ని నమోదు చేయండి:'); / * 1 వ స్ట్రింగ్ కోసం వినియోగదారు సందేశం */
fgets (స్ట్రింగ్ 1,BUF_SIZE,stdin); / * వినియోగదారు ఇన్‌పుట్ రెండవ స్ట్రింగ్, స్ట్రింగ్ 1 */లో నిల్వ చేయబడింది
స్ట్రింగ్ 1[ strlen (స్ట్రింగ్ 1)-1] = ' 0';
printf ('రెండవ స్ట్రింగ్‌ని నమోదు చేయండి:'); / * 2 వ స్ట్రింగ్ కోసం వినియోగదారు సందేశం */
fgets (స్ట్రింగ్ 2,BUF_SIZE,stdin); / * వినియోగదారు ఇన్‌పుట్ రెండవ స్ట్రింగ్, స్ట్రింగ్ 2 */లో నిల్వ చేయబడింది
స్ట్రింగ్ 2[ strlen (స్ట్రింగ్ 2)-1] = ' 0';
strcat_memcpy(స్ట్రింగ్ 1,స్ట్రింగ్ 2); /* ఫంక్షన్‌ను స్ట్రింగ్ 1 మరియు స్ట్రింగ్ 2 తో ఆర్గ్యుమెంట్‌లుగా కాల్ చేయండి*/
printf ('ఫలిత స్ట్రింగ్ = %s' n',స్ట్రింగ్ 1);
తిరిగి 0;
}
ప్రోగ్రామ్ యొక్క స్నాప్‌షాట్‌లు మరియు అవుట్‌పుట్:
ముగింపు:
ఈ చర్చలన్నింటితో మనం సి. లో స్ట్రింగ్ కాంకెంటేషన్‌ను ముగించవచ్చు మేము ప్రధాన అంశాలను గుర్తుచేస్తాము: రెండు మార్గాలు ఉన్నాయి, ఒకటి సి స్టాండర్డ్ మరియు మరొకటి యూజర్ నిర్వచించిన మార్గం. వినియోగదారు నిర్వచించినది అనేక రకాలుగా ఉండవచ్చు, వినియోగదారు స్ట్రింగ్ కాన్కానేషన్‌ను ఎలా అమలు చేయాలనుకుంటున్నారనే దానిపై ఆధారపడి ఉంటుంది.