ఉదాహరణ 1:
ఈ పరిస్థితిలో, మేము తప్పనిసరిగా స్ట్రింగ్‌లు మరియు ఇన్‌పుట్ లేదా అవుట్‌పుట్ డేటాతో పని చేయాలి, కాబట్టి “iostream” మరియు “string” హెడర్ ఫైల్‌లు అందించబడతాయి. కాబట్టి, ఈ హెడర్ ఫైల్‌లను ఇక్కడ చేర్చాలి. ఆ తర్వాత, మన కోడ్‌లో స్వతంత్రంగా ప్రతి ఫంక్షన్‌తో ఈ “std”ని చేర్చాల్సిన అవసరం లేదు, ఎందుకంటే మేము ఇప్పటికే “using” కీవర్డ్ సహాయంతో “namespace std”ని చేర్చాము. ఇక్కడ, 'ప్రధాన ()' ఫంక్షన్ అప్పుడు అంటారు. అప్పుడు, 'ఒరిజినల్ స్ట్రింగ్' అనే 'స్ట్రింగ్' వేరియబుల్ కొంత స్ట్రింగ్‌తో ప్రారంభించబడుతుంది. అప్పుడు, మేము C++ తో 'word' అనే మరొక 'స్ట్రింగ్' వేరియబుల్‌ని ప్రారంభించాము.
ఇప్పుడు, దీని కింద, మేము 'కౌట్' ను ఉపయోగించాము మరియు అసలు స్ట్రింగ్‌ను ప్రింట్ చేస్తాము. దీని తర్వాత, మేము 'int ఫలితం'ని ప్రకటిస్తాము మరియు 'originalString'లో 'పదం' ఉందో లేదో తనిఖీ చేయడానికి 'contains()' ఫంక్షన్‌ను ఉంచుతాము. మేము దాని క్రింద 'if' ఉంచుతాము. మేము 'ఫలితాన్ని' 'if'కి పాస్ చేస్తాము. ఒరిజినల్ స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉన్నట్లయితే, అది మనం “if” తర్వాత జోడించిన స్టేట్‌మెంట్‌ను రెండర్ చేస్తుంది. స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ను కలిగి లేనప్పుడు, “వేరే” తర్వాత ప్రదర్శించబడే స్టేట్‌మెంట్ రెండర్ చేయబడుతుంది.
కోడ్ 1:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ అసలైన స్ట్రింగ్ = 'నాకు C++ ప్రోగ్రామింగ్ అంటే ఇష్టం' ;
స్ట్రింగ్ పదం = 'C++' ;
కోట్ << 'తీగ =' << అసలైన స్ట్రింగ్ << endl << endl ;
int ఫలితం = అసలైన స్ట్రింగ్. కలిగి ఉంటుంది ( పదం ) ;
ఉంటే ( ఫలితం )
{
కోట్ << 'స్ట్రింగ్‌లో కనిపించే పదం =' << పదం << endl ;
}
లేకపోతే
{
కోట్ << 'స్ట్రింగ్‌లో పదం కనుగొనబడలేదు' << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
కలిగి() ఫంక్షన్ సహాయంతో ఒరిజినల్ స్ట్రింగ్‌లో మనం కనుగొన్న సబ్‌స్ట్రింగ్ అసలు స్ట్రింగ్ లోపల కనుగొనబడి ఇక్కడ ప్రదర్శించబడుతుందని ఈ ఫలితం చూపిస్తుంది.
ఉదాహరణ 2:
“iostream” మరియు “string” అనేవి మనం ఈ కోడ్‌లో దిగుమతి చేసుకున్న హెడర్ ఫైల్‌లు. 'std' నేమ్‌స్పేస్ కూడా చేర్చబడింది. అప్పుడు, ప్రధాన()ని ఇక్కడ పిలుస్తారు. తరువాత, మేము కొంత స్ట్రింగ్ డేటాను జోడించడం ద్వారా 'str_1' అని పిలువబడే 'స్ట్రింగ్' వేరియబుల్‌ని ప్రారంభిస్తాము. ఇకపై, మేము 'str_2' అని పిలువబడే 'స్ట్రింగ్' వేరియబుల్‌ను 'రైన్'తో ప్రారంభిస్తాము.
దీని క్రింద, మేము 'కౌట్' ఫంక్షన్ ఉపయోగించి అసలు స్ట్రింగ్‌ను ప్రింట్ చేస్తాము. “str_1”లో “str_2” ఉందో లేదో నిర్ధారించడానికి, మేము “int ఫలితం”ని ప్రకటిస్తాము మరియు కలిగి ఉన్న() పద్ధతిని ఇక్కడ చొప్పిస్తాము. క్రింద, మేము 'if'ని ఉంచుతాము మరియు 'ఫలితం' ను 'if'కి పాస్ చేస్తాము. ఒరిజినల్ స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ ఉంటే “if” రెండర్ చేసిన తర్వాత మేము “cout” స్టేట్‌మెంట్‌ను జోడిస్తాము. లేకపోతే, 'else' తర్వాత వచ్చే 'cout' స్టేట్‌మెంట్ రెండర్ చేయబడుతుంది.
కోడ్ 2:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ str_1 = 'బయట వాతావరణం చల్లగా ఉంది' ;
స్ట్రింగ్ str_2 = 'వర్షం' ;
కోట్ << 'తీగ =' << str_1 << endl << endl ;
int ఫలితం = str_1. కలిగి ఉంటుంది ( str_2 ) ;
ఉంటే ( ఫలితం )
{
కోట్ << 'స్ట్రింగ్‌లో కనిపించే పదం =' << str_2 << endl ;
}
లేకపోతే
{
కోట్ << 'స్ట్రింగ్‌లో పదం కనుగొనబడలేదు' << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
కలిగి() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా ఒరిజినల్ స్ట్రింగ్‌లో మనం కనుగొన్న సబ్‌స్ట్రింగ్ అసలు స్ట్రింగ్‌లో కనిపించదని మరియు ఫలితంగా ఇక్కడ రెండర్ చేయబడిందని ఇది సూచిస్తుంది.
ఉదాహరణ 3:
మేము ఈ కోడ్‌లోని “iostream” మరియు “string” హెడర్ ఫైల్‌లను దిగుమతి చేస్తాము. అప్పుడు, దీని క్రింద, మేము 'namespace std'ని ఉపయోగిస్తాము. అప్పుడు, ప్రధాన() ఇక్కడ సూచించబడుతుంది. ఇప్పుడు, మేము వరుసగా 'myString_1' మరియు 'myString_2' పేర్లతో 'స్ట్రింగ్' డేటా రకం యొక్క రెండు వేరియబుల్స్‌ను ప్రారంభిస్తాము మరియు 'myString_1' వేరియబుల్‌కు సబ్‌స్ట్రింగ్‌ను కనుగొనాలనుకుంటున్న అసలైన స్ట్రింగ్‌ను కేటాయిస్తాము మరియు సబ్‌స్ట్రింగ్ కేటాయించబడుతుంది. “myString_2” వేరియబుల్‌కు.
దీని తర్వాత, మేము 'కౌట్' స్టేట్‌మెంట్‌లో 'myString_1'ని ఉంచడం ద్వారా అసలైన స్ట్రింగ్‌ను ప్రదర్శిస్తాము మరియు 'if'ని ఉంచాము, దీనిలో మేము ఇచ్చిన స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ ఉందో లేదో తనిఖీ చేసే 'contains()' పద్ధతిని ఉపయోగిస్తాము. సబ్‌స్ట్రింగ్ అసలు స్ట్రింగ్‌లో ఉంటే, “కౌట్” సహాయంతో, మేము ఫలితాన్ని అందిస్తాము.
మేము రెండు 'కౌట్' స్టేట్‌మెంట్‌లను ఉంచుతాము, అందులో ఒకటి 'if' తర్వాత ఉంచబడుతుంది మరియు మరొకటి 'else' భాగం తర్వాత జోడించబడుతుంది. అసలు స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉన్నట్లయితే, 'if' తర్వాత 'కౌట్' రెండర్ చేయబడుతుంది. సబ్‌స్ట్రింగ్ కనుగొనబడకపోతే లేదా అసలైన స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ లేకుంటే, 'ఇతర' తర్వాత 'కౌట్' రెండర్ చేయబడుతుంది.
కోడ్ 3:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ myString_1 = 'హాయ్! హలో వరల్డ్' ;
స్ట్రింగ్ myString_2 = 'హలో' ;
కోట్ << 'పూర్తి స్ట్రింగ్' << myString_1 << endl ;
ఉంటే ( myString_1. కలిగి ఉంటుంది ( myString_2 ) ) {
కోట్ << 'ది స్ట్రింగ్ కనుగొనబడింది =' << myString_2 << endl ;
}
లేకపోతే {
కోట్ << 'ది స్ట్రింగ్ ఇక్కడ కనుగొనబడలేదు' << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం మేము కలిగి ఉన్న () పద్ధతిని ఉపయోగించి అసలు స్ట్రింగ్‌లో శోధించే సబ్‌స్ట్రింగ్ అసలు స్ట్రింగ్‌లోనే ఉందని మరియు అది ఇక్కడ చూపబడిందని నిరూపిస్తుంది.
ఉదాహరణ 4:
“iostream” మరియు “string” హెడర్ ఫైల్‌లు ఈ కోడ్‌లోకి దిగుమతి చేయబడ్డాయి. మేము క్రింద ఉన్న “namespace std”ని ఉపయోగించిన తర్వాత ప్రధాన() ఫంక్షన్ ఇక్కడ పిలువబడుతుంది. 'స్ట్రింగ్' డేటా రకం యొక్క రెండు వేరియబుల్స్ యొక్క ప్రారంభాలు వరుసగా 's_1' మరియు 's_2' అని పేరు పెట్టబడ్డాయి. మేము సబ్‌స్ట్రింగ్‌ను కనుగొనాలనుకుంటున్న అసలు స్ట్రింగ్ ఇప్పుడు “s_1” వేరియబుల్‌కు కేటాయించబడింది మరియు సబ్‌స్ట్రింగ్ “s_2” వేరియబుల్‌కు ఇవ్వబడింది. 'కౌట్' స్టేట్‌మెంట్‌లో 's_1'ని చొప్పించడం ద్వారా అసలు స్ట్రింగ్ చూపబడుతుంది.
తరువాత, సరఫరా చేయబడిన స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో తెలుసుకోవడానికి మేము కలిగి ఉన్న() పద్ధతిని ఉపయోగించే “if” నిబంధనను జోడిస్తాము. అసలు స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ ఉన్నట్లయితే మేము అవుట్‌పుట్‌ను “కౌట్” ఉపయోగించి రెండర్ చేస్తాము. రెండు “కౌట్” స్టేట్‌మెంట్‌లు జోడించబడ్డాయి, ఒకటి “if” తర్వాత మరియు మరొకటి కోడ్ యొక్క “else” భాగం తర్వాత. అసలు స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ ఉన్నట్లయితే, 'if' తర్వాత 'కౌట్' రెండర్ చేయబడుతుంది. లేకపోతే, సబ్‌స్ట్రింగ్‌ని ఒరిజినల్ స్ట్రింగ్‌లో గుర్తించలేకపోతే, 'else' క్రింది 'కౌట్' రెండర్ చేయబడుతుంది.
కోడ్ 4:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ s_1 = 'హాయ్! నేను జాక్ ఇక్కడ ఉన్నాను'' ;
స్ట్రింగ్ s_2 = 'పీటర్' ;
కోట్ << 'పూర్తి స్ట్రింగ్ =' << s_1 << endl ;
ఉంటే ( s_1. కలిగి ఉంటుంది ( s_2 ) ) {
కోట్ << 'ది స్ట్రింగ్ కనుగొనబడింది =' << s_2 << endl ;
}
లేకపోతే {
కోట్ << 'ది స్ట్రింగ్ కనుగొనబడలేదు =' << s_2 << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం నుండి చూసినట్లుగా, మేము కలిగి ఉన్న () పద్ధతిని ఉపయోగించి అసలు టెక్స్ట్‌లో శోధించిన సబ్‌స్ట్రింగ్ కోడ్‌లో కనుగొనబడలేదు.
ఉదాహరణ 5:
ఇక్కడ, మేము 'బూస్ట్' లైబ్రరీని ఉపయోగిస్తాము మరియు స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో కనుగొంటాము. ఈ “బూస్ట్” పద్ధతిలో, మేము కలిగి() ఫంక్షన్‌ని కూడా ఉపయోగిస్తాము. కాబట్టి, మేము ఈ కోడ్‌లో “iostream” మరియు “string” హెడర్ ఫైల్‌లతో పాటు “boost/algorithm/string.hpp” హెడర్ ఫైల్‌ను కూడా చేర్చుతాము. మేము 'std'ని ఉంచాము మరియు ఇక్కడ ప్రధాన() పద్ధతిని అమలు చేస్తాము.
అప్పుడు, మేము 'స్ట్రింగ్' డేటా రకం యొక్క 'StringData1' మరియు 'StringData2' వేరియబుల్స్‌ను ప్రకటించాము మరియు స్ట్రింగ్ డేటాను ఇక్కడ ప్రారంభించాము. “bool” డేటా రకం యొక్క “c_result” వేరియబుల్ “boost::algorithm::contains()”తో ప్రారంభించబడింది మరియు మేము ఈ ఫంక్షన్‌లోకి “StringData1” మరియు “StringData2”ని పాస్ చేస్తాము. ఇది ఒరిజినల్ స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్‌ను కూడా కనుగొంటుంది మరియు బూలియన్ ఫలితాన్ని “c_result” వేరియబుల్‌లో నిల్వ చేస్తుంది.
ఇప్పుడు, మేము క్రింద ఉన్న “if”లో “c_result==1”ని ఉంచుతాము. “c_result” యొక్క బూలియన్ విలువ “1” అయితే, “if” తర్వాత స్టేట్‌మెంట్ ప్రదర్శించబడుతుంది. లేకపోతే, అది 'వేరే' భాగం వైపు కదులుతుంది మరియు 'if' తర్వాత ఉన్న స్టేట్‌మెంట్‌ను దాటవేస్తుంది మరియు 'వేరే' భాగం యొక్క స్టేట్‌మెంట్‌ను రెండర్ చేస్తుంది.
కోడ్ 5:
##
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
స్ట్రింగ్ StringData1 = 'నా మొదటి కార్యక్రమం' ;
స్ట్రింగ్ StringData2 = 'ప్రధమ' ;
bool c_ఫలితం = పెంచండి :: అల్గోరిథం :: కలిగి ఉంటుంది ( స్ట్రింగ్‌డేటా1 , StringData2 ) ;
ఉంటే ( c_ఫలితం == 1 )
{
కోట్ << 'ది స్ట్రింగ్' << ''' << స్ట్రింగ్‌డేటా1 << ''' << 'ఉంది' << StringData2 << endl ;
}
లేకపోతే
{
కోట్ << 'ఇచ్చిన పదం స్ట్రింగ్‌లో లేదు.' ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితంలో మనం చూడగలిగే అసలైన స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ ఇప్పుడు కనుగొనబడింది.
ముగింపు
మేము C++ భాష అందించిన కలిగి() పద్ధతిని వివరంగా అన్వేషించాము. మేము కలిగి ఉన్న() ఫంక్షన్ “C+++ 23”లో మాత్రమే అందుబాటులో ఉంటుందని కూడా మేము పేర్కొన్నాము. అసలు స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్‌ను కనుగొనడంలో కలిగి ఉన్న() ఫంక్షన్ సహాయపడుతుందా లేదా స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ ఉందో లేదో తనిఖీ చేయడంలో సహాయపడుతుందా అని మేము అన్వేషించాము మరియు తదనుగుణంగా ఫలితాన్ని అందించాము.