இந்த சரம் கம்ப்யூட்டருக்குள் இருக்கலாம், மேலும் அதில் மனிதன் என்ற வார்த்தை இருக்கிறதா என்று பயனர் அறிய விரும்பலாம். அதில் ஆண் என்ற வார்த்தை இருந்தால், அவர் ஆண் என்ற வார்த்தையை பெண்ணாக மாற்ற விரும்பலாம்; அதனால் சரம் படிக்க வேண்டும்:
'இதோ என் பெண்.'
கணினி பயனரிடமிருந்து இது போன்ற பல ஆசைகள் உள்ளன; சில சிக்கலானவை. வழக்கமான வெளிப்பாடு, சுருக்கமாக, ரெஜெக்ஸ், இந்த சிக்கல்களை கணினி மூலம் கையாளும் பொருள். சி ++ ரெஜெக்ஸ் என்ற நூலகத்துடன் வருகிறது. எனவே, ரெஜெக்ஸைக் கையாள ஒரு சி ++ நிரல் இத்துடன் தொடங்க வேண்டும்:
#சேர்க்கிறது
#சேர்க்கிறது
நேம்ஸ்பேஸ் எஸ்டிடியைப் பயன்படுத்துதல்;
இந்த கட்டுரை சி ++ இல் வழக்கமான வெளிப்பாடு அடிப்படைகளை விளக்குகிறது.
கட்டுரை உள்ளடக்கம்
- வழக்கமான வெளிப்பாடு அடிப்படைகள்
- முறை
- எழுத்து வகுப்புகள்
- ஒளிரும் இடங்கள்
- வடிவத்தில் காலம் (.)
- பொருந்தும் மறுபடியும்
- பொருந்தும் மாற்று
- பொருத்தம் ஆரம்பம் அல்லது முடிவு
- தொகுத்தல்
- ஐகேஸ் மற்றும் மல்டிலைன் regex_constants
- முழு இலக்குடன் பொருந்துகிறது
- பொருத்தம்_ முடிவுகள் பொருள்
- போட்டியின் நிலை
- தேடல் மற்றும் மாற்று
- முடிவுரை
வழக்கமான வெளிப்பாடு அடிப்படைகள்
ரீஜெக்ஸ்
இங்கே என் மனிதன் போன்ற ஒரு சரம். மேலே இலக்கு வரிசை அல்லது இலக்கு சரம் அல்லது வெறுமனே, இலக்கு. தேடப்பட்ட மனிதன், வழக்கமான வெளிப்பாடு, அல்லது வெறுமனே, regex.
பொருந்துதல்
தேடும் வார்த்தை அல்லது சொற்றொடர் அமைந்தால் பொருத்தம் ஏற்படும் என்று கூறப்படுகிறது. பொருத்திய பிறகு, மாற்றீடு நடைபெறலாம். உதாரணமாக, ஆண் மேலே அமைந்த பிறகு, அதை பெண்ணால் மாற்ற முடியும்.
எளிய பொருத்தம்
மனிதன் என்ற சொல் எவ்வாறு பொருந்துகிறது என்பதை பின்வரும் நிகழ்ச்சி காட்டுகிறது.
#சேர்க்கிறது
#சேர்க்கிறது
நேம்ஸ்பேஸ் எஸ்டிடியைப் பயன்படுத்துதல்;
intமுக்கிய()
{
regex reg('ஆண்');
என்றால் (regex_search('இதோ என் மனிதன்.',ரெக்))
செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
திரும்ப 0;
}
பொருத்தம் regex_search () பொருத்தமாக இருந்தால் சரி மற்றும் பொருந்தவில்லை என்றால் பொய்யாகத் திரும்பும். இங்கே, செயல்பாடு இரண்டு வாதங்களை எடுத்துக்கொள்கிறது: முதலாவது இலக்கு சரம், இரண்டாவது ரெஜெக்ஸ் பொருள். ரெஜெக்ஸ் தானே 'மனிதன்', இரட்டை மேற்கோள்களில். முக்கிய () செயல்பாட்டின் முதல் அறிக்கை ரெஜெக்ஸ் பொருளை உருவாக்குகிறது. ரெஜெக்ஸ் ஒரு வகை, மற்றும் ரெக் என்பது ரெஜெக்ஸ் பொருள். மேலே உள்ள நிரலின் வெளியீடு 'பொருந்தும்', ஏனெனில் 'மனிதன்' இலக்கு சரத்தில் காணப்படுகிறது. இலக்கில் 'மனிதன்' காணப்படவில்லை என்றால், regex_search () பொய்யாகத் திரும்பியிருக்கும், மற்றும் வெளியீடு 'பொருந்தவில்லை'.
பின்வரும் குறியீட்டின் வெளியீடு பொருந்தவில்லை:
regex reg('ஆண்');என்றால் (regex_search('இதோ என் தயாரிப்பு.',ரெக்))
செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
பொருந்தவில்லை, ஏனென்றால் ரீஜெக்ஸ் 'மனிதன்' முழு இலக்கு சரத்திலும் காணப்படவில்லை, 'இதோ என் தயாரிப்பு.'
முறை
வழக்கமான வெளிப்பாடு, மேலே உள்ள மனிதன், மிகவும் எளிமையானது. ரெஜெக்ஸ் பொதுவாக அவ்வளவு எளிதல்ல. வழக்கமான வெளிப்பாடுகள் மெட்டாகிராக்டர்களைக் கொண்டுள்ளன. மெட்டாச்சார்ட்டர்கள் சிறப்பு அர்த்தங்களைக் கொண்ட எழுத்துக்கள். ஒரு மெட்டா கேரக்டர் என்பது கதாபாத்திரங்களைப் பற்றிய ஒரு பாத்திரம். சி ++ ரீஜெக்ஸ் மெட்டாக்டாக்டர்கள்:
ஆ$ .* + ? ( ) [ ] { } |ஒரு regex, metacharacters உடன் அல்லது இல்லாமல், ஒரு முறை.
எழுத்து வகுப்புகள்
சதுர அடைப்புக்குறிகள்
ஒரு முறை சதுர அடைப்புக்குறிக்குள் எழுத்துக்களைக் கொண்டிருக்கலாம். இதனுடன், இலக்கு சரத்தில் ஒரு குறிப்பிட்ட நிலை எந்த சதுர அடைப்புக்குறி எழுத்துக்களுடனும் பொருந்தும். பின்வரும் இலக்குகளை கருத்தில் கொள்ளுங்கள்:
'பூனை அறையில் இருக்கிறது.''மட்டை அறையில் உள்ளது.'
'எலி அறையில் இருக்கிறது.'
ரீஜெக்ஸ், [cbr] முதல் இலக்கில் பூனையுடன் பொருந்தும். இது இரண்டாவது இலக்கில் மட்டையுடன் பொருந்தும். இது மூன்றாவது இலக்கில் எலியுடன் பொருந்தும். ஏனென்றால், பூனை அல்லது மட்டை அல்லது எலி 'c' அல்லது 'b' அல்லது 'r' உடன் தொடங்குகிறது. பின்வரும் குறியீடு பிரிவு இதை விளக்குகிறது:
regex reg('[cbr] மணிக்கு');என்றால் (regex_search('பூனை அறையில் இருக்கிறது.',ரெக்))
செலவு<< 'பொருந்தியது' <<endl;
என்றால் (regex_search('மட்டை அறையில் உள்ளது.',ரெக்))
செலவு<< 'பொருந்தியது' <<endl;
என்றால் (regex_search('எலி அறையில் இருக்கிறது.',ரெக்))
செலவு<< 'பொருந்தியது' <<endl;
வெளியீடு:
பொருந்தியதுபொருந்தியது
பொருந்தியது
கதாபாத்திரங்களின் வரம்பு
வர்க்கம், [cbr] வடிவத்தில் [cbr], இலக்கில் பல சாத்தியமான எழுத்துக்களுடன் பொருந்தும். இது இலக்கில் 'c' அல்லது 'b' அல்லது 'r' உடன் பொருந்தும். இலக்குக்கு 'சி' அல்லது 'பி' அல்லது 'ஆர்' எதுவும் இல்லை என்றால், அதைத் தொடர்ந்து, எந்த பொருத்தமும் இருக்காது.
'சி' அல்லது 'பி' அல்லது 'ஆர்' போன்ற சில சாத்தியங்கள் ஒரு வரம்பில் உள்ளன. 0 முதல் 9 வரையிலான இலக்கங்களின் வரம்பில் 10 சாத்தியங்கள் உள்ளன, அதற்கான முறை [0-9]. சிறிய எழுத்துக்களின் வரம்பு, a to z, 26 சாத்தியக்கூறுகளைக் கொண்டுள்ளது, அதற்கான முறை [a-z] ஆகும். பெரிய எழுத்துக்களின் வரம்பு, A முதல் Z வரை, 26 சாத்தியங்கள் உள்ளன, அதற்கான முறை [A-Z] ஆகும். - அதிகாரப்பூர்வமாக ஒரு மெட்டாசாக்டர் அல்ல, ஆனால் சதுர அடைப்புக்குறிக்குள், அது ஒரு வரம்பைக் குறிக்கும். எனவே, பின்வருபவை ஒரு பொருத்தத்தை உருவாக்குகின்றன:
என்றால் (regex_search('ID6id',ரீஜெக்ஸ்('[0-9]')))செலவு<< 'பொருந்தியது' <<endl;
இரண்டாவது வாதமாக ரீஜெக்ஸ் எவ்வாறு கட்டப்பட்டுள்ளது என்பதைக் கவனியுங்கள். இலக்கமானது, 6 வரம்பில், 0 முதல் 9 வரை, மற்றும் இலக்கு 6, ID6id க்கு இடையில் போட்டி நடக்கிறது. மேலே உள்ள குறியீடு இதற்கு சமம்:
என்றால் (regex_search('ID6id',ரீஜெக்ஸ்('[0123456789]')))செலவு<< 'பொருந்தியது' <<endl;
பின்வரும் குறியீடு ஒரு பொருத்தத்தை உருவாக்குகிறது:
கரிப[] = 'ID6iE';என்றால் (regex_search(ப,ரீஜெக்ஸ்('[a-z]')))
செலவு<< 'பொருந்தியது' <<endl;
இங்கே முதல் வாதம் ஒரு சரம் மாறி மற்றும் சரம் நேரடி அல்ல என்பதை நினைவில் கொள்க. போட்டி [a-z] இல் 'i' மற்றும் ID6iE இல் 'i' க்கு இடையில் உள்ளது.
ஒரு வரம்பு ஒரு வகுப்பு என்பதை மறந்துவிடாதீர்கள். வரம்பின் வலதுபுறம் அல்லது வரம்பின் இடதுபுறத்தில் வடிவத்தில் உரை இருக்கலாம். பின்வரும் குறியீடு ஒரு பொருத்தத்தை உருவாக்குகிறது:
என்றால் (regex_search(ID2id ஒரு ஐடி ',ரீஜெக்ஸ்('ஐடி [0-9] ஐடி')))செலவு<< 'பொருந்தியது' <<endl;
போட்டி ஐடி [0-9] ஐடி மற்றும் ஐடி 2 ஐடி இடையே உள்ளது. இலக்கு சரத்தின் மீதமுள்ள, ஒரு ஐடி, இந்த சூழ்நிலையில் பொருந்தவில்லை.
வழக்கமான வெளிப்பாடு பாடத்தில் (regexes) பயன்படுத்தப்படுவது போல், வர்க்கம் என்ற சொல் உண்மையில் ஒரு தொகுப்பு என்று பொருள். அதாவது, தொகுப்பில் உள்ள கதாபாத்திரங்களில் ஒன்று பொருந்தும்.
குறிப்பு: ஹைபன் - ஒரு வரம்பைக் குறிக்கும் சதுர அடைப்புக்குறிக்குள் மட்டுமே ஒரு மெட்டாச்சார்டர். இது சதுர அடைப்புக்குறிக்கு வெளியே, ரீஜெக்ஸில் உள்ள ஒரு மெட்டாசாக்டர் அல்ல.
புறக்கணிப்பு
ஒரு வரம்பு உட்பட ஒரு வர்க்கம் மறுக்கப்படலாம். அதாவது, தொகுப்பில் (வகுப்பு) உள்ள எழுத்துக்கள் அல்லாதவை பொருந்த வேண்டும். வகுப்பு வடிவத்தின் தொடக்கத்தில், தொடக்க சதுர அடைப்புக்குறிக்குப் பிறகு இது ^ மெட்டாகாரக்டருடன் குறிக்கப்படுகிறது. எனவே, [^0-9] என்பது இலக்கில் பொருத்தமான இடத்தில் பாத்திரத்தை பொருத்துவதாகும், இது 0 முதல் 9 வரையிலான வரம்பில் எந்த கதாபாத்திரமும் இல்லை. எனவே பின்வரும் குறியீடு ஒரு பொருத்தத்தை உருவாக்காது:
என்றால் (regex_search('0123456789101112',ரீஜெக்ஸ்('[^ 0-9]')))செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
0 முதல் 9 வரம்பிற்குள் உள்ள இலக்கமானது இலக்கு சரம் நிலைகளில் ஏதேனும் ஒன்றைக் காணலாம், 0123456789101112 ,; அதனால் பொருத்தம் இல்லை - மறுப்பு.
பின்வரும் குறியீடு ஒரு பொருத்தத்தை உருவாக்குகிறது:
என்றால் (regex_search('ABCDEFGHIJ',ரீஜெக்ஸ்('[^ 0-9]')))செலவு<< 'பொருந்தியது' <<endl;
இலக்கில் எந்த இலக்கமும் காணப்படவில்லை, ABCDEFGHIJ ,; எனவே ஒரு போட்டி உள்ளது.
[a-z] என்பது [^a-z] க்கு வெளியே உள்ள ஒரு வரம்பு. அதனால் [^a-z] என்பது [a-z] இன் மறுப்பு.
[A-Z] என்பது வெளிப்புற வரம்பு [^A-Z]. அதனால் [^A-Z] என்பது [A-Z] இன் மறுப்பு.
பிற மறுப்புகள் உள்ளன.
ஒளிரும் இடங்கள்
‘’ அல்லது t அல்லது r அல்லது n அல்லது f என்பது ஒரு வெளிறிய எழுத்து. பின்வரும் குறியீட்டில், regex, n இலக்கில் ‘ n’ உடன் பொருந்துகிறது:
என்றால் (regex_search('வரிசையில் ஒன்று. r nவரி இரண்டு. ',ரீஜெக்ஸ்(' n')))செலவு<< 'பொருந்தியது' <<endl;
எந்த வெளிறிய எழுத்துக்கும் பொருந்தும்
எந்த வெண்வெளி எழுத்துக்களுடனும் பொருந்தும் முறை அல்லது வர்க்கம், [ t r n f]. பின்வரும் குறியீட்டில், '' பொருந்தும்:
என்றால் (regex_search('ஒன்று இரண்டு',ரீஜெக்ஸ்('[ t r n f] ')))செலவு<< 'பொருந்தியது' <<endl;
எந்த வெளிறாத தன்மையையும் பொருத்துதல்
வெள்ளை அல்லாத இடைவெளி எழுத்துகளுடன் பொருந்தும் முறை அல்லது வர்க்கம், [^ t r n f]. பின்வரும் குறியீடு ஒரு பொருத்தத்தை உருவாக்குகிறது, ஏனெனில் இலக்கில் வெற்று இடம் இல்லை:
என்றால் (regex_search('1234 ஏபிசிடி',ரீஜெக்ஸ்('[^ t r n f] ')))செலவு<< 'பொருந்தியது' <<endl;
வடிவத்தில் காலம் (.)
வடிவத்தில் உள்ள காலம். ஒரு போட்டி பின்வரும் குறியீட்டில் தயாரிக்கப்படுகிறது:
என்றால் (regex_search('1234 ஏபிசிடி',ரீஜெக்ஸ்('.')))செலவு<< 'பொருந்தியது' <<endl;
பின்வரும் குறியீட்டில் பொருந்தும் முடிவுகள் இல்லை, ஏனெனில் இலக்கு n.
என்றால் (regex_search(' n',ரீஜெக்ஸ்('.')))செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
குறிப்பு: சதுர அடைப்புக்குறிக்குள் ஒரு எழுத்து வகுப்பின் உள்ளே, காலத்திற்கு சிறப்பு அர்த்தம் இல்லை.
பொருந்தும் மறுபடியும்
ஒரு எழுத்து அல்லது எழுத்துக்களின் குழு இலக்கு சரத்திற்குள் ஒன்றுக்கு மேற்பட்ட முறை நிகழலாம். ஒரு முறை இந்த மறுபடியும் பொருந்தும். இலக்கில் மீண்டும் மீண்டும் பொருந்துவதற்கு மெட்டாசாக்டர்கள்,?, *, +, மற்றும் {} பயன்படுத்தப்படுகின்றன. இலக்கு சரத்தில் x என்பது ஒரு ஆர்வமுள்ள தன்மை என்றால், மெட்டாசாக்டர்களுக்கு பின்வரும் அர்த்தங்கள் உள்ளன:
எக்ஸ்*:பொருத்தம் என்று பொருள்'எக்ஸ்' 0அல்லது அதற்கு மேற்பட்ட முறை,நான்.மற்றும்.,எத்தனை முறை வேண்டுமானாலும்எக்ஸ்+:பொருத்தம் என்று பொருள்'எக்ஸ்' 1அல்லது அதற்கு மேற்பட்ட முறை,நான்.மற்றும்.,ஒரு முறையாவது
எக்ஸ்? :பொருத்தம் என்று பொருள்'எக்ஸ்' 0அல்லது1 நேரம்
எக்ஸ்{என்,}:பொருத்தம் என்று பொருள்'எக்ஸ்'குறைந்தது n அல்லது அதற்கு மேற்பட்ட முறை.குறிப்புகமா
எக்ஸ்{என்} :பொருத்துக'எக்ஸ்'சரியாக n முறை
எக்ஸ்{என்,மீ}:பொருத்துக'எக்ஸ்'குறைந்தது n முறை,ஆனால் மீ முறைக்கு மேல் இல்லை.
இந்த உருமாற்றங்கள் அழைக்கப்படுகின்றன அளவீடுகள்.
விளக்கப்படங்கள்
*
* * முந்தைய எழுத்து அல்லது முந்தைய குழு, பூஜ்யம் அல்லது பல முறை பொருந்துகிறது. o* இலக்கு சரத்தின் நாயுடன் 'o' உடன் பொருந்துகிறது. இது புத்தகத்திலும் தோற்றத்திலும் பொருந்துகிறது. Regex, o* பொருந்தும் விலங்கு booooed.
+
1 + அல்லது அதற்கு மேற்பட்ட முறை முந்தைய எழுத்து அல்லது முந்தைய குழுவுடன் பொருந்துகிறது. பூஜ்ஜியத்துடன் அல்லது அதற்கு மேற்பட்ட முறை *க்கு மாறாக. எனவே, ரெஜெக்ஸ், ஈ+ சாப்பிடுவதில் 'இ' உடன் பொருந்துகிறது, அங்கு 'இ' ஒரு முறை நிகழ்கிறது. e+ ஆடுகளில் ee உடன் பொருந்துகிறது, அங்கு 'e' ஒன்றுக்கு மேற்பட்ட முறை நிகழ்கிறது. கவனம்
?
தி? முந்தைய எழுத்து அல்லது முந்தைய குழு, 0 அல்லது 1 முறை பொருந்துகிறது (மேலும் இல்லை). எனவே, இ? போட்டிகள் தோண்டப்படுகின்றன, ஏனெனில் ‘ஈ’ தோண்டுவது, பூஜ்ஜிய நேரத்தில். இ? 'இ' தொகுப்பில் ஒரு முறை ஏற்படுவதால் போட்டிகள் அமைக்கப்படுகின்றன. குறிப்பு: இ? இன்னும் ஆடுகளுடன் பொருந்துகிறது; ஆடுகளில் இரண்டு 'இ'கள் இருந்தாலும். இங்கே ஒரு நுணுக்கம் உள்ளது - பிறகு பார்க்கவும்.
{n,}
இது முந்தைய கதாபாத்திரம் அல்லது முந்தைய குழுவின் குறைந்தது n தொடர்ச்சியான மறுபடியும் பொருந்துகிறது. எனவே, regex, e {2,} இலக்கில் உள்ள இரண்டு ‘e’ களையும், செம்மறியாடுகளையும், இலக்கு ஆடுகளில் உள்ள மூன்று ‘e’களையும் பொருத்துகிறது. e {2,} தொகுப்புடன் பொருந்தவில்லை, ஏனென்றால் தொகுப்பில் ஒரே ஒரு 'e' உள்ளது.
{n}
இது முந்தைய கதாபாத்திரம் அல்லது முந்தைய குழுவின் தொடர்ச்சியான n தொடர்ச்சியான ஒத்திகளுடன் பொருந்துகிறது. எனவே, regex, e {2} இலக்கு, செம்மறி ஆகிய இரண்டு 'e களுடன் பொருந்துகிறது. e {2} தொகுப்புடன் பொருந்தவில்லை, ஏனெனில் தொகுப்பில் ஒரே ஒரு 'e' உள்ளது. சரி, இ {2} இலக்கில் இரண்டு ‘இ’க்களுடன் பொருந்துகிறது, ஷீப். இங்கே ஒரு நுணுக்கம் உள்ளது - பிறகு பார்க்கவும்.
{n, m}
இது முந்தைய எழுத்து அல்லது முந்தைய குழுவின் தொடர்ச்சியான பலமுறை, n முதல் m வரை எங்கும் பொருந்துகிறது. எனவே, ஈ '1,3}' ஈ 'இல்லாத டிக்கில் எதுவும் பொருந்தவில்லை. இது செட்டில் உள்ள ஒரு ‘இ’, இரண்டு ‘இ’கள் ஆடுகளிலும், மூன்று‘ இ ’ஷீப்பிலும், மூன்று‘ இ ’ஷீப்பிலும் பொருந்துகிறது. கடைசி போட்டியில் ஒரு நுணுக்கம் உள்ளது - பிறகு பார்க்கவும்.
பொருந்தும் மாற்று
கணினியில் பின்வரும் இலக்கு சரத்தைக் கவனியுங்கள்.
பண்ணையில் பல்வேறு அளவுகளில் பன்றிகள் உள்ளன.
இந்த இலக்கு ஆடு அல்லது முயல் அல்லது பன்றி இருக்கிறதா என்பதை புரோகிராமர் அறிய விரும்பலாம். குறியீடு பின்வருமாறு இருக்கும்:
கரிப[] = 'பண்ணையில் வெவ்வேறு அளவுகளில் பன்றிகள் உள்ளன.';என்றால் (regex_search(ப,ரீஜெக்ஸ்('ஆடு | முயல் | பன்றி')))
செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
குறியீடு ஒரு பொருத்தத்தை உருவாக்குகிறது. மாற்று எழுத்தின் பயன்பாட்டைக் கவனியுங்கள், |. இரண்டு, மூன்று, நான்கு மற்றும் பல விருப்பங்கள் இருக்கலாம். சி ++ முதலில் இலக்கு சரத்தில் ஒவ்வொரு எழுத்து நிலையில் முதல் மாற்றான ஆட்டை பொருத்த முயற்சிக்கும். அது ஆடுடன் வெற்றிபெறவில்லை என்றால், அது அடுத்த மாற்று முயலை முயற்சிக்கிறது. முயலால் அது வெற்றிபெறவில்லை என்றால், அது அடுத்த மாற்றான பன்றியை முயற்சிக்கிறது. பன்றி தோல்வியுற்றால், சி ++ இலக்கில் அடுத்த நிலைக்குச் சென்று மீண்டும் முதல் மாற்றுடன் தொடங்குகிறது.
மேலே உள்ள குறியீட்டில், பன்றி பொருந்துகிறது.
பொருத்தம் ஆரம்பம் அல்லது முடிவு
தொடங்குதல்
ரெஜெக்ஸின் தொடக்கத்தில் ^ இருந்தால், இலக்கு சரத்தின் தொடக்க உரையை ரெஜெக்ஸால் பொருத்தலாம். பின்வரும் குறியீட்டில், இலக்கின் தொடக்கம் abc ஆகும், இது பொருந்துகிறது:
செலவு<< 'பொருந்தியது' <<endl;
பின்வரும் குறியீட்டில் பொருந்தவில்லை
என்றால் (regex_search('ஆம், ஏபிசி மற்றும் டெஃப்',ரீஜெக்ஸ்('^ ஏபிசி')))செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
இங்கே, ஏபிசி இலக்கின் தொடக்கத்தில் இல்லை.
கவனம் எழுத்து வகுப்பின் தொடக்கத்தில் இது இன்னும் ஒரு மெட்டாசாக்டராக உள்ளது, அங்கு அது வகுப்பை மறுக்கிறது.
முடிவு
ரீஜெக்ஸின் முடிவில் $ இருந்தால், இலக்கு சரத்தின் இறுதி உரையை ரெஜெக்ஸால் பொருத்தலாம். பின்வரும் குறியீட்டில், இலக்கின் முடிவு xyz ஆகும், இது பொருந்துகிறது:
என்றால் (regex_search('uvw மற்றும் xyz',ரீஜெக்ஸ்('xyz $')))செலவு<< 'பொருந்தியது' <<endl;
பின்வரும் குறியீட்டில் பொருந்தவில்லை
என்றால் (regex_search('uvw மற்றும் xyz இறுதி',ரீஜெக்ஸ்('xyz $')))செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
இங்கே, xyz இலக்கின் முடிவில் இல்லை.
தொகுத்தல்
ஒரு வடிவத்தில் கதாபாத்திரங்களை குழுவாக்க பெற்றோர் எழுத்துக்கள் பயன்படுத்தப்படலாம். பின்வரும் ரீஜெக்ஸைக் கவனியுங்கள்:
'ஒரு கச்சேரி (பியானோ கலைஞர்)'இங்குள்ள குழு பியானோ கலைஞர்களால் சூழப்பட்டுள்ளது. இது உண்மையில் ஒரு துணை குழு, அதே நேரத்தில் ஒரு கச்சேரி (பியானோ கலைஞர்) முழு குழுவாகும். பின்வருவதைக் கவனியுங்கள்:
'பியானோ கலைஞர் நல்லவர்'இங்கே, துணை குழு அல்லது துணை சரம், பியானோ கலைஞர் நல்லது.
பொதுவான பகுதிகளுடன் துணை சரங்கள்
புத்தக பராமரிப்பாளர் புத்தகங்களை கவனித்துக் கொள்ளும் ஒரு நபர். ஒரு புத்தக காப்பாளர் மற்றும் புத்தக அலமாரியுடன் ஒரு நூலகத்தை கற்பனை செய்து பாருங்கள். பின்வரும் இலக்கு சரங்களில் ஒன்று கணினியில் இருப்பதாக வைத்துக்கொள்ளுங்கள்:
'நூலகத்தில் ஒரு புத்தக அலமாரி போற்றப்படுகிறது.';'இதோ புத்தக காப்பாளர்';
புத்தகக் காவலர் புத்தக அலமாரியுடன் வேலை செய்கிறார். ';
புரோகிராமரின் ஆர்வம் கம்ப்யூட்டரில் இந்த வாக்கியங்களில் எது இருக்கிறது என்பதை அறியவில்லை என்று வைத்துக்கொள்ளுங்கள். இருப்பினும், கணினியில் எந்த இலக்கு சரமாக இருந்தாலும் புத்தக அலமாரி அல்லது புத்தக காப்பாளர் இருக்கிறாரா என்பதை அறிவதே அவரது ஆர்வம். இந்த வழக்கில், அவரது regex இருக்க முடியும்:
'புத்தக அலமாரி | புத்தக பராமரிப்பாளர்.'மாற்றீட்டைப் பயன்படுத்துதல்.
இரண்டு சொற்களுக்கும் பொதுவான புத்தகத்தை இரண்டு முறை தட்டச்சு செய்திருப்பதைக் கவனியுங்கள். புத்தகத்தை இரண்டு முறை தட்டச்சு செய்வதைத் தவிர்க்க, ரீஜெக்ஸ் சிறப்பாக எழுதப்படும்:
புத்தகம் (அலமாரி | கீப்பர்) 'இங்கே, குழு, அலமாரி | கீப்பர் மாற்று மெட்டாசாக்டர் இன்னும் பயன்படுத்தப்படுகிறது, ஆனால் இரண்டு நீண்ட வார்த்தைகளுக்கு அல்ல. இது இரண்டு நீண்ட சொற்களின் இரண்டு இறுதிப் பகுதிகளுக்குப் பயன்படுத்தப்பட்டது. C ++ ஒரு குழுவை ஒரு நிறுவனமாக கருதுகிறது. எனவே, C ++ புத்தகத்திற்குப் பிறகு உடனடியாக வரும் அலமாரி அல்லது கீப்பரைத் தேடும். பின்வரும் குறியீட்டின் வெளியீடு பொருந்துகிறது:
கரிப[] = 'நூலகத்தில் ஒரு புத்தக அலமாரி போற்றப்படுகிறது.';என்றால் (regex_search(ப,ரீஜெக்ஸ்(புத்தகம் (அலமாரி | கீப்பர்) ')))
செலவு<< 'பொருந்தியது' <<endl;
புத்தக அலமாரி மற்றும் புத்தக பராமரிப்பாளர் பொருந்தவில்லை.
ஐகேஸ் மற்றும் மல்டிலைன் regex_constants
ஐகேஸ்
பொருத்துதல் இயல்பாக வழக்கு உணர்திறன் கொண்டது. இருப்பினும், இது வழக்கு உணர்வற்றதாக மாற்றப்படலாம். இதை அடைய, regex :: icase மாறிலியைப் பயன்படுத்தவும், பின்வரும் குறியீட்டைப் போல:
என்றால் (regex_search('பின்னூட்டம்',ரீஜெக்ஸ்('தீவனம்',ரீஜெக்ஸ்::ஐகேஸ்)))செலவு<< 'பொருந்தியது' <<endl;
வெளியீடு பொருந்துகிறது. எனவே பெரிய எழுத்து 'F' உடன் பின்னூட்டம் சிறிய 'f' உடன் ஊட்டத்துடன் பொருந்துகிறது. regex :: icase ஆனது regex () கட்டமைப்பாளரின் இரண்டாவது வாதமாக மாற்றப்பட்டுள்ளது. அது இல்லாமல், அறிக்கை ஒரு பொருத்தத்தை உருவாக்காது.
மல்டிலைன்
பின்வரும் குறியீட்டை கவனியுங்கள்:
கரிப[] = 'வரிசை 1 nவரி 2 nவரி 3 ';என்றால் (regex_search(ப,ரீஜெக்ஸ்('^. * $')))
செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
வெளியீடு பொருந்தவில்லை. ரெஜெக்ஸ், ^.*$, இலக்கு சரத்தை அதன் ஆரம்பத்தில் இருந்து இறுதி வரை பொருத்துகிறது. .* என்பது n, பூஜ்யம் அல்லது அதற்கு மேற்பட்ட முறை தவிர எந்த எழுத்தையும் குறிக்கிறது. எனவே, இலக்கு உள்ள புதிய வரிசைகள் ( n) காரணமாக, பொருத்தம் இல்லை.
இலக்கு ஒரு மல்டிலைன் சரம். புதிய வரிசையுடன் ‘.’ பொருந்துவதற்கு, நிலையான regex :: multiline செய்யப்பட வேண்டும், ரெஜெக்ஸ் () கட்டுமானத்தின் இரண்டாவது வாதம். பின்வரும் குறியீடு இதை விளக்குகிறது:
கரிப[] = 'வரிசை 1 nவரி 2 nவரி 3 ';என்றால் (regex_search(ப,ரீஜெக்ஸ்('^. * $',ரீஜெக்ஸ்::பல வரி)))
செலவு<< 'பொருந்தியது' <<endl;
வேறு
செலவு<< 'பொருந்தவில்லை' <<endl;
முழு இலக்கு சரத்துடன் பொருந்துகிறது
புதிய இலக்கு எழுத்து ( n) இல்லாத முழு இலக்கு சரத்தையும் பொருத்த, regex_match () செயல்பாட்டைப் பயன்படுத்தலாம். இந்த செயல்பாடு regex_search () இலிருந்து வேறுபட்டது. பின்வரும் குறியீடு இதை விளக்குகிறது:
கரிப[] = 'முதல் இரண்டாம் மூன்றாம்';என்றால் (regex_match(ப,ரீஜெக்ஸ்('.*இரண்டாவது.*')))
செலவு<< 'பொருந்தியது' <<endl;
இங்கே ஒரு போட்டி உள்ளது. இருப்பினும், ரெஜெக்ஸ் முழு இலக்கு சரத்துடனும் பொருந்துகிறது என்பதை நினைவில் கொள்க, மற்றும் இலக்கு சரத்திற்கு எந்த ' n' இல்லை.
பொருத்தம்_ முடிவுகள் பொருள்
Regex_search () செயல்பாடு இலக்குக்கும் regex பொருளுக்கும் இடையில் ஒரு வாதத்தை எடுக்கலாம். இந்த வாதம் போட்டி_ முடிவுகள் முடிவுகள். முழு பொருந்தும் (பகுதி) சரம் மற்றும் பொருந்திய துணை சரங்களை அதனுடன் அறியலாம். இந்த பொருள் முறைகள் கொண்ட ஒரு சிறப்பு வரிசை. பொருத்தம்_ முடிவுகள் பொருள் வகை cmatch (சரம் எழுத்துக்களுக்கு).
போட்டிகளைப் பெறுதல்
பின்வரும் குறியீட்டை கவனியுங்கள்:
கரிப[] = 'நீங்கள் தேடும் பெண்!';cmatch m;
என்றால் (regex_search(ப,மீ,ரீஜெக்ஸ்('w.mn')))
செலவு<<மீ[0] <<endl;
இலக்கு சரத்தில் பெண் என்ற சொல் உள்ளது. வெளியீடு பெண் ', இது ரெஜெக்ஸ், w.mn உடன் ஒத்துள்ளது. குறியீட்டு பூஜ்ஜியத்தில், சிறப்பு வரிசை ஒரே பொருத்தத்தைக் கொண்டுள்ளது, இது பெண்.
வகுப்பு விருப்பங்களுடன், இலக்கில் காணப்படும் முதல் சரம் மட்டும் சிறப்பு வரிசைக்கு அனுப்பப்படும். பின்வரும் குறியீடு இதை விளக்குகிறது:
cmatch m;என்றால் (regex_search('எலி, பூனை, மட்டை!',மீ,ரீஜெக்ஸ்('[bcr] இல்')))
செலவு<<மீ[0] <<endl;
செலவு<<மீ[1] <<endl;
செலவு<<மீ[2] <<endl;
வெளியீடு குறியீட்டு பூஜ்ஜியத்திலிருந்து எலி. m [1] மற்றும் m [2] காலியாக உள்ளன.
மாற்றுகளுடன், இலக்கில் காணப்படும் முதல் சரம் மட்டும் சிறப்பு வரிசைக்கு அனுப்பப்படும். பின்வரும் குறியீடு இதை விளக்குகிறது:
என்றால் (regex_search('முயல், ஆடு, பன்றி!',மீ,ரீஜெக்ஸ்('ஆடு | முயல் | பன்றி')))செலவு<<மீ[0] <<endl;
செலவு<<மீ[1] <<endl;
செலவு<<மீ[2] <<endl;
வெளியீடு குறியீட்டு பூஜ்ஜியத்திலிருந்து முயல். m [1] மற்றும் m [2] காலியாக உள்ளன.
குழுக்கள்
குழுக்கள் ஈடுபடும்போது, முழுமையான முறை பொருந்தும், சிறப்பு வரிசையின் செல் பூஜ்ஜியத்திற்கு செல்கிறது. கண்டுபிடிக்கப்பட்ட அடுத்த சரம் செல் 1 க்கு செல்கிறது; துணை சரம் தொடர்ந்து, செல் 2 க்கு செல்கிறது; மற்றும் பல. பின்வரும் குறியீடு இதை விளக்குகிறது:
என்றால் (regex_search('இன்று சிறந்த புத்தக விற்பனையாளர்!',மீ,ரீஜெக்ஸ்(புத்தகம் ((sel) (ler)) ')))செலவு<<மீ[0] <<endl;
செலவு<<மீ[1] <<endl;
செலவு<<மீ[2] <<endl;
செலவு<<மீ[3] <<endl;
வெளியீடு:
புத்தக விற்பனையாளர்விற்பனையாளர்
செல்
படி
குழு (விற்பனையாளர்) குழுவிற்கு (sel) முன் வருவதை கவனிக்கவும்.
போட்டியின் நிலை
க்மாட்ச் வரிசையில் உள்ள ஒவ்வொரு துணை சரத்திற்கும் போட்டியின் நிலையை அறிய முடியும். இலக்கு சரத்தின் முதல் எழுத்தில் இருந்து, பூஜ்ஜிய நிலையில் எண்ணுதல் தொடங்குகிறது. பின்வரும் குறியீடு இதை விளக்குகிறது:
cmatch m;என்றால் (regex_search('இன்று சிறந்த புத்தக விற்பனையாளர்!',மீ,ரீஜெக்ஸ்(புத்தகம் ((sel) (ler)) ')))
செலவு<<மீ[0] << '->' <<மீநிலை(0) <<endl;
செலவு<<மீ[1] << '->' <<மீநிலை(1) <<endl;
செலவு<<மீ[2] << '->' <<மீநிலை(2) <<endl;
செலவு<<மீ[3] << '->' <<மீநிலை(3) <<endl;
நிலைச் சொத்தை, செல் குறியீட்டுடன், ஒரு வாதமாகப் பயன்படுத்துவதைக் கவனியுங்கள். வெளியீடு:
புத்தக விற்பனையாளர்->5விற்பனையாளர்->9
செல்->9
படி->12
தேடல் மற்றும் மாற்று
ஒரு புதிய சொல் அல்லது சொற்றொடர் பொருத்தத்தை மாற்றும். இதற்கு regex_replace () செயல்பாடு பயன்படுத்தப்படுகிறது. எனினும், இம்முறை, இடமாற்றம் நிகழும் சரம் சரம் பொருள், சரம் நேரடி அல்ல. எனவே, சரம் நூலகம் திட்டத்தில் சேர்க்கப்பட வேண்டும். விளக்கம்:
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
நேம்ஸ்பேஸ் எஸ்டிடியைப் பயன்படுத்துதல்;
intமுக்கிய()
{
சரம் str= 'இதோ, என் மனிதன் வருகிறான். அங்கே உங்கள் மனிதன் செல்கிறான். ';
சரம் newStr=regex_replace(ப,ரீஜெக்ஸ்('ஆண்'), 'பெண்');
செலவு<<newStr<<endl;
திரும்ப 0;
}
Regex_replace () செயல்பாடு, இங்கு குறியிடப்பட்டுள்ளபடி, அனைத்துப் பொருத்தங்களையும் மாற்றுகிறது. செயல்பாட்டின் முதல் வாதம் இலக்கு, இரண்டாவது ரெஜெக்ஸ் பொருள், மற்றும் மூன்றாவது மாற்று சரம். செயல்பாடு ஒரு புதிய சரத்தை அளிக்கிறது, இது இலக்கு ஆனால் மாற்றீடு கொண்டது. வெளியீடு:
இதோ என் பெண் வருகிறாள். அங்கே உங்கள் பெண் செல்கிறார்.
முடிவுரை
வழக்கமான வெளிப்பாடு இலக்கு வரிசை சரத்தில் அடித்தளங்களை பொருத்த வடிவங்களைப் பயன்படுத்துகிறது. வடிவங்கள் மெட்டாச்சார்டர்களைக் கொண்டுள்ளன. சி ++ வழக்கமான வெளிப்பாடுகளுக்கு பொதுவாகப் பயன்படுத்தப்படும் செயல்பாடுகள்: regex_search (), regex_match () மற்றும் regex_replace (). ரெஜெக்ஸ் என்பது இரட்டை மேற்கோள்களில் ஒரு முறை. இருப்பினும், இந்த செயல்பாடுகள் ரீஜெக்ஸ் பொருளை ஒரு வாதமாக எடுத்துக்கொள்கின்றன, ரீஜெக்ஸ் மட்டுமல்ல. இந்த செயல்பாடுகளைப் பயன்படுத்துவதற்கு முன்பு ரீஜெக்ஸ் ஒரு ரீஜெக்ஸ் பொருளாக மாற்றப்பட வேண்டும்.