C++లో, మేము స్ట్రింగ్ డేటా రకాన్ని కలిగి ఉన్నాము మరియు స్ట్రింగ్‌లతో వివిధ పనులను చేయడానికి వివిధ ఫంక్షన్‌లను వర్తింపజేయవచ్చు. అసలు స్ట్రింగ్ లోపల సబ్‌స్ట్రింగ్ ఉందో లేదో మేము తనిఖీ చేయవచ్చు. 'స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ను కలిగి ఉంది' అని కూడా మనం చెప్పగలం. ఈ గైడ్‌లో, “స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉంది” అని కనుగొనడంలో మాకు సహాయపడే పద్ధతులను మేము నేర్చుకుంటాము. C++ ప్రోగ్రామింగ్‌లో ఈ పనిని చేయడంలో “find()” మరియు “strstr()” ఫంక్షన్‌లు మాకు సహాయపడతాయి.
ఉదాహరణ 1:
'iostream' మరియు 'string' అనేవి ఇక్కడ చేర్చబడిన హెడర్ ఫైల్‌లు, ఎందుకంటే మనం స్ట్రింగ్‌లతో పని చేయాల్సి ఉంటుంది మరియు డేటాను ఇన్‌పుట్ లేదా అవుట్‌పుట్ చేయాలి. కాబట్టి, మనం తప్పనిసరిగా ఈ హెడర్ ఫైల్‌లను ఇక్కడ చేర్చాలి. దీని తర్వాత, మేము 'ఉపయోగించు' కీవర్డ్ సహాయంతో 'namespace std'ని చేర్చుతాము. కాబట్టి, మన కోడ్‌లో అన్ని ఫంక్షన్‌లతో ఈ “std”ని విడిగా ఉంచాల్సిన అవసరం లేదు. అప్పుడు, 'ప్రధాన()' ఫంక్షన్ ఇక్కడ ప్రారంభించబడుతుంది.
ఇప్పుడు, మేము “str_1” స్ట్రింగ్‌ను ప్రకటించాము మరియు ఈ వేరియబుల్‌కు కొంత స్ట్రింగ్ డేటాను కేటాయిస్తాము. అప్పుడు, మేము 'str_2' అనే 'స్ట్రింగ్' డేటా రకం యొక్క మరొక వేరియబుల్‌ని కూడా ప్రారంభించాము మరియు ఈ 'str_2' వేరియబుల్‌కి 'ఇష్టం'ని కేటాయిస్తాము. దీని క్రింద, మేము నిజమైన లేదా తప్పుడు ఫలితాలను అందించడానికి “బూల్” కీవర్డ్‌ని ఉపయోగిస్తాము. మేము ఈ “బూల్” డేటా రకంతో “stringHasStr”ని ప్రారంభిస్తాము మరియు “find()” ఫంక్షన్‌ని ఉపయోగిస్తాము. ఇది 'స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉంది' అని శోధిస్తుంది. “str_1” అనేది పూర్తి స్ట్రింగ్ మరియు “str_2” అనేది సబ్‌స్ట్రింగ్.
ఇక్కడ, మేము ఈ స్ట్రింగ్‌లో సరిపోలికలు లేవని చూపించడానికి ఉపయోగించబడే “npos” కీవర్డ్‌ను కూడా జోడిస్తాము. ఇది స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ ఉందో లేదో తనిఖీ చేస్తుంది మరియు ఫలితాన్ని ఈ “stringHasStr” బూల్ వేరియబుల్‌లో నిల్వ చేస్తుంది.
అప్పుడు, మేము 'if' కండిషన్ వైపు ముందుకు వెళ్తాము మరియు ఈ 'stringHasStr' వేరియబుల్‌ని ఈ 'if' కండిషన్‌కు పాస్ చేస్తాము. ఈ బూల్ వేరియబుల్‌లో నిల్వ చేయబడిన ఫలితం “నిజం” అయితే, ఈ “if” కండిషన్ తర్వాత స్టేట్‌మెంట్‌ని మేము ఉపయోగించినప్పుడు “cout”ని ఉపయోగిస్తాము మరియు ఇక్కడ కనిపించే స్ట్రింగ్‌ను ప్రదర్శిస్తాము. కానీ 'తప్పుడు' ఫలితం ఈ బూల్ వేరియబుల్‌లో నిల్వ చేయబడితే, ఇతర భాగం అమలు చేయబడుతుంది మరియు స్ట్రింగ్ ఇక్కడ కనుగొనబడలేదని ప్రదర్శిస్తుంది.
కోడ్ 1:
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
స్ట్రింగ్ str_1 = 'నాకు C++ ప్రోగ్రామింగ్ లాంగ్వేజ్ ఇష్టం' ;
స్ట్రింగ్ str_2 = 'ఇష్టం' ;
bool stringHasStr = str_1.find ( str_2 ) ! = స్ట్రింగ్ ::npos;
ఉంటే ( stringHasStr ) {
కోట్ << 'మేము ఇక్కడ స్ట్రింగ్‌ని కనుగొన్నాము' << str_2 << endl;
}
లేకపోతే {
కోట్ << 'ది స్ట్రింగ్ కనుగొనబడలేదు' << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఇచ్చిన అవుట్‌పుట్ స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ను కలిగి ఉందని మరియు దానిని ఇక్కడ ప్రదర్శిస్తుందని రెండర్ చేస్తుంది. “find()” ఫంక్షన్‌ని ఉపయోగించడం ద్వారా మేము దీన్ని తనిఖీ చేస్తాము.
ఉదాహరణ 2:
మేము ఇక్కడ 'iostream', 'string' మరియు 'cstring' అనే మూడు హెడర్ ఫైల్‌లను చేర్చాము. ఆపై, 'నేమ్‌స్పేస్ std'ని ఉంచిన తర్వాత 'ప్రధాన()'ని పిలవండి. “new_str” స్ట్రింగ్ ఇప్పుడు ప్రకటించబడింది మరియు కొంత స్ట్రింగ్ డేటా కేటాయించబడింది.
తరువాత, మేము 'sub_str' అని పిలువబడే 'స్ట్రింగ్' డేటా రకం యొక్క రెండవ వేరియబుల్‌ని ప్రారంభించాము మరియు దానికి 'వెరీ' విలువను ఇస్తాము. అప్పుడు, మేము 'const char*' ను ఉంచుతాము. కాబట్టి, పాయింటర్ విలువను మెమరీలోని ఇతర స్థానానికి సూచించడానికి మార్చడం అసాధ్యం. మేము ఇక్కడ “FindingStr” వేరియబుల్‌ని ఈ “const char*” పాయింటర్‌గా ప్రకటిస్తాము. మేము దానిని “strstr()” పద్ధతితో ప్రారంభించాము మరియు “c_str()” ఫంక్షన్‌తో పాటు రెండు స్ట్రింగ్‌లను పాస్ చేస్తాము, అది స్ట్రింగ్‌ను శూన్య విలువతో ముగిసే అక్షర శ్రేణిగా మారుస్తుంది. ఈ “strstr()” పద్ధతి “new_str” స్ట్రింగ్‌లో “sub_str” సబ్‌స్ట్రింగ్ ఉందో లేదో తనిఖీ చేయడంలో సహాయపడుతుంది. అప్పుడు, మనకు “if” ఉంది, దీనిలో మనం “FindingStr”ని జోడిస్తాము. అది ఒరిజినల్‌లో సబ్‌స్ట్రింగ్‌ని కనుగొంటే, మనం “కౌట్”ని ఉపయోగించుకునే చోట “if” తర్వాత స్టేట్‌మెంట్ అమలు చేయబడుతుంది. సబ్‌స్ట్రింగ్ కనుగొనబడకపోతే, అది నేరుగా 'వేరే' భాగం వైపు కదులుతుంది మరియు 'వేరే' భాగం తర్వాత ఉంచబడిన ఫలితాన్ని ముద్రిస్తుంది.
కోడ్ 2:
##
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
స్ట్రింగ్ new_str = 'బయట వర్షం పడుతోంది మరియు వాతావరణం చాలా ఆహ్లాదకరంగా ఉంది.' ;
స్ట్రింగ్ sub_str = 'చాలా' ;
కాన్స్ట్ చార్ * FindingStr = strstr ( కొత్త_str.c_str ( ) , sub_str.c_str ( ) ) ;
ఉంటే ( FindingStr ) {
కోట్ << 'మేము స్ట్రింగ్‌ని కనుగొన్నాము మరియు స్ట్రింగ్: ' << sub_str << endl;
}
లేకపోతే {
కోట్ << 'స్ట్రింగ్ కనుగొనబడలేదు' << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
'if' తర్వాత మేము జోడించిన స్టేట్‌మెంట్‌ను ప్రదర్శించి, సబ్‌స్ట్రింగ్‌ను ఇక్కడ ప్రింట్ చేస్తున్నందున, అందించిన స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ను కలిగి ఉందని మేము గమనించవచ్చు. మేము “strstr()” ఫంక్షన్‌ని ఉపయోగించడం ద్వారా దీన్ని తనిఖీ చేస్తాము.
ఉదాహరణ 3:
మేము ఇక్కడ రెండు స్ట్రింగ్ వేరియబుల్స్ ప్రారంభించాము: 'myNewStr' మరియు 'mySubStr'. అప్పుడు, మేము కొంత స్ట్రింగ్ డేటాను కేటాయిస్తాము మరియు రెండు పూర్ణాంకాల వేరియబుల్‌లను ప్రకటిస్తాము: “posOfStr” మరియు “indexOfStr”.
దీని క్రింద, మేము “while()” లూప్‌ని ఉపయోగిస్తాము మరియు ఈ “while()” లూప్‌లోని “indexOfStr” వేరియబుల్‌కు “find()” ఫంక్షన్ వేరియబుల్‌ను కేటాయిస్తాము. మేము ఈ “find()” ఫంక్షన్‌కి “mySubStr” మరియు “posOfStr” అనే రెండు వేరియబుల్స్‌ని పాస్ చేస్తాము. అప్పుడు, మేము “npos” కీవర్డ్‌ని ఉంచుతాము, ఇది “find” ఫంక్షన్ యొక్క ఫలితం “npos”కి సమానంగా లేదని తనిఖీ చేస్తుంది. దీని తరువాత, మేము ఇండెక్స్ విలువను ఒకదానితో ఒకటి పెంచే 'cout'ని ఉపయోగిస్తాము మరియు దానిని 'posOfStr' వేరియబుల్‌లో నిల్వ చేస్తాము.
కోడ్ 3:
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
స్ట్రింగ్ myNewStr = 'మేము ఇక్కడ స్ట్రింగ్‌ని కనుగొంటాము' ;
స్ట్రింగ్ mySubStr = 'తీగ' ;
int posOfStr = 0 ;
int indexOfStr;
అయితే ( ( indexOfStr = myNewStr.find ( mySubStr, posOfStr ) ) ! = స్ట్రింగ్ ::npos ) {
కోట్ << 'సబ్‌స్ట్రింగ్ అనేది' << ''' << mySubStr << ''' << 'సూచిక సంఖ్య వద్ద కనుగొనబడింది :' << indexOfStr << endl;
posOfStr = indexOfStr + 1 ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, ఇచ్చిన స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉందని మరియు ఈ స్ట్రింగ్ యొక్క సూచిక సంఖ్య “19” అని చూపిస్తుంది, ఇది ఈ ఫలితంలో కూడా ప్రదర్శించబడుతుంది.
ఉదాహరణ 4:
ఈ కోడ్‌లో, మేము “bits/stdc++.h” హెడర్ ఫైల్‌ని చేర్చుతాము. ఇప్పుడు, అవసరమైన అన్ని లైబ్రరీలను కలిగి ఉన్నందున మేము ఇతర హెడర్ ఫైల్‌లను చేర్చాల్సిన అవసరం లేదు. “main()”ని ప్రారంభించిన తర్వాత, మేము “string” డేటా రకం యొక్క “org_str” మరియు “sub_str” వేరియబుల్‌లను ప్రారంభిస్తాము. అప్పుడు, మేము 'strstr()' ఫంక్షన్‌ని ఉపయోగించుకునే 'if' కండిషన్‌ను జోడిస్తాము. ఇచ్చిన స్ట్రింగ్‌లో కావలసిన సబ్‌స్ట్రింగ్ ఉందో లేదో తెలుసుకోవడానికి ఈ ఫంక్షన్ శోధిస్తుంది. ఆపై, సబ్‌స్ట్రింగ్ ఇక్కడ కనుగొనబడిందని ప్రింట్ చేయడానికి మేము “కౌట్” స్టేట్‌మెంట్‌ను జోడిస్తాము. అప్పుడు, 'if' షరతు సంతృప్తి చెందనప్పుడు లేదా స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ కనుగొనబడనప్పుడు మాత్రమే అమలు చేయబడే 'else' భాగాన్ని కూడా ఉంచాము.
దీని తర్వాత, మేము “sub_str2” వేరియబుల్‌ని ప్రకటించి, ఇక్కడ స్ట్రింగ్ డేటాను కేటాయిస్తాము. అప్పుడు “if” షరతు చొప్పించబడుతుంది మరియు “strstr()” ఫంక్షన్ ఉపయోగించబడుతుంది. ఈ పద్ధతి సరఫరా చేయబడిన స్ట్రింగ్ అభ్యర్థించిన సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో శోధిస్తుంది. 'కౌట్' ఆదేశాన్ని ఉపయోగించి ఫలితం ఇక్కడ ముద్రించబడుతుంది. మేము 'వేరే' విభాగాన్ని కూడా చేర్చుతాము, అది 'if' షరతుకు అనుగుణంగా లేకుంటే లేదా స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్‌ని గుర్తించలేకపోతే మాత్రమే అమలు చేయబడుతుంది.
కోడ్ 4:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
స్ట్రింగ్ org_str = 'C++ ప్రోగ్రామింగ్ లాంగ్వేజ్' ;
స్ట్రింగ్ sub_str = 'కార్యక్రమం' ;
ఉంటే ( strstr ( org_str.c_str ( ) ,sub_str.c_str ( ) ) )
{
కోట్ << 'ఇక్కడ ఉన్న సబ్‌స్ట్రింగ్' << ''' << sub_str << ''' << 'లో ఉంది' << org_str << endl;
}
లేకపోతే {
కోట్ << 'సబ్‌స్ట్రింగ్ స్ట్రింగ్‌లో లేదు.' << endl;
}
స్ట్రింగ్ sub_str2 = 'జావా' ;
ఉంటే ( strstr ( org_str.c_str ( ) ,sub_str2.c_str ( ) ) )
{
కోట్ << 'ఇక్కడ ఉన్న సబ్‌స్ట్రింగ్' << ''' << sub_str2 << ''' << 'లో ఉంది' << org_str << endl;
}
లేకపోతే {
కోట్ << 'ఈ స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ లేదు.' << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మొదటి “strstr()” ఫంక్షన్ ఫలితం స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉందని చూపిస్తుంది, అయితే రెండవ “strstr()” ఫంక్షన్ ఫలితం స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ లేదని చూపిస్తుంది.
ముగింపు
ఈ గైడ్‌లో “స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉంది” అనే భావన పూర్తిగా పరిశీలించబడింది. 'స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉందా' అని శోధించడంలో సహాయపడే రెండు పద్ధతులను మేము అన్వేషించాము. ఈ పనిని చేయడం కోసం ఈ గైడ్‌లో C++ అందించే “find()” అలాగే “strstr()” ఫంక్షన్‌లను మేము వివరించాము. 'స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ను కలిగి ఉందా' అని తనిఖీ చేయడానికి ఈ ఫంక్షన్‌లను ఎలా ఉపయోగించాలో మేము నేర్చుకున్న ప్రత్యేకమైన ఉదాహరణలతో మేము ప్రదర్శిస్తాము.