ముందస్తు అవసరం
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేయడానికి ముందు, మీరు సిస్టమ్‌లో g ++ కంపైలర్ ఇన్‌స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్‌ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్‌ను సృష్టించడానికి C ++ సోర్స్ కోడ్‌ను కంపైల్ చేయడానికి అవసరమైన ఎక్స్‌టెన్షన్‌లను ఇన్‌స్టాల్ చేయండి. ఇక్కడ, C ++ కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి విజువల్ స్టూడియో కోడ్ అప్లికేషన్ ఉపయోగించబడింది.
Getline () ఫంక్షన్ ఉపయోగించి స్ట్రింగ్‌ను విభజించండి
నిర్దిష్ట డీలిమిటర్ లేదా సెపరేటర్ కనుగొనబడే వరకు స్ట్రింగ్ లేదా ఫైల్ కంటెంట్ నుండి అక్షరాలను చదవడానికి మరియు ప్రతి పార్స్ స్ట్రింగ్‌ను మరొక స్ట్రింగ్ వేరియబుల్‌లో స్టోర్ చేయడానికి getline () ఫంక్షన్ ఉపయోగించబడుతుంది. స్ట్రింగ్ లేదా ఫైల్ యొక్క పూర్తి కంటెంట్ పార్స్ అయ్యే వరకు ఫంక్షన్ పనిని కొనసాగిస్తుంది. ఈ ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రింద ఇవ్వబడింది.
వాక్యనిర్మాణం:
ఐస్ట్రీమ్&గెట్‌లైన్(ఐస్ట్రీమ్&ఉంది, స్ట్రింగ్&str,చార్డీలిమ్);
ఇక్కడ, మొదటి పరామితి, ప్రవాహం, అక్షరాలు సంగ్రహించబడే వస్తువు. రెండవ పరామితి అనేది స్ట్రింగ్ వేరియబుల్, ఇది సేకరించిన విలువను నిల్వ చేస్తుంది. స్ట్రింగ్‌ను తీయడానికి ఉపయోగించే డీలిమిటర్‌ను సెట్ చేయడానికి మూడవ పరామితి ఉపయోగించబడుతుంది.
స్పేస్ డీలిమిటర్ ఆధారంగా స్ట్రింగ్‌ను విభజించడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ను సృష్టించండి గెట్‌లైన్ () ఫంక్షన్ బహుళ పదాల స్ట్రింగ్ విలువ వేరియబుల్‌గా కేటాయించబడింది మరియు స్పేస్ సెపరేటర్‌గా ఉపయోగించబడింది. సేకరించిన పదాలను నిల్వ చేయడానికి వెక్టర్ వేరియబుల్ ప్రకటించబడింది. తరువాత, వెక్టర్ శ్రేణి నుండి ప్రతి విలువను ముద్రించడానికి ‘for’ లూప్ ఉపయోగించబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన()
{
// విభజించబడే స్ట్రింగ్ డేటాను నిర్వచించండి
గంటలు::స్ట్రింగ్strData= 'సి ++ ప్రోగ్రామింగ్ నేర్చుకోండి';
// డీలిమిటర్‌గా పనిచేసే కాంటెంట్ డేటాను నిర్వచించండి
కానిస్టేట్ చార్వేరుచేయువాడు= '';
// స్ట్రింగ్స్ యొక్క డైనమిక్ అర్రే వేరియబుల్‌ను నిర్వచించండి
గంటలు::వెక్టర్అవుట్‌పుట్ అర్రే;
// స్ట్రింగ్ నుండి స్ట్రీమ్‌ని నిర్మించండి
గంటలు::స్ట్రింగ్‌స్ట్రీమ్స్ట్రీమ్ డేటా(strData);
/ *
ఉపయోగించబడే స్ట్రింగ్ వేరియబుల్‌ని ప్రకటించండి
విభజన తర్వాత డేటాను నిల్వ చేయడానికి
* /
గంటలు::స్ట్రింగ్గంటలు;
/ *
లూప్ విభజించబడిన డేటాను మళ్ళిస్తుంది మరియు
శ్రేణిలో డేటాను చొప్పించండి
* /
అయితే (గంటలు::గెట్‌లైన్(స్ట్రీమ్ డేటా, వాల్, సెపరేటర్)) {
అవుట్‌పుట్ అర్రే.వెనుకకు నెట్టడం(గంటలు);
}
// విభజించబడిన డేటాను ముద్రించండి
గంటలు::ఖరీదు << 'అసలు స్ట్రింగ్:' <<strData<<గంటలు::endl;
// శ్రేణిని చదవండి మరియు విభజించబడిన డేటాను ముద్రించండి
గంటలు::ఖరీదు << ' nస్పేస్ ఆధారంగా స్ట్రింగ్‌ను విభజించిన తర్వాత విలువలు: ' <<గంటలు::endl;
కోసం (దానంతట అదే &గంటలు:అవుట్‌పుట్ అర్రే) {
గంటలు::ఖరీదు <<గంటలు<<గంటలు::endl;
}
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
Strtok () ఫంక్షన్ ఉపయోగించి స్ట్రింగ్‌ను విభజించండి
స్ట్రింగ్ భాగాన్ని డీలిమిటర్ ఆధారంగా టోకనైజ్ చేయడం ద్వారా స్ట్రింగ్‌ను విభజించడానికి strtok () ఫంక్షన్ ఉపయోగించవచ్చు. అది ఉన్నట్లయితే అది తదుపరి టోకెన్‌కు పాయింటర్‌ను అందిస్తుంది; లేకపోతే, అది పూర్తి విలువను అందిస్తుంది. ది string.h ఈ ఫంక్షన్‌ను ఉపయోగించడానికి హెడర్ ఫైల్ అవసరం. లూప్‌కు స్ట్రింగ్ నుండి అన్ని విభజించబడిన విలువలను చదవడం అవసరం. మొదటి ఆర్గ్యుమెంట్ స్ట్రింగ్ విలువను కలిగి ఉంటుంది, రెండవ వాదనలో టోకెన్‌ను రూపొందించడానికి ఉపయోగించే డీలిమిటర్ ఉంటుంది. ఈ ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రింద ఇవ్వబడింది.
వాక్యనిర్మాణం:
చార్ * strtok ( చార్ *str,కానిస్టేట్ చార్ *డీలిమిటర్లు);Strtok () ఫంక్షన్‌ను ఉపయోగించి స్ట్రింగ్‌ను విభజించడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. పెద్దప్రేగు (':') కలిగి ఉన్న కోడ్‌లో అక్షరాల శ్రేణిని సెపరేటర్‌గా నిర్వచించారు. తరువాత, ది strtok () ఫంక్షన్‌ను స్ట్రింగ్ విలువ మరియు మొదటి టోకెన్‌ను రూపొందించడానికి డీలిమిటర్ అని పిలుస్తారు. ది ' అయితే 'వరకు ఇతర టోకెన్లు మరియు టోకెన్ విలువలను రూపొందించడానికి లూప్ నిర్వచించబడింది శూన్య విలువ కనుగొనబడింది.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
intప్రధాన()
{
// అక్షరాల శ్రేణిని ప్రకటించండి
చార్స్ట్రే[] = 'మెహ్రాబ్ హుస్సేన్: IT ప్రొఫెషనల్: [ఇమెయిల్ ప్రొటెక్ట్]: +8801726783423';
// ':' ఆధారంగా మొదటి టోకెన్ విలువను తిరిగి ఇవ్వండి
చార్ *టోకెన్ విలువ= strtok(స్ట్రే,':');
// కౌంటర్ వేరియబుల్‌ను ప్రారంభించండి
intకౌంటర్= 1;
/ *
టోకెన్ విలువను ముద్రించడానికి లూప్‌ని ప్రతిబింబించండి
మరియు పొందడానికి మిగిలిన స్ట్రింగ్ డేటాను విభజించండి
తదుపరి టోకెన్ విలువ
* /
అయితే (టోకెన్ విలువ!= శూన్య)
{
ఉంటే(కౌంటర్== 1)
printf('పేరు: %s n', టోకెన్ విలువ);
లేకపోతే ఉంటే(కౌంటర్== 2)
printf('వృత్తి: %s n', టోకెన్ విలువ);
లేకపోతే ఉంటే(కౌంటర్== 3)
printf('ఇమెయిల్: %s n', టోకెన్ విలువ);
లేకపోతే
printf('మొబైల్ నం: %s n', టోకెన్ విలువ);
టోకెన్ విలువ= strtok(శూన్య,':');
కౌంటర్++;
}
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఫైండ్ () మరియు ఎరేజ్ () ఫంక్షన్‌లను ఉపయోగించి స్ట్రింగ్‌ను విభజించండి
ఫైండ్ () మరియు ఎరేజ్ () ఫంక్షన్‌లను ఉపయోగించడం ద్వారా స్ట్రింగ్‌ను సి ++ లో విభజించవచ్చు. నిర్దిష్ట డీలిమిటర్ ఆధారంగా స్ట్రింగ్ విలువను విభజించడానికి ఫైండ్ () మరియు ఎరేజ్ () ఫంక్షన్ల ఉపయోగాలను తనిఖీ చేయడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. కనుగొనడం () ఫంక్షన్‌ని ఉపయోగించి డీలిమిటర్ పొజిషన్‌ను కనుగొనడం ద్వారా టోకెన్ విలువ రూపొందించబడుతుంది మరియు ఎరేస్ () ఫంక్షన్ ఉపయోగించి డిలిమిటర్‌ను తీసివేసిన తర్వాత టోకెన్ విలువ నిల్వ చేయబడుతుంది. స్ట్రింగ్ యొక్క పూర్తి కంటెంట్ పార్స్ అయ్యే వరకు ఈ పని పునరావృతమవుతుంది. తరువాత, వెక్టర్ శ్రేణి యొక్క విలువలు ముద్రించబడతాయి.
// అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన(){
// స్ట్రింగ్‌ను నిర్వచించండి
గంటలు::స్ట్రింగ్స్ట్రింగ్ డేటా= 'బంగ్లాదేశ్ మరియు జపాన్ మరియు జర్మనీ మరియు బ్రెజిల్';
// విభజనను నిర్వచించండి
గంటలు::స్ట్రింగ్వేరుచేయువాడు= 'మరియు';
// వెక్టర్ వేరియబుల్‌ని ప్రకటించండి
గంటలు::వెక్టర్దేశం{};
// పూర్ణాంక వేరియబుల్‌ని ప్రకటించండి
intస్థానం;
// స్ట్రింగ్ వేరియబుల్‌ని ప్రకటించండి
గంటలు::స్ట్రింగ్outstr, టోకెన్;
/ *
సబ్‌స్ట్రర్ () ఫంక్షన్‌ను ఉపయోగించి స్ట్రింగ్‌ని విభజించండి
మరియు వెక్టర్‌లోకి విడిపోయిన పదాన్ని జోడించడం
* /
అయితే ((స్థానం=స్ట్రింగ్ డేటా.కనుగొనండి(వేరుచేయువాడు)) !=గంటలు::స్ట్రింగ్::npos) {
టోకెన్=స్ట్రింగ్ డేటా.సబ్‌స్ట్రార్(0, స్థానం);
// విడిపోయిన స్ట్రింగ్ ముందు నుండి అదనపు స్థలాన్ని తొలగించండి
దేశం.వెనుకకు నెట్టడం(టోకెన్.చెరిపివేయి(0, టోకెన్.కనుగొనండి_మొదటిది_కాదు('')));
స్ట్రింగ్ డేటా.చెరిపివేయి(0, స్థానం+వేరుచేయువాడు.పొడవు());
}
// చివరిది మినహా అన్ని విడిపోయిన పదాన్ని ముద్రించండి
కోసం (కానిస్టేట్ దానంతట అదే &outstr:దేశం) {
గంటలు::ఖరీదు <<outstr<<గంటలు::endl;
}
// చివరిగా విడిపోయిన పదాన్ని ముద్రించండి
గంటలు::ఖరీదు <<స్ట్రింగ్ డేటా.చెరిపివేయి(0, స్ట్రింగ్ డేటా.కనుగొనండి_మొదటిది_కాదు('')) <<గంటలు::endl;
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ముగింపు
C ++ లో స్ట్రింగ్‌ను విభజించడానికి మూడు విభిన్న మార్గాలు ఈ ట్యుటోరియల్‌లో కొత్త పైథాన్ వినియోగదారులకు C ++ లో సులభంగా స్ప్లిట్ ఆపరేషన్ చేయడంలో సహాయపడటానికి సాధారణ ఉదాహరణలను ఉపయోగించి వివరించబడ్డాయి.