सी ++ में नियमित अभिव्यक्ति मूल बातें

Regular Expression Basics C



उद्धरणों में निम्नलिखित वाक्य पर विचार करें:

'यहाँ मेरा आदमी है।'

यह स्ट्रिंग कंप्यूटर के अंदर हो सकती है, और उपयोगकर्ता जानना चाह सकता है कि क्या इसमें आदमी शब्द है। यदि उसके पास पुरुष शब्द है, तो वह पुरुष शब्द को स्त्री में बदलना चाहेगा; ताकि स्ट्रिंग को पढ़ना चाहिए:







'यहाँ मेरी औरत है।'

इस तरह की और भी बहुत सी इच्छाएँ कंप्यूटर उपयोगकर्ता की होती हैं; कुछ जटिल हैं। रेगुलर एक्सप्रेशन, संक्षिप्त, रेगेक्स, कंप्यूटर द्वारा इन मुद्दों को संभालने का विषय है। सी ++ रेगेक्स नामक लाइब्रेरी के साथ आता है। तो, रेगेक्स को संभालने के लिए एक सी ++ प्रोग्राम के साथ शुरू होना चाहिए:



#शामिल

#शामिल

नेमस्पेस एसटीडी का उपयोग करना;

यह आलेख सी++ में रेगुलर एक्सप्रेशन मूल बातें समझाता है।



लेख सामग्री

रेगुलर एक्सप्रेशन फंडामेंटल

regex

एक स्ट्रिंग जैसे यहाँ मेरा आदमी है। ऊपर लक्ष्य अनुक्रम या लक्ष्य स्ट्रिंग या बस, लक्ष्य है। आदमी, जिसे खोजा गया था, वह रेगुलर एक्सप्रेशन है, या बस, रेगेक्स है।





मेल मिलाना

मिलान तब कहा जाता है जब वह शब्द या वाक्यांश जिसे खोजा जा रहा हो, स्थित हो। मिलान के बाद, एक प्रतिस्थापन हो सकता है। उदाहरण के लिए, पुरुष के ऊपर स्थित होने के बाद, इसे महिला द्वारा प्रतिस्थापित किया जा सकता है।

सरल मिलान

निम्नलिखित कार्यक्रम दिखाता है कि आदमी शब्द कैसे मेल खाता है।



#शामिल

#शामिल

नेमस्पेस एसटीडी का उपयोग करना;

NSमुख्य()
{

रेगेक्स रेग('पुरुष');
अगर (रेगेक्स_सर्च('यहाँ मेरा आदमी है।',रेग))
लागत<< 'मिलान' <<एंडली;
अन्यथा
लागत<< 'मिलान नही हुआ' <<एंडली;

वापसी 0;
}

यदि कोई मिलान है तो फ़ंक्शन regex_search () सत्य लौटाता है और यदि कोई मिलान नहीं होता है तो असत्य लौटाता है। यहां, फ़ंक्शन दो तर्क लेता है: पहला लक्ष्य स्ट्रिंग है, और दूसरा रेगेक्स ऑब्जेक्ट है। रेगेक्स स्वयं 'आदमी' है, डबल-कोट्स में। मुख्य () फ़ंक्शन में पहला कथन रेगेक्स ऑब्जेक्ट बनाता है। रेगेक्स एक प्रकार है, और रेग रेगेक्स ऑब्जेक्ट है। उपरोक्त प्रोग्राम का आउटपुट 'मिलान' है, क्योंकि लक्ष्य स्ट्रिंग में 'मैन' देखा जाता है। यदि लक्ष्य में 'आदमी' नहीं देखा गया था, तो regex_search() गलत लौटा होगा, और आउटपुट 'मिलान नहीं' होगा।

निम्नलिखित कोड का आउटपुट मेल नहीं खाता है:

रेगेक्स रेग('पुरुष');
अगर (रेगेक्स_सर्च('यहाँ मेरा निर्माण है।',रेग))
लागत<< 'मिलान' <<एंडली;
अन्यथा
लागत<< 'मिलान नही हुआ' <<एंडली;

मेल नहीं हुआ क्योंकि रेगेक्स 'मैन' पूरे लक्ष्य स्ट्रिंग में नहीं मिला, 'हियर इज माई मेकिंग'।

प्रतिरूप

नियमित अभिव्यक्ति, ऊपर आदमी, बहुत सरल है। रेगेक्स आमतौर पर इतना आसान नहीं होता है। रेगुलर एक्सप्रेशन में मेटाएक्टैक्टर होते हैं। मेटाकैरेक्टर विशेष अर्थ वाले पात्र होते हैं। एक मेटाकैरेक्टर पात्रों के बारे में एक चरित्र है। सी ++ रेगेक्स मेटाएक्टेक्टर हैं:

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

एक रेगेक्स, मेटाएक्टेक्टर्स के साथ या बिना, एक पैटर्न है।

चरित्र वर्ग

वर्ग कोष्ठक

एक पैटर्न में वर्ग कोष्ठक के भीतर वर्ण हो सकते हैं। इसके साथ, लक्ष्य स्ट्रिंग में एक विशेष स्थिति वर्ग कोष्ठक के किसी भी वर्ण से मेल खाती है। निम्नलिखित लक्ष्यों पर विचार करें:

'बिल्ली कमरे में है।'

'बल्ला कमरे में है।'

'चूहा कमरे में है।'

रेगेक्स, [सीबीआर] पहले लक्ष्य में बिल्ली से मेल खाएगा। यह दूसरे लक्ष्य में बल्ले से मेल खाएगा। यह तीसरे लक्ष्य में चूहे से मुकाबला करेगा। ऐसा इसलिए है क्योंकि बिल्ली या बल्ला या चूहा 'c' या 'b' या 'r' से शुरू होता है। निम्नलिखित कोड खंड इसे दिखाता है:

रेगेक्स रेग('[सीबीआर] पर');
अगर (रेगेक्स_सर्च('बिल्ली कमरे में है।',रेग))
लागत<< 'मिलान' <<एंडली;
अगर (रेगेक्स_सर्च('बल्ला कमरे में है।',रेग))
लागत<< 'मिलान' <<एंडली;
अगर (रेगेक्स_सर्च('चूहा कमरे में है।',रेग))
लागत<< 'मिलान' <<एंडली;

आउटपुट है:

मिलान किया

मिलान किया

मिलान किया

वर्णों की श्रेणी

वर्ग, [cbr] पैटर्न [cbr] में, लक्ष्य में कई संभावित वर्णों से मेल खाएगा। यह लक्ष्य में 'सी' या 'बी' या 'आर' से मेल खाएगा। यदि लक्ष्य में 'c' या 'b' या 'r' में से कोई भी नहीं है, तो उसके बाद कोई मेल नहीं होगा।

'सी' या 'बी' या 'आर' जैसी कुछ संभावनाएं एक श्रेणी में मौजूद हैं। ० से ९ तक के अंकों की श्रेणी में १० संभावनाएं हैं, और उसके लिए पैटर्न [०-९] है। लोअरकेस अक्षरों की श्रेणी, ए से ज़ेड, में 26 संभावनाएं हैं, और इसके लिए पैटर्न [ए-जेड] है। अपरकेस अक्षरों की श्रेणी, ए से ज़ेड, में 26 संभावनाएं हैं, और उसके लिए पैटर्न [ए-जेड] है। - आधिकारिक तौर पर एक मेटाकैरेक्टर नहीं है, लेकिन वर्ग कोष्ठक के भीतर, यह एक सीमा को इंगित करेगा। तो, निम्नलिखित एक मैच पैदा करता है:

अगर (रेगेक्स_सर्च('ID6id',regex('[0-9]')))

लागत<< 'मिलान' <<एंडली;

ध्यान दें कि रेगेक्स को दूसरे तर्क के रूप में कैसे बनाया गया है। मैच अंक के बीच होता है, 6 की सीमा में, 0 से 9 तक, और लक्ष्य में 6, ID6id। उपरोक्त कोड इसके बराबर है:

अगर (रेगेक्स_सर्च('ID6id',regex('[0123456789]')))

लागत<< 'मिलान' <<एंडली;

निम्नलिखित कोड एक मैच उत्पन्न करता है:

charपी[] = 'आईडी6आईई';

अगर (रेगेक्स_सर्च(पी,regex('[ए-जेड]')))

लागत<< 'मिलान' <<एंडली;

ध्यान दें कि यहां पहला तर्क एक स्ट्रिंग वेरिएबल है न कि स्ट्रिंग अक्षर। मैच [a-z] में 'i' और ID6iE में 'i' के बीच है।

यह मत भूलो कि एक श्रेणी एक वर्ग है। पैटर्न में रेंज के दाईं ओर या रेंज के बाईं ओर टेक्स्ट हो सकता है। निम्नलिखित कोड एक मैच उत्पन्न करता है:

अगर (रेगेक्स_सर्च('ID2id एक आईडी है',regex('आईडी [0-9] आईडी')))

लागत<< 'मिलान' <<एंडली;

मैच ID[0-9]id और ID2id के बीच है। शेष लक्ष्य स्ट्रिंग, एक आईडी है, इस स्थिति में मेल नहीं खाती है।

जैसा कि नियमित अभिव्यक्ति विषय (रेगेक्स) में प्रयोग किया जाता है, वर्ग शब्द का अर्थ वास्तव में एक सेट है। यानी सेट में एक किरदार का मिलान होना है।

नोट: हाइफ़न - केवल वर्ग कोष्ठक के भीतर एक मेटाकैरेक्टर है, जो एक श्रेणी को दर्शाता है। यह वर्ग कोष्ठक के बाहर, रेगेक्स में एक मेटाएक्टेक्टर नहीं है।

नकार

एक श्रेणी सहित एक वर्ग को नकारा जा सकता है। अर्थात्, सेट (वर्ग) के पात्रों में से कोई भी मेल नहीं खाना चाहिए। इसे वर्ग पैटर्न की शुरुआत में ^ मेटाकैरेक्टर के साथ इंगित किया जाता है, जो शुरुआती वर्ग ब्रैकेट के ठीक बाद होता है। तो, [^0-9] का अर्थ है लक्ष्य में उपयुक्त स्थान पर वर्ण का मिलान करना, जो कि 0 से 9 तक की श्रेणी में कोई वर्ण नहीं है। तो निम्नलिखित कोड एक मैच का उत्पादन नहीं करेगा:

अगर (रेगेक्स_सर्च('01234567891011112',regex('[^ 0-9]')))

लागत<< 'मिलान' <<एंडली;

अन्यथा

लागत<< 'मिलान नही हुआ' <<एंडली;

0 से 9 की सीमा के भीतर एक अंक किसी भी लक्ष्य स्ट्रिंग स्थिति में पाया जा सकता है, 0123456789101112; इसलिए कोई मेल नहीं है - नकार।

निम्नलिखित कोड एक मैच उत्पन्न करता है:

अगर (रेगेक्स_सर्च('एबीसीडीईएफघिज',regex('[^ 0-9]')))

लागत<< 'मिलान' <<एंडली;

लक्ष्य में कोई अंक नहीं मिला, ABCDEFGHIJ,; तो एक मैच है।

[a-z] [^a-z] के बाहर की एक सीमा है। और इसलिए [^a-z] [a-z] का निषेध है।

[ए-जेड] [^ए-जेड] के बाहर की एक सीमा है। और इसलिए [^A-Z] [A-Z] का निषेध है।

अन्य निषेध मौजूद हैं।

व्हाइटस्पेस मिलान करना

'' या या या या f एक खाली स्थान वर्ण है। निम्नलिखित कोड में, रेगेक्स, लक्ष्य में ' ' से मेल खाता है:

अगर (रेगेक्स_सर्च('पंक्ति एक का।आरएनपंक्ति दो की।',regex('एन')))

लागत<< 'मिलान' <<एंडली;

किसी भी व्हॉट्सएप कैरेक्टर का मिलान करना

किसी भी व्हाइट स्पेस कैरेक्टर से मेल खाने वाला पैटर्न या क्लास है, [ f]। निम्नलिखित कूट में '' सुमेलित है :

अगर (रेगेक्स_सर्च('एक दो',regex('[टीआरएनएफ] ')))

लागत<< 'मिलान' <<एंडली;

किसी भी गैर-व्हाट्सएप कैरेक्टर का मिलान करना

किसी भी गैर-श्वेत स्थान वर्ण से मेल खाने वाला पैटर्न या वर्ग है, [^ f]। निम्न कोड एक मैच उत्पन्न करता है क्योंकि लक्ष्य में कोई सफेद जगह नहीं है:

अगर (रेगेक्स_सर्च('1234abcd',regex('[^टीआरएनएफ] ')))

लागत<< 'मिलान' <<एंडली;

पैटर्न में अवधि (।)

पैटर्न में अवधि (.) लक्ष्य में को छोड़कर, स्वयं सहित किसी भी वर्ण से मेल खाती है। निम्नलिखित कोड में एक मैच का उत्पादन किया जाता है:

अगर (रेगेक्स_सर्च('1234abcd',regex('।')))

लागत<< 'मिलान' <<एंडली;

निम्नलिखित कोड में कोई मिलान परिणाम नहीं है क्योंकि लक्ष्य है।

अगर (रेगेक्स_सर्च('एन',regex('।')))

लागत<< 'मिलान' <<एंडली;

अन्यथा

लागत<< 'मिलान नही हुआ' <<एंडली;

नोट: वर्ग कोष्ठक वाले वर्ण वर्ग के अंदर, अवधि का कोई विशेष अर्थ नहीं होता है।

मिलान दोहराव

लक्ष्य स्ट्रिंग के भीतर एक वर्ण या वर्णों का समूह एक से अधिक बार हो सकता है। एक पैटर्न इस दोहराव से मेल खा सकता है। लक्ष्य में पुनरावृत्ति का मिलान करने के लिए मेटाएक्टैक्टर, ?, *, +, और {} का उपयोग किया जाता है। यदि x लक्ष्य स्ट्रिंग में रुचि का एक चरित्र है, तो मेटाएक्टैक्टर्स के निम्नलिखित अर्थ हैं:

एक्स*:मतलब मैच'एक्स' 0या अधिक बार,मैं।और.,कितनी भी बार

एक्स+:मतलब मैच'एक्स' 1या अधिक बार,मैं।और.,कम से कम एक बार

एक्स? :मतलब मैच'एक्स' 0या1 समय

एक्स{एन,}:मतलब मैच'एक्स'कम से कम n या अधिक बार।ध्यान देंअल्पविराम।

एक्स{एन} :मिलान'एक्स'बिल्कुल n बार

एक्स{एन,एम}:मिलान'एक्स'कम से कम n बार,लेकिन मी गुना से अधिक नहीं।

इन मेटाकैरेक्टर को कहा जाता है परिमाणक

रेखांकन

*

* पिछले वर्ण या पूर्ववर्ती समूह से शून्य या अधिक बार मेल खाता है। ओ * लक्ष्य स्ट्रिंग के कुत्ते में 'ओ' से मेल खाता है। यह किताब और लुकिंग में भी oo से मेल खाता है। रेगेक्स, o* द एनिमल booooed में boooo से मेल खाता है.. नोट: o* डिग से मेल खाता है, जहां 'o' शून्य (या अधिक) समय होता है।

+

+ पिछले वर्ण या पूर्ववर्ती समूह से 1 या अधिक बार मेल खाता है। * के लिए इसकी तुलना शून्य या अधिक बार करें। तो रेगेक्स, ई + खाने में 'ई' से मेल खाता है, जहां 'ई' एक बार होता है। ई+ भेड़ में ई से भी मेल खाता है, जहां 'ई' एक से अधिक बार आता है। नोट: e+ डिग से मेल नहीं खाएगा क्योंकि डिग में 'e' कम से कम एक बार नहीं आता है।

?

NS ? पिछले वर्ण या पूर्ववर्ती समूह से मेल खाता है, 0 या 1 बार (और अधिक नहीं)। तो, ई? मैच डिग क्योंकि 'ई' डिग में होता है, जीरो टाइम। इ? मैच सेट क्योंकि 'ई' सेट में होता है, एक बार। नोट: ई? अभी भी भेड़ से मेल खाता है; हालांकि भेड़ में दो 'ई' होते हैं। यहाँ एक बारीकियाँ हैं - बाद में देखें।

{एन,}

यह पिछले वर्ण या पूर्ववर्ती समूह के कम से कम n लगातार दोहराव से मेल खाता है। तो रेगेक्स, ई {2,} लक्ष्य में दो 'ई' से मेल खाता है, भेड़, और तीन 'ई' लक्ष्य भेड़ में। e{2,} समुच्चय से मेल नहीं खाता, क्योंकि समुच्चय में केवल एक 'e' है।

{एन}

यह पिछले वर्ण या पूर्ववर्ती समूह के लगातार n दोहराव से मेल खाता है। तो रेगेक्स, ई{2} लक्ष्य में दो 'ई' से मेल खाता है, भेड़। e{2} सेट से मेल नहीं खाता क्योंकि सेट में केवल एक 'e' है। खैर, ई{2} लक्ष्य में दो 'ई' से मेल खाता है, भेड़। यहाँ एक बारीकियाँ हैं - बाद में देखें।

{एन, एम}

यह पिछले वर्ण या पूर्ववर्ती समूह के कई लगातार दोहराव से मेल खाता है, कहीं भी n से m तक, समावेशी। तो, e{1,3} डिग में कुछ भी मेल नहीं खाता, जिसमें कोई 'e' नहीं है। यह सेट में एक 'ई', भेड़ में दो 'ई', भेड़ में तीन 'ई' और भेड़ में तीन 'ई' से मेल खाता है। पिछले मैच में एक बारीकियां है - बाद में देखें।

मिलान विकल्प

कंप्यूटर में निम्नलिखित लक्ष्य स्ट्रिंग पर विचार करें।

खेत में विभिन्न आकार के सूअर हैं।

प्रोग्रामर जानना चाह सकता है कि क्या इस लक्ष्य में बकरी या खरगोश या सुअर है। कोड इस प्रकार होगा:

charपी[] = 'खेत में विभिन्न आकार के सूअर हैं।';

अगर (रेगेक्स_सर्च(पी,regex('बकरी|खरगोश|सुअर')))

लागत<< 'मिलान' <<एंडली;

अन्यथा

लागत<< 'मिलान नही हुआ' <<एंडली;

कोड एक मैच पैदा करता है। वैकल्पिक वर्ण के उपयोग पर ध्यान दें, |। दो, तीन, चार और अधिक विकल्प हो सकते हैं। सी ++ पहले लक्ष्य स्ट्रिंग में प्रत्येक वर्ण स्थिति पर पहले विकल्प, बकरी से मिलान करने का प्रयास करेगा। यदि यह बकरी के साथ सफल नहीं होता है, तो यह अगले विकल्प, खरगोश की कोशिश करता है। यदि यह खरगोश के साथ सफल नहीं होता है, तो यह अगले विकल्प, सुअर की कोशिश करता है। यदि सुअर विफल हो जाता है, तो C++ लक्ष्य में अगले स्थान पर चला जाता है और पहले विकल्प के साथ फिर से शुरू होता है।

उपरोक्त कोड में, सुअर का मिलान किया गया है।

मिलान शुरुआत या अंत

शुरुआत


यदि ^ रेगेक्स की शुरुआत में है, तो लक्ष्य स्ट्रिंग के शुरुआती टेक्स्ट का मिलान रेगेक्स द्वारा किया जा सकता है। निम्नलिखित कोड में, लक्ष्य की शुरुआत एबीसी है, जो मेल खाती है:

अगर (रेगेक्स_सर्च('एबीसी और डीईएफ़',regex('^ एबीसी')))

लागत<< 'मिलान' <<एंडली;

निम्नलिखित कोड में कोई मिलान नहीं होता है:

अगर (रेगेक्स_सर्च('हां, एबीसी और डीईएफ़',regex('^ एबीसी')))

लागत<< 'मिलान' <<एंडली;

अन्यथा

लागत<< 'मिलान नही हुआ' <<एंडली;

यहां, एबीसी लक्ष्य की शुरुआत में नहीं है।

नोट: सर्कमफ्लेक्स कैरेक्टर, '^', रेगेक्स की शुरुआत में एक मेटाकैरेक्टर है, जो लक्ष्य स्ट्रिंग की शुरुआत से मेल खाता है। यह अभी भी चरित्र वर्ग की शुरुआत में एक मेटाकैरेक्टर है, जहां यह वर्ग को नकारता है।

समाप्त

यदि $ रेगेक्स के अंत में है, तो लक्ष्य स्ट्रिंग के अंतिम पाठ का मिलान रेगेक्स द्वारा किया जा सकता है। निम्नलिखित कोड में, लक्ष्य का अंत xyz है, जो मेल खाता है:

अगर (रेगेक्स_सर्च('यूवीडब्ल्यू और xyz',regex('xyz$')))

लागत<< 'मिलान' <<एंडली;

निम्नलिखित कोड में कोई मिलान नहीं होता है:

अगर (रेगेक्स_सर्च('यूवीडब्ल्यू और एक्सवाईजेड फाइनल',regex('xyz$')))

लागत<< 'मिलान' <<एंडली;

अन्यथा

लागत<< 'मिलान नही हुआ' <<एंडली;

यहाँ, xyz लक्ष्य के अंत में नहीं है।

समूहन

कोष्ठक का उपयोग वर्णों को एक पैटर्न में समूहित करने के लिए किया जा सकता है। निम्नलिखित रेगेक्स पर विचार करें:

'एक संगीत कार्यक्रम (पियानोवादक)'

यहां का समूह पियानोवादक है जो मेटाएक्टेक्टर्स ( और ) से घिरा हुआ है। यह वास्तव में एक उप-समूह है, जबकि एक संगीत कार्यक्रम (पियानोवादक) संपूर्ण समूह है। निम्न पर विचार करें:

'द (पियानोवादक अच्छा है)'

यहाँ, उप-समूह या उप-स्ट्रिंग है, पियानोवादक अच्छा है।

सामान्य भागों के साथ उप-स्ट्रिंग

एक मुनीम वह व्यक्ति होता है जो किताबों की देखभाल करता है। एक बुककीपर और बुकशेल्फ़ के साथ एक पुस्तकालय की कल्पना करें। मान लें कि निम्न लक्ष्य स्ट्रिंग्स में से एक कंप्यूटर में हैं:

'पुस्तकालय में एक बुकशेल्फ़ है जिसकी प्रशंसा की जाती है।';

'यहाँ मुनीम है।';

'बुककीपर बुकशेल्फ़ के साथ काम करता है।';

मान लें कि प्रोग्रामर की रुचि यह जानने में नहीं है कि इनमें से कौन सा वाक्य कंप्यूटर में है। फिर भी, उसकी रुचि यह जानने में है कि कंप्यूटर में जो भी लक्ष्य स्ट्रिंग है उसमें बुकशेल्फ़ या बुककीपर मौजूद है या नहीं। इस मामले में, उसका रेगेक्स हो सकता है:

'बुकशेल्फ़|बुककीपर।'

प्रत्यावर्तन का उपयोग करना।

ध्यान दें कि किताब, जो दोनों शब्दों के लिए सामान्य है, पैटर्न में दो शब्दों में दो बार टाइप की गई है। दो बार टाइपिंग बुक से बचने के लिए, रेगेक्स को बेहतर तरीके से लिखा जाएगा:

'किताब(शेल्फ|कीपर)'

यहाँ, समूह, शेल्फ|कीपर वैकल्पिक रूपक का अभी भी उपयोग किया गया है, लेकिन दो लंबे शब्दों के लिए नहीं। इसका प्रयोग दो लंबे शब्दों के दो अंतिम भागों के लिए किया गया है। सी ++ समूह को एक इकाई के रूप में मानता है। तो, सी ++ शेल्फ या कीपर की तलाश करेगा जो किताब के तुरंत बाद आता है। निम्नलिखित कोड का आउटपुट मेल खाता है:

charपी[] = 'पुस्तकालय में एक बुकशेल्फ़ है जिसकी प्रशंसा की जाती है।';

अगर (रेगेक्स_सर्च(पी,regex('किताब(शेल्फ|कीपर)')))

लागत<< 'मिलान' <<एंडली;

बुकशेल्फ़ और बुककीपर का मिलान नहीं किया गया है।

आईकेस और मल्टीलाइन रेगेक्स_कॉन्स्टेंट्स

आई आवरण

मिलान डिफ़ॉल्ट रूप से केस संवेदी होता है। हालांकि, इसे केस असंवेदनशील बनाया जा सकता है। इसे प्राप्त करने के लिए, निम्न कोड के रूप में, रेगेक्स :: आईकेस स्थिरांक का उपयोग करें:

अगर (रेगेक्स_सर्च('प्रतिपुष्टि',regex('चारा',regex::आई आवरण)))

लागत<< 'मिलान' <<एंडली;

आउटपुट मेल खाता है। तो अपरकेस 'F' वाले फीडबैक का मिलान लोअरकेस 'f' वाले फीड से किया गया है। रेगेक्स :: आईकेस को रेगेक्स () कंस्ट्रक्टर का दूसरा तर्क बनाया गया है। इसके बिना, कथन एक मैच का निर्माण नहीं करेगा।

बहुपंक्ति

निम्नलिखित कोड पर विचार करें:

charपी[] = 'लाइन 1एनलाइन 2एनपंक्ति ३';

अगर (रेगेक्स_सर्च(पी,regex('^। * $')))

लागत<< 'मिलान' <<एंडली;

अन्यथा

लागत<< 'मिलान नही हुआ' <<एंडली;

आउटपुट मेल नहीं खाता। रेगेक्स, ^.*$, लक्ष्य स्ट्रिंग से उसके आरंभ से अंत तक मेल खाता है। .* का अर्थ , शून्य या अधिक बार को छोड़कर कोई भी वर्ण है। इसलिए, लक्ष्य में न्यूलाइन वर्णों ( ) के कारण, कोई मेल नहीं था।

लक्ष्य एक मल्टीलाइन स्ट्रिंग है। न्यूलाइन कैरेक्टर से मेल खाने के लिए '।' के लिए, निरंतर रेगेक्स :: मल्टीलाइन बनाना होगा, रेगेक्स() निर्माण का दूसरा तर्क। निम्नलिखित कोड इसे दिखाता है:

charपी[] = 'लाइन 1एनलाइन 2एनपंक्ति ३';

अगर (रेगेक्स_सर्च(पी,regex('^। * $',regex::बहु)))

लागत<< 'मिलान' <<एंडली;

अन्यथा

लागत<< 'मिलान नही हुआ' <<एंडली;

संपूर्ण लक्ष्य स्ट्रिंग का मिलान

संपूर्ण लक्ष्य स्ट्रिंग से मिलान करने के लिए, जिसमें न्यूलाइन वर्ण ( n) नहीं है, regex_match() फ़ंक्शन का उपयोग किया जा सकता है। यह फ़ंक्शन regex_search() से भिन्न है। निम्नलिखित कोड इसे दिखाता है:

charपी[] = 'पहला दूसरा तीसरा';

अगर (रेगेक्स_मैच(पी,regex('।*दूसरा।*')))

लागत<< 'मिलान' <<एंडली;

यहाँ एक मैच है। हालांकि, ध्यान दें कि रेगेक्स पूरे लक्ष्य स्ट्रिंग से मेल खाता है, और लक्ष्य स्ट्रिंग में कोई ' ' नहीं है।

मैच_परिणाम वस्तु

रेगेक्स_सर्च () फ़ंक्शन लक्ष्य और रेगेक्स ऑब्जेक्ट के बीच एक तर्क ले सकता है। यह तर्क match_results वस्तु है। पूरे मिलान (भाग) स्ट्रिंग और मिलान किए गए उप-स्ट्रिंग्स को इसके साथ जाना जा सकता है। यह ऑब्जेक्ट विधियों के साथ एक विशेष सरणी है। Match_results ऑब्जेक्ट प्रकार cmatch (स्ट्रिंग अक्षर के लिए) है।

मैच प्राप्त करना

निम्नलिखित कोड पर विचार करें:

charपी[] = 'जिस महिला को आप ढूंढ रहे थे!';

सेमीचैच एम;

अगर (रेगेक्स_सर्च(पी,एम,regex('डब्ल्यू.एम.एन')))

लागत<<एम[0] <<एंडली;

लक्ष्य स्ट्रिंग में महिला शब्द है। आउटपुट महिला है', जो रेगेक्स से मेल खाती है, w.m.n. सूचकांक शून्य पर, विशेष सरणी में एकमात्र मैच होता है, जो महिला है।

वर्ग विकल्पों के साथ, लक्ष्य में पाई जाने वाली केवल पहली उप-स्ट्रिंग को विशेष सरणी में भेजा जाता है। निम्नलिखित कोड इसे दिखाता है:

सेमीचैच एम;

अगर (रेगेक्स_सर्च('चूहा, बिल्ली, बल्ला!',एम,regex('[बीसीआर] पर')))

लागत<<एम[0] <<एंडली;

लागत<<एम[1] <<एंडली;

लागत<<एम[2] <<एंडली;

उत्पादन सूचकांक शून्य से चूहा है। एम [1] और एम [2] खाली हैं।

विकल्पों के साथ, लक्ष्य में मिली केवल पहली उप-स्ट्रिंग को विशेष सरणी में भेजा जाता है। निम्नलिखित कोड इसे दिखाता है:

अगर (रेगेक्स_सर्च('खरगोश, बकरी, सुअर!',एम,regex('बकरी|खरगोश|सुअर')))

लागत<<एम[0] <<एंडली;

लागत<<एम[1] <<एंडली;

लागत<<एम[2] <<एंडली;

सूचकांक शून्य से उत्पादन खरगोश है। एम [1] और एम [2] खाली हैं।

ग्रुपिंग

जब समूह शामिल होते हैं, तो पूरा पैटर्न मेल खाता है, विशेष सरणी के सेल शून्य में जाता है। पाया गया अगला उप-स्ट्रिंग सेल 1 में जाता है; निम्नलिखित उप-स्ट्रिंग, सेल 2 में जाती है; और इसी तरह। निम्नलिखित कोड इसे दिखाता है:

अगर (रेगेक्स_सर्च('सर्वश्रेष्ठ पुस्तक विक्रेता आज!',एम,regex('पुस्तक ((सेल) (एलईआर))')))

लागत<<एम[0] <<एंडली;

लागत<<एम[1] <<एंडली;

लागत<<एम[2] <<एंडली;

लागत<<एम[3] <<एंडली;

आउटपुट है:

किताब बेचनेवाला

विक्रेता

कक्ष

पढ़ना

ध्यान दें कि समूह (विक्रेता) समूह (सेल) से पहले आता है।

मैच की स्थिति

cmatch सरणी में प्रत्येक उप-स्ट्रिंग के लिए मिलान की स्थिति ज्ञात की जा सकती है। गिनती लक्ष्य स्ट्रिंग के पहले वर्ण से शुरू होती है, स्थिति शून्य पर। निम्नलिखित कोड इसे दिखाता है:

सेमीचैच एम;

अगर (रेगेक्स_सर्च('सर्वश्रेष्ठ पुस्तक विक्रेता आज!',एम,regex('पुस्तक ((सेल) (एलईआर))')))

लागत<<एम[0] << '->' <<एम।पद(0) <<एंडली;

लागत<<एम[1] << '->' <<एम।पद(1) <<एंडली;

लागत<<एम[2] << '->' <<एम।पद(2) <<एंडली;

लागत<<एम[3] << '->' <<एम।पद(3) <<एंडली;

एक तर्क के रूप में, सेल इंडेक्स के साथ, स्थिति संपत्ति के उपयोग पर ध्यान दें। आउटपुट है:

किताब बेचनेवाला->5

विक्रेता->9

कक्ष->9

पढ़ना->12

खोजें और बदलें

एक नया शब्द या वाक्यांश मैच की जगह ले सकता है। इसके लिए regex_replace() फ़ंक्शन का उपयोग किया जाता है। हालांकि, इस बार, स्ट्रिंग जहां प्रतिस्थापन होता है वह स्ट्रिंग ऑब्जेक्ट है, स्ट्रिंग अक्षर नहीं। तो, स्ट्रिंग लाइब्रेरी को प्रोग्राम में शामिल करना होगा। चित्रण:

#शामिल

#शामिल

#शामिल

नेमस्पेस एसटीडी का उपयोग करना;

NSमुख्य()
{
स्ट्रिंग str= 'यहाँ, मेरे आदमी आता है। वहाँ तुम्हारा आदमी जाता है।';
स्ट्रिंग newStr=रेगेक्स_रिप्लेस(पी,regex('पुरुष'), 'महिला');
लागत<<न्यूस्ट्रो<<एंडली;

वापसी 0;
}

regex_replace() फ़ंक्शन, जैसा कि यहां कोड किया गया है, सभी मैचों को बदल देता है। फ़ंक्शन का पहला तर्क लक्ष्य है, दूसरा रेगेक्स ऑब्जेक्ट है, और तीसरा प्रतिस्थापन स्ट्रिंग है। फ़ंक्शन एक नई स्ट्रिंग देता है, जो लक्ष्य है लेकिन प्रतिस्थापन है। आउटपुट है:

यहाँ मेरी औरत आती है। वहाँ तुम्हारी औरत जाती है।

निष्कर्ष

रेगुलर एक्सप्रेशन लक्ष्य अनुक्रम स्ट्रिंग में सबस्ट्रिंग से मिलान करने के लिए पैटर्न का उपयोग करता है। पैटर्न में मेटाकैरेक्टर होते हैं। सी ++ रेगुलर एक्सप्रेशन के लिए आमतौर पर इस्तेमाल किए जाने वाले फंक्शन हैं: रेगेक्स_सर्च (), रेगेक्स_मैच () और रेगेक्स_रेप्लेस ()। एक रेगेक्स डबल-कोट्स में एक पैटर्न है। हालांकि, ये फ़ंक्शन रेगेक्स ऑब्जेक्ट को तर्क के रूप में लेते हैं, न कि केवल रेगेक्स। इन कार्यों का उपयोग करने से पहले रेगेक्स को रेगेक्स ऑब्जेक्ट में बनाया जाना चाहिए।