రెండు లేదా అంతకంటే ఎక్కువ తీగలను విలీనం చేసే మార్గాన్ని స్ట్రింగ్ కాన్కాంటేషన్ అంటారు. ఏదైనా ప్రోగ్రామింగ్ లాంగ్వేజ్ కోసం ఇది చాలా సాధారణ పని. కొన్ని ప్రోగ్రామింగ్ భాషలు నిర్దిష్ట ఆపరేటర్ను ఉపయోగిస్తాయి, కొన్ని ప్రోగ్రామింగ్ భాషలు అంతర్నిర్మిత ఫంక్షన్ను ఉపయోగిస్తాయి మరియు కొన్ని ప్రోగ్రామింగ్ భాషలు స్ట్రింగ్ విలువలను కలపడానికి ఆపరేటర్ మరియు అంతర్నిర్మిత ఫంక్షన్ రెండింటినీ ఉపయోగిస్తాయి. C ++ లో ‘+’ ఆపరేటర్ మరియు వివిధ రకాల అంతర్నిర్మిత ఫంక్షన్లను ఉపయోగించడం ద్వారా స్ట్రింగ్ కాన్కనేషన్ చేయవచ్చు. C ++ లో తీగలను కలపడానికి ‘+’ ఆపరేటర్ మరియు విభిన్న అంతర్నిర్మిత ఫంక్షన్ల ఉపయోగాలు ఈ ట్యుటోరియల్లో వివరించబడ్డాయి.
ముందస్తు అవసరం:
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేయడానికి ముందు, మీరు సిస్టమ్లో g ++ కంపైలర్ ఇన్స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్ను సృష్టించడానికి C ++ సోర్స్ కోడ్ను కంపైల్ చేయడానికి అవసరమైన ఎక్స్టెన్షన్లను ఇన్స్టాల్ చేయండి. ఇక్కడ, C ++ కోడ్ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి విజువల్ స్టూడియో కోడ్ అప్లికేషన్ ఉపయోగించబడింది.
స్ట్రింగ్ సంగ్రహణ కోసం '+' ఆపరేటర్ని ఉపయోగించడం:
'+' ఆపరేటర్ను ఉపయోగించడం అనేది రెండు తీగలను కలపడానికి సులభమైన మార్గం. '+' ఆపరేటర్ని ఉపయోగించి రెండు తీగలను కలపడానికి కింది కోడ్తో C ++ ఫైల్ని సృష్టించండి. కోడ్ ప్రారంభంలో రెండు ఖాళీ స్ట్రింగ్ వేరియబుల్స్ ప్రకటించబడ్డాయి. వినియోగదారు నుండి తీసుకున్న ఇన్పుట్ను నిల్వ చేయడానికి ఈ వేరియబుల్స్ ఉపయోగించబడ్డాయి. తరువాత, తర్వాత ముద్రించిన కొత్త స్ట్రింగ్ని రూపొందించడానికి రెండు విలువలు కలిపాయి.
// అవసరమైన లైబ్రరీలను చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన()
{
// రెండు స్ట్రింగ్ వేరియబుల్స్ ఆలస్యం చేయండి
గంటలు::స్ట్రింగ్strData1='', strData2='';
// వినియోగదారు నుండి రెండు స్ట్రింగ్ విలువలను తీసుకోండి
గంటలు::ఖరీదు<<'మొదటి స్ట్రింగ్ని నమోదు చేయండి:';
గంటలు::జిన్>>strData1;
గంటలు::ఖరీదు<<'రెండవ స్ట్రింగ్ని నమోదు చేయండి:';
గంటలు::జిన్>>strData2;
// స్ట్రింగ్ విలువలను కలపండి
గంటలు::స్ట్రింగ్కలపండి=strData1+strData2;
// అనుసంధానమైన స్ట్రింగ్ విలువను ముద్రించండి
గంటలు::ఖరీదు << 'కాంకటేటెడ్ స్ట్రింగ్:' <<కలపండి<< ' n';
తిరిగి 0;
}
అవుట్పుట్:
వినియోగదారు టైప్ చేస్తే ' హలో 'మరియు' ప్రపంచ కోడ్ను అమలు చేసిన తర్వాత ఇన్పుట్ విలువలుగా, కింది అవుట్పుట్ కనిపిస్తుంది.
స్ట్రింగ్ సంగ్రహణ కోసం ఒక లూప్ను ఉపయోగించడం:
చార్ శ్రేణి యొక్క స్ట్రింగ్ విలువలను కలపడానికి లూప్ను ఉపయోగించడం మరొక మార్గం. రెండు చార్ శ్రేణి వేరియబుల్స్లో నిల్వ చేసిన స్ట్రింగ్ విలువలను కలపడం కోసం ‘for’ లూప్ని ఉపయోగించడాన్ని తనిఖీ చేయడానికి క్రింది కోడ్తో C ++ ఫైల్ని సృష్టించండి. రెండు స్ట్రింగ్ వేరియబుల్స్ మరియు 100 మూలకాల యొక్క రెండు చార్ శ్రేణులు కోడ్లో ప్రకటించబడ్డాయి. ఇన్పుట్ విలువలు స్ట్రింగ్ వేరియబుల్స్లో నిల్వ చేయబడతాయి మరియు strcpy () ఫంక్షన్ స్ట్రింగ్ విలువలను చార్ శ్రేణులలో నిల్వ చేస్తుంది. తరువాత, మొదటి చార్ శ్రేణి యొక్క పొడవు మొదటి చార్ శ్రేణి చివరిలో రెండవ చార్ శ్రేణి యొక్క కంటెంట్ను జోడించడానికి ‘ఫర్’ లూప్లో లెక్కించబడుతుంది మరియు ఉపయోగించబడింది. రెండవ చార్ శ్రేణిలోని అన్ని మూలకాలను కలిపిన తర్వాత మొదటి చార్ శ్రేణి యొక్క విలువలు ముద్రించబడతాయి.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్స్పేస్గంటలు;
intప్రధాన()
{
// రెండు స్ట్రింగ్ వేరియబుల్స్ ఆలస్యం చేయండి
చార్chrData1[100], chrData2[100];
// స్ట్రింగ్ వేరియబుల్ని ప్రకటించండి
స్ట్రింగ్ strData1, strData2;
// మొదటి స్ట్రింగ్ డేటాను తీసుకొని దానిని అక్షర శ్రేణిగా మార్చండి
ఖరీదు<<'మొదటి స్ట్రింగ్ని నమోదు చేయండి:';
జిన్>>strData1;
strcpy(chrData1, strData1.c_str());
// రెండవ స్ట్రింగ్ డేటాను తీసుకొని దానిని అక్షర శ్రేణిగా మార్చండి
ఖరీదు<<'రెండవ స్ట్రింగ్ని నమోదు చేయండి:';
జిన్>>strData2;
strcpy(chrData2, strData2.c_str());
// మొదటి అక్షర శ్రేణి యొక్క మొత్తం మూలకాన్ని లెక్కించండి
intలెన్= strlen(chrData1);
/ *
యొక్క అన్ని మూలకాలను చొప్పించడానికి లూప్ను ప్రతిబింబించండి
రెండవ అక్షర శ్రేణి
మొదటి అక్షర శ్రేణికి
* /
కోసం(inti=0;i< పరిమాణం(chrData2);i++)
{
chrData1[లెన్] =chrData2[i];
లెన్++;
}
// కన్యాక్టినేటెడ్ అవుట్పైట్ను ముద్రించండి
ఖరీదు << 'సమన్వయ స్ట్రింగ్:' <<chrData1<<endl;
తిరిగి 0;
}
అవుట్పుట్:
కోడ్ను అమలు చేసిన తర్వాత వినియోగదారు 'Linux' మరియు 'Hint' లను ఇన్పుట్ విలువలుగా టైప్ చేస్తే, కింది అవుట్పుట్ కనిపిస్తుంది.
స్ట్రింగ్ సంగ్రహణ కోసం strcat () ఫంక్షన్ను ఉపయోగించడం:
ది strcat () రెండు స్ట్రింగ్ విలువలను కలపడానికి అంతర్నిర్మిత ఫంక్షన్. ఇది ఆర్గ్యుమెంట్ విలువలు మరియు శ్రేణుల సమన్వయ విలువగా రెండు చార్ శ్రేణులను తీసుకుంటుంది. ఈ ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రింద ఇవ్వబడింది.
వాక్యనిర్మాణం:
strcat(చార్ *శ్రేణి 1,చార్ *శ్రేణి 2)Strcat () ఫంక్షన్ను ఉపయోగించి రెండు చార్ శ్రేణుల విలువను కలపడానికి కింది కోడ్తో C ++ ఫైల్ని సృష్టించండి. వినియోగదారు నుండి తీసుకున్న ఇన్పుట్ విలువలను నిల్వ చేయడానికి కోడ్లో రెండు చార్ శ్రేణులు ప్రకటించబడ్డాయి. తరువాత, strcat () ఫంక్షన్ రెండు చార్ శ్రేణుల సమ్మేళన విలువను ముద్రించడానికి ఉపయోగించబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్స్పేస్గంటలు;
intప్రధాన()
{
// రెండు స్ట్రింగ్ వేరియబుల్స్ ఆలస్యం చేయండి
చార్chrData1[100], chrData2[100];
// మొదటి స్ట్రింగ్ డేటాని తీసుకోండి
ఖరీదు<<'మొదటి స్ట్రింగ్ని నమోదు చేయండి:';
జిన్.గెట్లైన్(chrData1,100);
// రెండవ స్ట్రింగ్ డేటాను తీసుకోండి
ఖరీదు<<'రెండవ స్ట్రింగ్ని నమోదు చేయండి:';
జిన్.గెట్లైన్(chrData2,100);
// సమ్మిళిత స్ట్రింగ్ను ముద్రించండి
ఖరీదు << 'సమన్వయ స్ట్రింగ్:' << strcat(chrData1, chrData2) <<endl;
ఖరీదు <<chrData1;
తిరిగి 0;
}
అవుట్పుట్:
వినియోగదారు టైప్ చేస్తే ' సి ++ 'మరియు' ప్రోగ్రామింగ్ కోడ్ను అమలు చేసిన తర్వాత ఇన్పుట్ విలువలుగా, కింది అవుట్పుట్ కనిపిస్తుంది.
స్ట్రింగ్ సంగ్రహణ కోసం అనుబంధం () ఫంక్షన్ను ఉపయోగించడం:
ది జోడించు () అనేది రెండు అంతర్నిర్మిత ఫంక్షన్, ఇది రెండు స్ట్రింగ్ విలువల యొక్క సమన్వయ స్ట్రింగ్ను అందిస్తుంది మరియు ఆర్గ్యుమెంట్లో స్ట్రింగ్ తీసుకుంటుంది. ఈ ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రింద ఇవ్వబడింది.
వాక్యనిర్మాణం:
స్ట్రింగ్&స్ట్రింగ్::అనుబంధం ( కానిస్టేట్స్ట్రింగ్&p)అనుబంధం () ఫంక్షన్ని ఉపయోగించి రెండు స్ట్రింగ్ విలువలను కలపడానికి క్రింది కోడ్తో C ++ ఫైల్ని సృష్టించండి. నాలుగు స్ట్రింగ్ వేరియబుల్స్ కోడ్లో ప్రకటించబడ్డాయి. ఒక స్ట్రింగ్ వేరియబుల్ కాంకినేటెడ్ స్ట్రింగ్ విలువను నిల్వ చేస్తుంది, మరియు మూడు స్ట్రింగ్ విలువలు ఇతర మూడు వేరియబుల్స్లో నిల్వ చేయబడ్డాయి. మూడు స్ట్రింగ్ వేరియబుల్స్ విలువలను కలపడానికి మరియు తరువాత ముద్రించిన అవుట్స్టెర్ వేరియబుల్లోకి విలువలను జోడించడానికి అనుబంధంలో () ఫంక్షన్ మూడుసార్లు కోడ్లో పిలువబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
ఉపయోగించి నేమ్స్పేస్గంటలు;
intప్రధాన()
{
// అవుట్పుట్ వేరియబుల్ని ప్రకటించండి
స్ట్రింగ్ outstr;
// మూడు స్ట్రింగ్ విలువలను కేటాయించండి
స్ట్రింగ్ స్ట్రింగ్ 1= 'నేను';
స్ట్రింగ్ స్ట్రింగ్ 2= 'ఇష్టం';
స్ట్రింగ్ స్ట్రింగ్ 3= 'ప్రోగ్రామింగ్.';
// అవుట్పుట్ వేరియబుల్కు మూడు స్ట్రింగ్ని జోడించండి
outstr.అనుబంధం(స్ట్రింగ్ 1);
outstr.అనుబంధం(స్ట్రింగ్ 2);
outstr.అనుబంధం(స్ట్రింగ్ 3);
// సంయోగపు అవుట్పుట్ను ముద్రించండి
ఖరీదు << 'సమన్వయ స్ట్రింగ్:' <<outstr<< ' n';
తిరిగి 0;
}
అవుట్పుట్:
పై కోడ్ను అమలు చేసిన తర్వాత కింది అవుట్పుట్ కనిపిస్తుంది.
ముగింపు:
C ++ లో తీగలను కలపడానికి వివిధ మార్గాలు నాలుగు సాధారణ ఉదాహరణలను ఉపయోగించి ఈ ట్యుటోరియల్లో వివరించబడ్డాయి. స్ట్రింగ్ విలువలు అంతర్నిర్మిత ఫంక్షన్ను ఉపయోగించి మరియు సి ++ లో అంతర్నిర్మిత ఫంక్షన్ను ఉపయోగించకుండా కలపవచ్చు. C ++ ప్రోగ్రామర్ స్ట్రింగ్ విలువలను కలపడానికి ఇక్కడ చూపిన ఏవైనా మార్గాలను ఉపయోగించవచ్చు.