C ++ లో రెగ్యులర్ ఎక్స్‌ప్రెషన్ బేసిక్స్

Regular Expression Basics C

కింది వాక్యాన్ని కోట్స్‌లో పరిగణించండి:

'ఇదిగో నా మనిషి.'

ఈ స్ట్రింగ్ కంప్యూటర్ లోపల ఉండవచ్చు, మరియు అది మనిషి అనే పదాన్ని కలిగి ఉందో లేదో వినియోగదారు తెలుసుకోవాలనుకోవచ్చు. అందులో మనిషి అనే పదం ఉన్నట్లయితే, అతడు పురుషుని పదాన్ని స్త్రీగా మార్చాలనుకోవచ్చు; తద్వారా స్ట్రింగ్ చదవాలి:



'ఇదిగో నా మహిళ.'

కంప్యూటర్ వినియోగదారు నుండి ఇలాంటి అనేక ఇతర కోరికలు ఉన్నాయి; కొన్ని సంక్లిష్టంగా ఉంటాయి. రెగ్యులర్ ఎక్స్‌ప్రెషన్, సంక్షిప్త, రెగెక్స్, కంప్యూటర్ ద్వారా ఈ సమస్యలను నిర్వహించే విషయం. C ++ అనేది Regex అనే లైబ్రరీతో వస్తుంది. కాబట్టి, రెగెక్స్‌ని నిర్వహించడానికి C ++ ప్రోగ్రామ్ దీనితో ప్రారంభం కావాలి:



#చేర్చండి

#చేర్చండి

నేమ్‌స్పేస్ std ఉపయోగించి;

ఈ ఆర్టికల్ సి ++ లో రెగ్యులర్ ఎక్స్‌ప్రెషన్ బేసిక్‌లను వివరిస్తుంది.



వ్యాసం కంటెంట్

రెగ్యులర్ ఎక్స్‌ప్రెషన్ ఫండమెంటల్స్

రెగెక్స్

ఇక్కడ నా మనిషి లాంటి స్ట్రింగ్. పైన ఉన్న లక్ష్యం క్రమం లేదా లక్ష్య స్ట్రింగ్ లేదా కేవలం, లక్ష్యం. శోధించిన వ్యక్తి, సాధారణ వ్యక్తీకరణ, లేదా కేవలం, రీజెక్స్.

సరిపోలడం

వెతుకుతున్న పదం లేదా పదబంధాన్ని గుర్తించినప్పుడు సరిపోలిక ఏర్పడుతుంది. సరిపోలిన తర్వాత, భర్తీ చేయవచ్చు. ఉదాహరణకు, పురుషుడు పైన ఉన్న తర్వాత, దానిని స్త్రీ భర్తీ చేయవచ్చు.

సాధారణ సరిపోలిక

కింది కార్యక్రమం మనిషి అనే పదం ఎలా సరిపోలుతుందో చూపుతుంది.



#చేర్చండి

#చేర్చండి

నేమ్‌స్పేస్ std ఉపయోగించి;

intప్రధాన()
{

regex reg('మనిషి');
ఉంటే (regex_search('ఇదిగో నా మనిషి.',reg))
ఖరీదు<< 'సరిపోలింది' <<endl;
లేకపోతే
ఖరీదు<< 'సరిపోలలేదు' <<endl;

తిరిగి 0;
}

మ్యాచ్ ఉంటే regex_search () ఫంక్షన్ నిజమవుతుంది మరియు మ్యాచ్ జరగకపోతే తప్పుడు తిరిగి వస్తుంది. ఇక్కడ, ఫంక్షన్ రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది: మొదటిది టార్గెట్ స్ట్రింగ్, మరియు రెండవది రిజెక్స్ ఆబ్జెక్ట్. రెజెక్స్ డబుల్ కోట్స్‌లో 'మనిషి'. ప్రధాన () ఫంక్షన్‌లోని మొదటి స్టేట్‌మెంట్ రెగెక్స్ ఆబ్జెక్ట్‌ను రూపొందిస్తుంది. Regex అనేది ఒక రకం, మరియు reg అనేది regex వస్తువు. టార్గెట్ స్ట్రింగ్‌లో 'మ్యాన్' కనిపిస్తున్నందున, పై ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ 'సరిపోలింది'. లక్ష్యంలో 'మనిషి' కనిపించకపోతే, regex_search () తప్పుగా తిరిగి వచ్చేది, మరియు అవుట్‌పుట్ 'సరిపోలలేదు'.

కింది కోడ్ యొక్క అవుట్‌పుట్ సరిపోలలేదు:

regex reg('మనిషి');
ఉంటే (regex_search('ఇదిగో నా తయారీ.',reg))
ఖరీదు<< 'సరిపోలింది' <<endl;
లేకపోతే
ఖరీదు<< 'సరిపోలలేదు' <<endl;

సరిపోలడం లేదు ఎందుకంటే రెగెక్స్ 'మ్యాన్' మొత్తం టార్గెట్ స్ట్రింగ్‌లో కనుగొనబడలేదు, 'ఇదిగో నా తయారీ.'

సరళి

సాధారణ వ్యక్తీకరణ, పైన మనిషి, చాలా సులభం. రీజెక్స్‌లు సాధారణంగా అంత సులభం కాదు. రెగ్యులర్ ఎక్స్‌ప్రెషన్స్‌లో మెటా కారెక్టర్లు ఉంటాయి. మెటా కారెక్టర్స్ అంటే ప్రత్యేక అర్థాలు ఉన్న పాత్రలు. మెటా కారెక్టర్ అనేది పాత్రల గురించిన పాత్ర. C ++ రీజెక్స్ మెటా కారెక్టర్లు:

$ .* + ? ( ) [ ] { } |

మెటా కారెక్టర్లతో లేదా లేకుండా ఒక రీజెక్స్ ఒక నమూనా.

అక్షర తరగతులు

చదరపు బ్రాకెట్లలో

ఒక నమూనా చదరపు బ్రాకెట్లలో అక్షరాలను కలిగి ఉంటుంది. దీనితో, టార్గెట్ స్ట్రింగ్‌లోని ఒక నిర్దిష్ట స్థానం ఏవైనా స్క్వేర్ బ్రాకెట్‌ల అక్షరాలతో సరిపోతుంది. కింది లక్ష్యాలను పరిగణించండి:

'పిల్లి గదిలో ఉంది.'

'గబ్బిలం గదిలో ఉంది.'

'ఎలుక గదిలో ఉంది.'

రెగెక్స్, [cbr] మొదటి లక్ష్యంలో పిల్లితో సరిపోతుంది. ఇది రెండో టార్గెట్‌లో బ్యాట్‌తో సరిపోతుంది. ఇది మూడవ లక్ష్యంలో ఎలుకతో సరిపోతుంది. దీనికి కారణం, పిల్లి లేదా గబ్బిలం లేదా ఎలుక 'c' లేదా 'b' లేదా 'r' తో మొదలవుతుంది. కింది కోడ్ విభాగం దీనిని వివరిస్తుంది:

regex reg('[cbr] వద్ద');
ఉంటే (regex_search('పిల్లి గదిలో ఉంది.',reg))
ఖరీదు<< 'సరిపోలింది' <<endl;
ఉంటే (regex_search('గబ్బిలం గదిలో ఉంది.',reg))
ఖరీదు<< 'సరిపోలింది' <<endl;
ఉంటే (regex_search('ఎలుక గదిలో ఉంది.',reg))
ఖరీదు<< 'సరిపోలింది' <<endl;

అవుట్‌పుట్:

సరిపోలింది

సరిపోలింది

సరిపోలింది

పాత్రల పరిధి

క్లాస్, [cbr] నమూనాలో [cbr], లక్ష్యంలోని అనేక సాధ్యమైన అక్షరాలతో సరిపోతుంది. ఇది లక్ష్యంలో 'సి' లేదా 'బి' లేదా 'ఆర్' తో సరిపోతుంది. లక్ష్యం వద్ద 'c' లేదా 'b' లేదా 'r' ఏదీ లేనట్లయితే, ఆ తర్వాత అనుసరించబడితే, మ్యాచ్ ఉండదు.

'సి' లేదా 'బి' లేదా 'ఆర్' వంటి కొన్ని అవకాశాలు ఒక పరిధిలో ఉన్నాయి. అంకెల పరిధి, 0 నుండి 9 వరకు 10 అవకాశాలు ఉన్నాయి, మరియు దాని కోసం నమూనా [0-9]. చిన్న అక్షరాల శ్రేణి, a నుండి z వరకు, 26 అవకాశాలను కలిగి ఉంది మరియు దాని కోసం నమూనా [a-z]. A నుండి Z వరకు ఉన్న పెద్ద అక్షరాల శ్రేణి 26 అవకాశాలను కలిగి ఉంది మరియు దాని నమూనా [A-Z]. - అధికారికంగా మెటా కారెక్టర్ కాదు, కానీ చదరపు బ్రాకెట్లలో, ఇది ఒక పరిధిని సూచిస్తుంది. కాబట్టి, కిందివి ఒక మ్యాచ్‌ని ఉత్పత్తి చేస్తాయి:

ఉంటే (regex_search('ID6id',regex('[0-9]')))

ఖరీదు<< 'సరిపోలింది' <<endl;

రెండవ వాదనగా రెజెక్స్ ఎలా నిర్మించబడిందో గమనించండి. అంకె, 6 పరిధిలో, 0 నుండి 9, మరియు లక్ష్యంలో 6, ID6id మధ్య మ్యాచ్ జరుగుతుంది. పై కోడ్ దీనికి సమానం:

ఉంటే (regex_search('ID6id',regex('[0123456789]')))

ఖరీదు<< 'సరిపోలింది' <<endl;

కింది కోడ్ ఒక మ్యాచ్‌ను ఉత్పత్తి చేస్తుంది:

చార్p[] = 'ID6iE';

ఉంటే (regex_search(p,regex('[a-z]')))

ఖరీదు<< 'సరిపోలింది' <<endl;

ఇక్కడ మొదటి వాదన స్ట్రింగ్ వేరియబుల్ మరియు స్ట్రింగ్ అక్షరమైనది కాదని గమనించండి. మ్యాచ్ [a-z] లోని 'i' మరియు ID6iE లో 'i' మధ్య ఉంటుంది.

శ్రేణి ఒక తరగతి అని మర్చిపోవద్దు. నమూనాలో శ్రేణికి కుడివైపు లేదా పరిధికి ఎడమవైపున టెక్స్ట్ ఉండవచ్చు. కింది కోడ్ ఒక మ్యాచ్‌ను ఉత్పత్తి చేస్తుంది:

ఉంటే (regex_search('ID2id ఒక ID ',regex('ID [0-9] id')))

ఖరీదు<< 'సరిపోలింది' <<endl;

మ్యాచ్ ID [0-9] id మరియు ID2id మధ్య ఉంటుంది. మిగిలిన లక్ష్యం స్ట్రింగ్, ఒక ID, ఈ పరిస్థితిలో సరిపోలలేదు.

రెగ్యులర్ ఎక్స్‌ప్రెషన్ సబ్జెక్ట్ (రీజెక్స్) లో ఉపయోగించినట్లుగా, క్లాస్ అనే పదానికి నిజానికి సమితి అని అర్ధం. అంటే, సెట్‌లోని ఒక పాత్ర సరిపోలడం.

గమనిక: హైఫన్ - ఒక పరిధిని సూచించే చదరపు బ్రాకెట్లలో మాత్రమే ఒక మెటా కారెక్టర్. ఇది చదరపు బ్రాకెట్‌ల వెలుపల, రీజెక్స్‌లో మెటా కారెక్టర్ కాదు.

నిరాకరణ

శ్రేణితో సహా తరగతి తిరస్కరించబడుతుంది. అంటే, సెట్ (క్లాస్) లోని అక్షరాలు కానివి సరిపోలాలి. క్లాస్ నమూనా ప్రారంభంలో, ప్రారంభ చదరపు బ్రాకెట్ తర్వాత ఇది ^ మెటా కారెక్టర్‌తో సూచించబడుతుంది. కాబట్టి, [^0-9] అంటే లక్ష్యంలో తగిన స్థానంలో అక్షరాన్ని సరిపోల్చడం, ఇది 0 నుండి 9 వరకు పరిధిలోని ఏ అక్షరం కాదు. కాబట్టి కింది కోడ్ సరిపోలికను ఉత్పత్తి చేయదు:

ఉంటే (regex_search('0123456789101112',regex('[^ 0-9]')))

ఖరీదు<< 'సరిపోలింది' <<endl;

లేకపోతే

ఖరీదు<< 'సరిపోలలేదు' <<endl;

0 నుండి 9 పరిధిలో ఉన్న ఒక అంకె లక్ష్య స్ట్రింగ్ పొజిషన్‌లలో 0123456789101112,; కాబట్టి మ్యాచ్ లేదు - తిరస్కరణ.

కింది కోడ్ ఒక మ్యాచ్‌ను ఉత్పత్తి చేస్తుంది:

ఉంటే (regex_search('ABCDEFGHIJ',regex('[^ 0-9]')))

ఖరీదు<< 'సరిపోలింది' <<endl;

ABCDEFGHIJ, లక్ష్యంలో సంఖ్య కనుగొనబడలేదు; కాబట్టి ఒక మ్యాచ్ ఉంది.

[a-z] వెలుపలి పరిధి [^a-z]. కాబట్టి [^a-z] అనేది [a-z] యొక్క నిరాకరణ.

[A-Z] ఒక పరిధి [^A-Z]. కాబట్టి [^A-Z] అనేది [A-Z] యొక్క తిరస్కరణ.

ఇతర నిరాకరణలు ఉన్నాయి.

వైట్‌స్పేస్‌లను సరిపోల్చడం

‘’ లేదా t లేదా r లేదా n లేదా f అనేది వైట్‌స్పేస్ అక్షరం. కింది కోడ్‌లో, రెగెక్స్, n టార్గెట్‌లో ‘ n’ కి సరిపోతుంది:

ఉంటే (regex_search('లైన్ ఒకటి. r nరెండు లైన్. ',regex(' n')))

ఖరీదు<< 'సరిపోలింది' <<endl;

ఏదైనా వైట్‌స్పేస్ అక్షరంతో సరిపోలడం

ఏదైనా వైట్ స్పేస్ అక్షరానికి సరిపోయే నమూనా లేదా తరగతి, [ t r n f]. కింది కోడ్‌లో, '' సరిపోలింది:

ఉంటే (regex_search('ఒకటి రెండు',regex('[ t r n f] ')))

ఖరీదు<< 'సరిపోలింది' <<endl;

ఏదైనా వైట్‌స్పేస్ కాని అక్షరంతో సరిపోలడం

ఏదైనా తెల్లని స్పేస్ అక్షరానికి సరిపోయే నమూనా లేదా తరగతి, [^ t r n f]. కింది కోడ్ మ్యాచ్‌ని ఉత్పత్తి చేస్తుంది ఎందుకంటే టార్గెట్‌లో వైట్‌స్పేస్ లేదు:

ఉంటే (regex_search('1234abcd',regex('[^ t r n f] ')))

ఖరీదు<< 'సరిపోలింది' <<endl;

నమూనాలో కాలం (.)

నమూనాలోని కాలం (.) లక్ష్యంలో n మినహా తనతో సహా ఏదైనా అక్షరానికి సరిపోతుంది. ఒక మ్యాచ్ క్రింది కోడ్‌లో ఉత్పత్తి చేయబడుతుంది:

ఉంటే (regex_search('1234abcd',regex('.')))

ఖరీదు<< 'సరిపోలింది' <<endl;

కింది కోడ్‌లో సరిపోలే ఫలితాలు లేవు ఎందుకంటే లక్ష్యం n.

ఉంటే (regex_search(' n',regex('.')))

ఖరీదు<< 'సరిపోలింది' <<endl;

లేకపోతే

ఖరీదు<< 'సరిపోలలేదు' <<endl;

గమనిక: చదరపు బ్రాకెట్‌లతో అక్షర తరగతి లోపల, కాలానికి ప్రత్యేక అర్థం లేదు.

సరిపోలే పునరావృత్తులు

ఒక అక్షరం లేదా అక్షరాల సమూహం లక్ష్య స్ట్రింగ్‌లో ఒకటి కంటే ఎక్కువసార్లు సంభవించవచ్చు. ఈ పునరావృతానికి ఒక నమూనా సరిపోలవచ్చు. మెటా కారెక్టర్లు,?, *, +, మరియు {} లక్ష్యంలోని పునరావృతంతో సరిపోలడానికి ఉపయోగించబడతాయి. లక్షిత స్ట్రింగ్‌లో x ఆసక్తి ఉన్న పాత్ర అయితే, మెటా కారెక్టర్లకు ఈ క్రింది అర్థాలు ఉంటాయి:

x*:మ్యాచ్ అని అర్థం'x' 0లేదా అంతకంటే ఎక్కువ సార్లు,i.మరియు.,ఎన్నిసార్లు అయినా

x+:మ్యాచ్ అని అర్థం'x' 1లేదా అంతకంటే ఎక్కువ సార్లు,i.మరియు.,కనీసము ఒక్కసారైన

x? :మ్యాచ్ అని అర్థం'x' 0లేదా1 సమయం

x{ఎన్,}:మ్యాచ్ అని అర్థం'x'కనీసం n లేదా అంతకంటే ఎక్కువ సార్లు.గమనికకామా.

x{ఎన్} :మ్యాచ్'x'సరిగ్గా n సార్లు

x{ఎన్,m}:మ్యాచ్'x'కనీసం n సార్లు,కానీ m సార్లు కంటే ఎక్కువ కాదు.

ఈ మెటాఛార్టర్స్ అంటారు క్వాంటిఫైయర్స్.

దృష్టాంతాలు

*

* * మునుపటి అక్షరం లేదా మునుపటి సమూహం, సున్నా లేదా అంతకంటే ఎక్కువ సార్లు సరిపోతుంది. టార్గెట్ స్ట్రింగ్ యొక్క కుక్కలో o* 'o' కి సరిపోతుంది. ఇది బుక్ మరియు లుకింగ్‌లో ఊకి సరిపోతుంది. ది రీజెక్స్, ఓ* మ్యాచ్ బూవూ ఇన్ ది జంతువు బూవూ .. గమనిక: o* మ్యాచ్‌లు త్రవ్వబడతాయి, ఇక్కడ 'o' సున్నా (లేదా అంతకంటే ఎక్కువ) సమయం వస్తుంది.

+

+ + మునుపటి అక్షరం లేదా మునుపటి సమూహంతో సరిపోలుతుంది, 1 లేదా అంతకంటే ఎక్కువ సార్లు. *కోసం సున్నా లేదా అంతకంటే ఎక్కువ సార్లు విరుద్ధంగా ఉంచండి. కాబట్టి రెజెక్స్, e+ ఈట్‌లో 'e' కి సరిపోతుంది, ఇక్కడ 'e' ఒక సారి వస్తుంది. e+ కూడా గొర్రెలలో ee తో సరిపోతుంది, ఇక్కడ 'e' ఒకటి కంటే ఎక్కువ సార్లు సంభవిస్తుంది. గమనిక: ఇ+ డిగ్‌తో సరిపోలదు ఎందుకంటే డిగ్‌లో, 'ఇ' కనీసం ఒక్కసారి కూడా జరగదు.

?

ది ? మునుపటి పాత్ర లేదా మునుపటి సమూహంతో సరిపోలుతుంది, 0 లేదా 1 సారి (మరియు అంతకంటే ఎక్కువ కాదు). కాబట్టి, ఇ? మ్యాచ్‌లు త్రవ్వబడతాయి ఎందుకంటే డి, సున్నా సమయంలో 'ఇ' సంభవిస్తుంది. ఇ? మ్యాచ్‌లు సెట్ చేయబడ్డాయి ఎందుకంటే సెట్‌లో 'ఇ' ఒకేసారి వస్తుంది. గమనిక: ఇ? ఇప్పటికీ గొర్రెలకు సరిపోతుంది; అయితే గొర్రెలలో రెండు ‘ఇ’ లు ఉన్నాయి. ఇక్కడ ఒక స్వల్పభేదం ఉంది - తర్వాత చూడండి.

{n,}

ఇది మునుపటి పాత్ర లేదా మునుపటి సమూహం యొక్క కనీసం n వరుస పునరావృతాలతో సరిపోతుంది. కాబట్టి రెజెక్స్, ఇ {2,} టార్గెట్‌లోని రెండు 'ఇ'లు, గొర్రెలు మరియు మూడు' ఇ'లు టార్గెట్ షీప్‌లో సరిపోలుతాయి. e {2,} సెట్‌తో సరిపోలడం లేదు, ఎందుకంటే సెట్‌లో ఒకే 'e' ఉంటుంది.

{n}

ఇది మునుపటి అక్షరం లేదా మునుపటి సమూహం యొక్క వరుసగా n పునరావృతాలతో సరిపోతుంది. కాబట్టి రెజెక్స్, ఇ {2} లక్ష్యం, గొర్రెలోని రెండు ‘ఇ’లకు సరిపోతుంది. e {2} సెట్‌తో సరిపోలడం లేదు ఎందుకంటే సెట్‌లో ఒకే 'e' ఉంటుంది. సరే, e {2} షీప్, టార్గెట్‌లోని రెండు ‘e’లకు సరిపోతుంది. ఇక్కడ ఒక స్వల్పభేదం ఉంది - తర్వాత చూడండి.

{n, m}

ఇది మునుపటి అక్షరం లేదా మునుపటి సమూహం యొక్క వరుసగా పునరావృత్తులు, n నుండి m వరకు ఎక్కడైనా సరిపోతుంది. కాబట్టి, e '1,3} తవ్వకంలో ఏదీ సరిపోలలేదు, దీనికి' e 'లేదు. ఇది సెట్‌లోని ఒక ‘ఇ’, గొర్రెలోని రెండు ‘ఇ’, షీప్‌లో మూడు ‘ఇ’, మరియు షీప్‌లో మూడు ‘ఇ’లతో సరిపోతుంది. చివరి మ్యాచ్‌లో ఒక స్వల్పభేదం ఉంది - తర్వాత చూడండి.

సరిపోలే ప్రత్యామ్నాయం

కంప్యూటర్‌లో కింది లక్ష్య స్ట్రింగ్‌ని పరిగణించండి.

పొలంలో వివిధ పరిమాణాల పందులు ఉన్నాయి.

ఈ లక్ష్యానికి మేక లేదా కుందేలు లేదా పంది ఉందా అని ప్రోగ్రామర్ తెలుసుకోవాలనుకోవచ్చు. కోడ్ క్రింది విధంగా ఉంటుంది:

చార్p[] = 'పొలంలో వివిధ పరిమాణాల పందులు ఉన్నాయి.';

ఉంటే (regex_search(p,regex('మేక | కుందేలు | పంది')))

ఖరీదు<< 'సరిపోలింది' <<endl;

లేకపోతే

ఖరీదు<< 'సరిపోలలేదు' <<endl;

కోడ్ ఒక మ్యాచ్‌ని ఉత్పత్తి చేస్తుంది. ప్రత్యామ్నాయ అక్షర వినియోగాన్ని గమనించండి, |. రెండు, మూడు, నాలుగు మరియు మరిన్ని ఎంపికలు ఉండవచ్చు. లక్ష్య స్ట్రింగ్‌లోని ప్రతి అక్షరం స్థానంలో మొదటి ప్రత్యామ్నాయమైన మేకతో మ్యాచ్ చేయడానికి C ++ మొదట ప్రయత్నిస్తుంది. ఇది మేకతో విజయవంతం కాకపోతే, అది తదుపరి ప్రత్యామ్నాయమైన కుందేలును ప్రయత్నిస్తుంది. కుందేలుతో అది విజయవంతం కాకపోతే, అది తదుపరి ప్రత్యామ్నాయమైన పందిని ప్రయత్నిస్తుంది. పంది విఫలమైతే, C ++ లక్ష్యంలో తదుపరి స్థానానికి చేరుకుంటుంది మరియు మళ్లీ మొదటి ప్రత్యామ్నాయంతో ప్రారంభమవుతుంది.

పై కోడ్‌లో, పంది సరిపోలింది.

మ్యాచ్ బిగినింగ్ లేదా ఎండ్

ప్రారంభమవుతోంది


Regex ప్రారంభంలో ^ ఉంటే, లక్ష్య స్ట్రింగ్ యొక్క ప్రారంభ వచనాన్ని రెగెక్స్ ద్వారా సరిపోల్చవచ్చు. కింది కోడ్‌లో, లక్ష్యం ప్రారంభం abc, ఇది సరిపోతుంది:

ఉంటే (regex_search('abc మరియు def',regex('^ abc')))

ఖరీదు<< 'సరిపోలింది' <<endl;

కింది కోడ్‌లో సరిపోలిక జరగదు:

ఉంటే (regex_search('అవును, ఎబిసి మరియు డెఫ్',regex('^ abc')))

ఖరీదు<< 'సరిపోలింది' <<endl;

లేకపోతే

ఖరీదు<< 'సరిపోలలేదు' <<endl;

ఇక్కడ, abc లక్ష్యం ప్రారంభంలో లేదు.

గమనిక: సర్కమ్‌ఫ్లెక్స్ అక్షరం, ‘^’, రెగెక్స్ ప్రారంభంలో ఒక మెటా కారెక్టర్, ఇది లక్ష్య స్ట్రింగ్ ప్రారంభానికి సరిపోతుంది. క్యారెక్టర్ క్లాస్ ప్రారంభంలో ఇది ఇప్పటికీ ఒక మెటా కారెక్టర్, ఇది క్లాస్‌ని నిరాకరిస్తుంది.

ముగింపు

Regex చివరలో $ ఉంటే, టార్గెట్ స్ట్రింగ్ యొక్క ముగింపు టెక్స్ట్‌ను రీజెక్స్ ద్వారా సరిపోల్చవచ్చు. కింది కోడ్‌లో, లక్ష్యం ముగింపు xyz, ఇది సరిపోతుంది:

ఉంటే (regex_search('uvw మరియు xyz',regex('xyz $')))

ఖరీదు<< 'సరిపోలింది' <<endl;

కింది కోడ్‌లో సరిపోలిక జరగదు:

ఉంటే (regex_search('uvw మరియు xyz ఫైనల్',regex('xyz $')))

ఖరీదు<< 'సరిపోలింది' <<endl;

లేకపోతే

ఖరీదు<< 'సరిపోలలేదు' <<endl;

ఇక్కడ, xyz లక్ష్యం ముగింపులో లేదు.

సమూహము

పేరెంట్‌సిస్‌ను ఒక నమూనాలో అక్షరాలను సమూహపరచడానికి ఉపయోగించవచ్చు. కింది రీజెక్స్‌ని పరిగణించండి:

'కచేరీ (పియానిస్ట్)'

ఇక్కడ సమూహం పియానిస్ట్, చుట్టూ మెటా కారెక్టర్లు (మరియు) ఉన్నాయి. ఇది నిజానికి ఉప సమూహం, అయితే కచేరీ (పియానిస్ట్) మొత్తం సమూహం. కింది వాటిని పరిగణించండి:

'ది (పియానిస్ట్ మంచివాడు)'

ఇక్కడ, ఉప సమూహం లేదా ఉప-స్ట్రింగ్, పియానిస్ట్ మంచిది.

సాధారణ భాగాలతో ఉప-తీగలు

బుక్ కీపర్ అంటే పుస్తకాలను జాగ్రత్తగా చూసుకునే వ్యక్తి. బుక్ కీపర్ మరియు బుక్ షెల్ఫ్ ఉన్న లైబ్రరీని ఊహించండి. కింది టార్గెట్ స్ట్రింగ్‌లలో ఒకటి కంప్యూటర్‌లో ఉందని ఊహించండి:

'లైబ్రరీలో పుస్తకాల అర ఉంది, అది ప్రశంసించబడింది.';

'ఇదిగో బుక్కీపర్';

'బుక్ కీపర్ పుస్తకాల అరతో పని చేస్తుంది.';

ఈ వాక్యాలలో ఏది కంప్యూటర్‌లో ఉందో తెలుసుకోవడానికి ప్రోగ్రామర్ ఆసక్తి లేదని ఊహించండి. అయినప్పటికీ, కంప్యూటర్‌లో టార్గెట్ స్ట్రింగ్ ఏమైనా ఉంటే పుస్తకాల షెల్ఫ్ లేదా బుక్ కీపర్ ఉందా అని తెలుసుకోవడం అతని ఆసక్తి. ఈ సందర్భంలో, అతని రిజెక్స్ కావచ్చు:

'పుస్తకాల అర | బుక్ కీపర్.'

ప్రత్యామ్నాయాన్ని ఉపయోగించడం.

రెండు పదాలకు సాధారణమైన ఆ పుస్తకాన్ని, నమూనాలోని రెండు పదాలలో రెండుసార్లు టైప్ చేసినట్లు గమనించండి. పుస్తకాన్ని రెండుసార్లు టైప్ చేయకుండా ఉండటానికి, రీజెక్స్ ఇలా బాగా వ్రాయబడుతుంది:

'పుస్తకం (షెల్ఫ్ | కీపర్)'

ఇక్కడ, సమూహం, షెల్ఫ్ | కీపర్ ప్రత్యామ్నాయ మెటా కారెక్టర్ ఇప్పటికీ ఉపయోగించబడుతోంది, కానీ రెండు దీర్ఘ పదాలకు కాదు. ఇది రెండు పొడవాటి పదాల రెండు ముగింపు భాగాలకు ఉపయోగించబడింది. C ++ ఒక సమూహాన్ని ఒక సంస్థగా పరిగణిస్తుంది. కాబట్టి, C ++ బుక్ అయిన వెంటనే వచ్చే షెల్ఫ్ లేదా కీపర్ కోసం చూస్తుంది. కింది కోడ్ యొక్క అవుట్‌పుట్ సరిపోలింది:

చార్p[] = 'లైబ్రరీలో పుస్తకాల అర ఉంది, అది ప్రశంసించబడింది.';

ఉంటే (regex_search(p,regex('పుస్తకం (షెల్ఫ్ | కీపర్)')))

ఖరీదు<< 'సరిపోలింది' <<endl;

బుక్‌షెల్ఫ్ మరియు బుక్ కీపర్ సరిపోలలేదు.

ఐకాస్ మరియు మల్టీలైన్ regex_constants

ఐకాస్

మ్యాచ్ అనేది డిఫాల్ట్‌గా కేస్ సెన్సిటివ్. అయితే, దీనిని కేస్ సెన్సిటివ్‌గా చేయవచ్చు. దీనిని సాధించడానికి, కింది కోడ్‌లో ఉన్నట్లుగా, regex :: icase స్థిరాంకం ఉపయోగించండి:

ఉంటే (regex_search('అభిప్రాయం',regex('ఫీడ్',regex::ఐకాస్)))

ఖరీదు<< 'సరిపోలింది' <<endl;

అవుట్‌పుట్ సరిపోలింది. కాబట్టి పెద్ద అక్షరం 'F' తో ఫీడ్‌బ్యాక్ చిన్న అక్షరం 'f' తో ఫీడ్‌తో సరిపోలింది. regex :: icase అనేది regex () కన్స్ట్రక్టర్ యొక్క రెండవ వాదనగా చేయబడింది. అది లేకుండా, ప్రకటన సరిపోలికను ఉత్పత్తి చేయదు.

మల్టీలైన్

కింది కోడ్‌ని పరిగణించండి:

చార్p[] = 'లైన్ 1 nలైన్ 2 nలైన్ 3 ';

ఉంటే (regex_search(p,regex('^. * $')))

ఖరీదు<< 'సరిపోలింది' <<endl;

లేకపోతే

ఖరీదు<< 'సరిపోలలేదు' <<endl;

అవుట్‌పుట్ సరిపోలలేదు. రెగెక్స్, ^.*$, లక్ష్య స్ట్రింగ్‌ని దాని ప్రారంభం నుండి ముగింపు వరకు సరిపోల్చింది. .* అంటే n, సున్నా లేదా అంతకంటే ఎక్కువ సార్లు మినహా ఏదైనా అక్షరం. కాబట్టి, టార్గెట్‌లోని న్యూలైన్ అక్షరాలు ( n) కారణంగా, సరిపోలిక లేదు.

లక్ష్యం మల్టీలైన్ స్ట్రింగ్. ‘.’ కొత్త లైన్ అక్షరానికి సరిపడాలంటే, నిరంతర regex :: మల్టీలైన్ చేయవలసి ఉంటుంది, ఇది regex () నిర్మాణం యొక్క రెండవ వాదన. కింది కోడ్ దీనిని వివరిస్తుంది:

చార్p[] = 'లైన్ 1 nలైన్ 2 nలైన్ 3 ';

ఉంటే (regex_search(p,regex('^. * $',regex::బహుళ లైన్)))

ఖరీదు<< 'సరిపోలింది' <<endl;

లేకపోతే

ఖరీదు<< 'సరిపోలలేదు' <<endl;

మొత్తం టార్గెట్ స్ట్రింగ్‌ని సరిపోల్చడం

కొత్త లైన్ అక్షరం ( n) లేని మొత్తం లక్ష్య స్ట్రింగ్‌ని సరిపోల్చడానికి, regex_match () ఫంక్షన్‌ను ఉపయోగించవచ్చు. ఈ ఫంక్షన్ regex_search () కి భిన్నంగా ఉంటుంది. కింది కోడ్ దీనిని వివరిస్తుంది:

చార్p[] = 'మొదటి రెండవ మూడవ';

ఉంటే (regex_ సరిపోలిక(p,regex('.*రెండవ.*')))

ఖరీదు<< 'సరిపోలింది' <<endl;

ఇక్కడ ఒక మ్యాచ్ ఉంది. అయితే, రెగెక్స్ మొత్తం టార్గెట్ స్ట్రింగ్‌తో సరిపోలుతుందని గమనించండి మరియు టార్గెట్ స్ట్రింగ్‌లో ఏవైనా ‘ n’ లేదు.

మ్యాచ్_ఫలితాలు ఆబ్జెక్ట్

Regex_search () ఫంక్షన్ లక్ష్యం మరియు రీజెక్స్ ఆబ్జెక్ట్ మధ్య వాదనను తీసుకోవచ్చు. ఈ వాదన మ్యాచ్_ఫలితాల వస్తువు. సరిపోలిన (భాగం) స్ట్రింగ్ మరియు సరిపోలిన ఉప-తీగలను దానితో తెలుసుకోవచ్చు. ఈ వస్తువు పద్ధతులతో కూడిన ప్రత్యేక శ్రేణి. Match_results ఆబ్జెక్ట్ రకం cmatch (స్ట్రింగ్ లిటరల్స్ కోసం).

మ్యాచ్‌లను పొందడం

కింది కోడ్‌ని పరిగణించండి:

చార్p[] = 'మీరు వెతుకుతున్న మహిళ!';

cmatch m;

ఉంటే (regex_search(p,m,regex('w.mn')))

ఖరీదు<<m[0] <<endl;

లక్ష్య స్ట్రింగ్‌లో మహిళ అనే పదం ఉంది. అవుట్‌పుట్ మహిళ ’, ఇది రెజెక్స్‌కు అనుగుణంగా ఉంటుంది, w.mn. సూచిక సున్నా వద్ద, ప్రత్యేక శ్రేణి మాత్రమే మహిళను కలిగి ఉంటుంది.

క్లాస్ ఎంపికలతో, లక్ష్యంలో కనిపించే మొదటి ఉప-స్ట్రింగ్ మాత్రమే ప్రత్యేక శ్రేణికి పంపబడుతుంది. కింది కోడ్ దీనిని వివరిస్తుంది:

cmatch m;

ఉంటే (regex_search('ఎలుక, పిల్లి, గబ్బిలం!',m,regex('[bcr] వద్ద')))

ఖరీదు<<m[0] <<endl;

ఖరీదు<<m[1] <<endl;

ఖరీదు<<m[2] <<endl;

అవుట్పుట్ సూచిక సున్నా నుండి ఎలుక. m [1] మరియు m [2] ఖాళీగా ఉన్నాయి.

ప్రత్యామ్నాయాలతో, లక్ష్యంలో కనిపించే మొదటి ఉప-స్ట్రింగ్ మాత్రమే ప్రత్యేక శ్రేణికి పంపబడుతుంది. కింది కోడ్ దీనిని వివరిస్తుంది:

ఉంటే (regex_search('కుందేలు, మేక, పంది!',m,regex('మేక | కుందేలు | పంది')))

ఖరీదు<<m[0] <<endl;

ఖరీదు<<m[1] <<endl;

ఖరీదు<<m[2] <<endl;

అవుట్‌పుట్ సూచిక సున్నా నుండి కుందేలు. m [1] మరియు m [2] ఖాళీగా ఉన్నాయి.

సమూహాలు

సమూహాలు చేరినప్పుడు, పూర్తి నమూనా సరిపోలినప్పుడు, ప్రత్యేక శ్రేణి యొక్క సెల్ సున్నాకి వెళుతుంది. కనుగొనబడిన తదుపరి ఉప-స్ట్రింగ్ సెల్ 1 లోకి వెళుతుంది; కింది ఉప-స్ట్రింగ్, సెల్ 2 లోకి వెళుతుంది; మరియు అందువలన. కింది కోడ్ దీనిని వివరిస్తుంది:

ఉంటే (regex_search('ఈరోజు ఉత్తమ పుస్తక విక్రేత!',m,regex(పుస్తకం ((సెల్) (లెర్)) ')))

ఖరీదు<<m[0] <<endl;

ఖరీదు<<m[1] <<endl;

ఖరీదు<<m[2] <<endl;

ఖరీదు<<m[3] <<endl;

అవుట్‌పుట్:

పుస్తక విక్రేత

విక్రేత

సెల్

చదవండి

సమూహం (విక్రేత) సమూహం (సెల్) ముందు వస్తుందని గమనించండి.

మ్యాచ్ స్థానం

Cmatch శ్రేణిలోని ప్రతి ఉప-స్ట్రింగ్ కోసం మ్యాచ్ స్థానం తెలుసుకోవచ్చు. స్థానం సున్నా వద్ద లక్ష్య స్ట్రింగ్ యొక్క మొదటి అక్షరం నుండి లెక్కింపు ప్రారంభమవుతుంది. కింది కోడ్ దీనిని వివరిస్తుంది:

cmatch m;

ఉంటే (regex_search('ఈరోజు ఉత్తమ పుస్తక విక్రేత!',m,regex(పుస్తకం ((సెల్) (లెర్)) ')))

ఖరీదు<<m[0] << '->' <<mస్థానం(0) <<endl;

ఖరీదు<<m[1] << '->' <<mస్థానం(1) <<endl;

ఖరీదు<<m[2] << '->' <<mస్థానం(2) <<endl;

ఖరీదు<<m[3] << '->' <<mస్థానం(3) <<endl;

వాదనగా సెల్ ఇండెక్స్‌తో పొజిషన్ ప్రాపర్టీ వినియోగాన్ని గమనించండి. అవుట్‌పుట్:

పుస్తక విక్రేత->5

విక్రేత->9

సెల్->9

చదవండి->12

శోధించండి మరియు భర్తీ చేయండి

సరికొత్త పదం లేదా పదబంధాన్ని సరిపోల్చవచ్చు. దీనికి regex_replace () ఫంక్షన్ ఉపయోగించబడుతుంది. అయితే, ఈసారి, భర్తీ జరిగే స్ట్రింగ్ స్ట్రింగ్ వస్తువు, స్ట్రింగ్ అక్షరాలా కాదు. కాబట్టి, స్ట్రింగ్ లైబ్రరీని ప్రోగ్రామ్‌లో చేర్చాలి. దృష్టాంతం:

#చేర్చండి

#చేర్చండి

#చేర్చండి

నేమ్‌స్పేస్ std ఉపయోగించి;

intప్రధాన()
{
స్ట్రింగ్ str= 'ఇదిగో, నా మనిషి వచ్చాడు. మీ మనిషి వెళ్తాడు. ';
స్ట్రింగ్ newStr=regex_replace(p,regex('మనిషి'), 'మహిళ');
ఖరీదు<<న్యూస్టార్<<endl;

తిరిగి 0;
}

Regex_replace () ఫంక్షన్, ఇక్కడ కోడ్ చేయబడినట్లుగా, అన్ని మ్యాచ్‌లను భర్తీ చేస్తుంది. ఫంక్షన్ యొక్క మొదటి వాదన లక్ష్యం, రెండవది రీజెక్స్ వస్తువు, మరియు మూడవది భర్తీ స్ట్రింగ్. ఫంక్షన్ కొత్త స్ట్రింగ్‌ని అందిస్తుంది, ఇది లక్ష్యం అయితే భర్తీ చేయబడుతుంది. అవుట్‌పుట్:

ఇక్కడ నా మహిళ వచ్చింది. అక్కడ మీ మహిళ వెళ్తుంది.

ముగింపు

రెగ్యులర్ ఎక్స్‌ప్రెషన్ టార్గెట్ సీక్వెన్స్ స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్‌లకు సరిపోయేలా నమూనాలను ఉపయోగిస్తుంది. నమూనాలు మెటాచాక్టర్లను కలిగి ఉంటాయి. C ++ రెగ్యులర్ ఎక్స్‌ప్రెషన్‌ల కోసం సాధారణంగా ఉపయోగించే ఫంక్షన్లు: regex_search (), regex_match () మరియు regex_replace (). రెజెక్స్ అనేది డబుల్ కోట్స్‌లో ఒక నమూనా. ఏదేమైనా, ఈ విధులు రీజెక్స్ వస్తువును వాదనగా తీసుకుంటాయి మరియు కేవలం రీజెక్స్ మాత్రమే కాదు. ఈ ఫంక్షన్‌లు ఉపయోగించడానికి ముందు రెజెక్స్‌ను తప్పనిసరిగా రీజెక్స్ ఆబ్జెక్ట్‌గా తయారు చేయాలి.