ముందస్తు అవసరం
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేయడానికి ముందు, మీరు సిస్టమ్‌లో g ++ కంపైలర్ ఇన్‌స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్‌ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్‌ను సృష్టించడానికి C ++ సోర్స్ కోడ్‌ను కంపైల్ చేయడానికి అవసరమైన ఎక్స్‌టెన్షన్‌లను ఇన్‌స్టాల్ చేయండి. ఇక్కడ, C ++ కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి విజువల్ స్టూడియో కోడ్ అప్లికేషన్ ఉపయోగించబడింది.
Find_first_of () ఫంక్షన్ ఫీచర్లు
ది మొదటి_ని కనుగొనండి () ఫంక్షన్ మొదటి ఆర్గ్యుమెంట్ విలువ ఆధారంగా వివిధ రకాల వేరియబుల్స్‌ను తిరిగి ఇవ్వగలదు. మొదటి ఆర్గ్యుమెంట్ విలువ స్ట్రింగ్ అయితే ఇది స్ట్రింగ్ యొక్క సెర్చ్ పొజిషన్‌ను అందిస్తుంది. మొదటి ఆర్గ్యుమెంట్‌లో అక్షరాల శ్రేణికి పాయింటర్ ఇవ్వబడితే అది అక్షర స్ట్రింగ్ యొక్క శోధన స్థానాన్ని అందిస్తుంది. మూడవ ఆర్గ్యుమెంట్ విలువ ఇస్తే అది బఫర్ పొజిషన్‌ని అందిస్తుంది. మొదటి ఆర్గ్యుమెంట్‌లో ఒక క్యారెక్టర్ ఇవ్వబడితే మరియు అది ప్రధాన స్ట్రింగ్‌లో ఉంటే అది క్యారెక్టర్ పొజిషన్‌ను అందిస్తుంది. శోధన యొక్క ప్రారంభ స్థానం ఈ ఫంక్షన్ యొక్క రెండవ వాదనలో సెట్ చేయబడింది. ఈ ఫంక్షన్ యొక్క విభిన్న వాక్యనిర్మాణం క్రింద ఇవ్వబడింది.
వాక్యనిర్మాణం
స్ట్రింగ్ size_t find_first_of (const స్ట్రింగ్ & str, size_t pos = 0) const;
c-string size_t find_first_of (const char* s, size_t pos = 0) const;
బఫర్ సైజు_ఫస్ట్_ఫస్ట్_ఫస్ట్ (const char* s, size_t pos, size_t n) const;
అక్షర పరిమాణం_ఫస్ట్_ఫస్ట్_ఫోర్ట్ (చార్ సి, సైజ్_టి పోస్ = 0) కాన్స్ట్
ఉదాహరణ 1: స్ట్రింగ్ యొక్క నిర్దిష్ట అక్షరాన్ని శోధించండి మరియు భర్తీ చేయండి
కింది ఉదాహరణ స్ట్రింగ్‌లో నిర్దిష్ట అక్షరం యొక్క స్థానాన్ని శోధించే మార్గాన్ని చూపుతుంది. నిర్దిష్ట అక్షరాన్ని మరొక అక్షరంతో భర్తీ చేయడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. కోడ్‌లో, ది మొదటి_ని కనుగొనండి () ఫంక్షన్ స్ట్రింగ్‌లో ఒక నిర్దిష్ట అక్షరం యొక్క అన్ని స్థానాలను శోధించడానికి మరియు లూప్‌ను ఉపయోగించడం ద్వారా అక్షరాలను మరొక అక్షరంతో భర్తీ చేయడానికి ఉపయోగించబడింది. కోడ్ అమలు చేసిన తర్వాత అసలు స్ట్రింగ్ మరియు భర్తీ చేయబడిన స్ట్రింగ్ ముద్రించబడుతుంది.
// అవుట్‌పుట్‌ను ముద్రించడానికి చేర్చండి
#చేర్చండి
// size_t ఉపయోగించడానికి చేర్చండి
#చేర్చండి
intప్రధాన()
{
// స్ట్రింగ్ వేరియబుల్‌ను ప్రారంభించండి
గంటలు::స్ట్రింగ్strData('LinuxHint కి స్వాగతం');
// అసలు స్ట్రింగ్‌ను ముద్రించండి
గంటలు::ఖరీదు << 'అసలు స్ట్రింగ్:' +strData<< ' n';
// 'i' అక్షరం యొక్క అన్ని స్థానాలను కనుగొనండి
గంటలు::పరిమాణం_టిశోధన జాబితా=strData.మొదటి_ని కనుగొనండి('నేను');
// అన్ని 'i' ని '@' ద్వారా భర్తీ చేయడానికి లూప్‌ను పునరుద్ఘాటించండి
అయితే (శోధన జాబితా!=గంటలు::స్ట్రింగ్::npos)
{
strData[శోధన జాబితా] = '@';
శోధన జాబితా=strData.మొదటి_ని కనుగొనండి('నేను', శోధన జాబితా+1);
}
// సవరించిన స్ట్రింగ్‌ను ముద్రించండి
గంటలు::ఖరీదు << 'సవరించిన స్ట్రింగ్:' +strData<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఉదాహరణ 2: శోధించే అక్షరాల మొదటి స్థానాన్ని శోధించండి
బహుళ అక్షరాల స్ట్రింగ్ యొక్క స్థానాన్ని శోధించడానికి మరియు ప్రధాన స్ట్రింగ్‌తో సరిపోయే అక్షరం యొక్క మొదటి స్థానాన్ని తిరిగి ఇవ్వడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. స్ట్రింగ్ వేరియబుల్‌లో స్ట్రింగ్ డేటా కేటాయించబడింది మరియు మొదటి స్థానం పూర్ణాంక వేరియబుల్‌లో నిల్వ చేయబడుతుంది. కోడ్‌ని అమలు చేసిన తర్వాత స్థాన విలువ ముద్రించబడుతుంది.
// అవుట్‌పుట్‌ను ముద్రించడానికి చేర్చండి#చేర్చండి
intప్రధాన()
{
// స్ట్రింగ్ వేరియబుల్‌ను ప్రారంభించండి
గంటలు::స్ట్రింగ్strData( 'ప్రాథమిక సి ++ ప్రోగ్రామింగ్');
// పొజిషన్‌ను నిల్వ చేయడానికి ఇంటర్‌జర్ వేరియబుల్‌ని ప్రకటించండి
intస్థానం;
// 'C ++' అక్షరాన్ని శోధించండి
స్థానం=strData.మొదటి_ని కనుగొనండి( 'K ++' );
// స్థాన విలువను తనిఖీ చేయండి
ఉంటే (స్థానం> = 0)
{
// ఏదైనా పాత్ర దొరికితే పొజిషన్ ప్రింట్ చేయండి
గంటలు::ఖరీదు << 'పాత్ర' ' <<strData[స్థానం]
<< '' కనుగొన్నారు ' << 'స్థానంలో' <<స్థానం<< ' n';
}
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. ఇక్కడ, పాత్ర, ' + స్ట్రింగ్ యొక్క, ' K ++ 'స్థానం వద్ద కనుగొనబడింది, 7 ప్రధాన స్ట్రింగ్, ' ప్రాథమిక సి ++ ప్రోగ్రామింగ్ '.
ఉదాహరణ 3: నిర్దిష్ట స్థానం తర్వాత ఒక నిర్దిష్ట అక్షరాన్ని శోధించండి
నిర్దిష్ట స్థానం తర్వాత నిర్దిష్ట అక్షరాన్ని శోధించడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. స్ట్రింగ్ వేరియబుల్‌లో స్ట్రింగ్ డేటా నిల్వ చేయబడుతుంది మరియు స్థానం తర్వాత నిర్దిష్ట స్ట్రింగ్ శోధించబడుతుంది, 13. సెర్చ్ స్ట్రింగ్ యొక్క ఏదైనా అక్షరం ప్రధాన స్ట్రింగ్‌లో కనుగొనబడితే, ఒక పొజిషన్ విలువ తిరిగి ఇవ్వబడుతుంది.
// అవుట్‌పుట్‌ను ముద్రించడానికి చేర్చండి#చేర్చండి
intప్రధాన()
{
// స్ట్రింగ్ వేరియబుల్‌ను ప్రారంభించండి
గంటలు::స్ట్రింగ్strData= 'జీవించడానికి తినండి, తినడానికి జీవించవద్దు';
// అసలు స్ట్రింగ్‌ను ముద్రించండి
గంటలు::ఖరీదు << 'అసలు స్ట్రింగ్:' +strData<< ' n';
// చివరి అక్షరం కనుగొనబడిన స్థానాన్ని ముద్రించండి
గంటలు::ఖరీదు<<'పొజిషన్‌లో కనిపించిన చివరి మ్యాచింగ్ క్యారెక్టర్:'
<<strData.మొదటి_ని కనుగొనండి('వద్ద',13) << ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. ఇక్కడ, పాత్ర, ' కు స్ట్రింగ్ యొక్క, ' వద్ద 'స్థానం వద్ద కనుగొనబడింది, పదిహేను ప్రధాన స్ట్రింగ్, ' జీవించడానికి తినండి, తినడానికి జీవించవద్దు '.
ఉదాహరణ 4: మొదటి సరిపోలిక సంఖ్య యొక్క స్థానాన్ని శోధించండి
రెండవ వెక్టర్ జాబితాలో మొదటి వెక్టర్ జాబితా యొక్క ప్రతి సంఖ్యను శోధించడానికి మరియు మొదటి వెక్టర్ జాబితా యొక్క మ్యాచింగ్ నంబర్ స్థానాన్ని తిరిగి ఇవ్వడానికి క్రింది కోడ్‌తో C ++ ఫైల్‌ను సృష్టించండి. సరిపోలే వాదన కనుగొనబడితే, అప్పుడు స్థాన విలువ తిరిగి ఇవ్వబడుతుంది; లేకపోతే, ఒక సందేశం ముద్రించబడుతుంది.
// అవుట్‌పుట్‌ను ముద్రించడానికి చేర్చండి#చేర్చండి
// వెక్టర్‌లో డేటాను శోధించడం కోసం చేర్చండి
#చేర్చండి
// వెక్టర్ డేటాను ఉపయోగించడం కోసం చేర్చండి
#చేర్చండి
intప్రధాన()
{
// రెండు వెక్టర్ జాబితాను ప్రకటించండి
గంటలు::వెక్టర్జాబితా 1{10,5,65,31,7};
గంటలు::వెక్టర్జాబితా 2{2,77,5,38,32,55};
// జాబితా 1 లోని డేటాను జాబితా 2 లో శోధించండి
దానంతట అదేఅవుట్‌పుట్=గంటలు::మొదటి_ని కనుగొనండి(జాబితా 1.ప్రారంభించండి(), జాబితా 1.ముగింపు(), జాబితా 2.ప్రారంభించండి(), జాబితా 2.ముగింపు());
// సరిపోలే సంఖ్య యొక్క స్థానాన్ని చదవండి
intస్థానం=గంటలు::దూరం(జాబితా 1.ప్రారంభించండి(), అవుట్‌పుట్);
// జాబితా సంఖ్య ఏవైనా సంఖ్య 1 తో సరిపోల్చండి
ఉంటే (అవుట్‌పుట్<జాబితా 1.ముగింపు()) {
గంటలు::ఖరీదు << 'మొదటి సరిపోలిక సంఖ్య' <<జాబితా 1[స్థానం] << 'పొజిషన్‌లో దొరికింది' <<స్థానం<< ' n';
}
లేకపోతే {
గంటలు::ఖరీదు << 'సరిపోలే సంఖ్య కనుగొనబడలేదు. n';
}
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. మొదటి శ్రేణిలోని సంఖ్య విలువ, రెండవ శ్రేణిలో ఉంది మరియు ఈ సంఖ్య యొక్క స్థానం 1.
ముగింపు
Find_first_of () ఫంక్షన్ వివిధ ప్రోగ్రామింగ్ ప్రయోజనాల కోసం అక్షరం లేదా సంఖ్యను శోధించడానికి ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ వివిధ శోధన సమస్యలను పరిష్కరించడానికి ఉపయోగించబడుతుంది. ఈ ట్యుటోరియల్ చదివిన తర్వాత C ++ ప్రోగ్రామర్ ఈ ఫంక్షన్‌ను సరిగ్గా ఉపయోగించగలరని నేను ఆశిస్తున్నాను.