C++
नियमित अभिव्यक्ति

परिचय

वाक्य - विन्यास

• regex_match // पूर्ण वर्ण अनुक्रम regex द्वारा मिलान किया गया था या नहीं, रिटर्न, वैकल्पिक रूप से एक मैच ऑब्जेक्ट में कैप्चर करना
• regex_search // रिटर्न अनुक्रम चरित्र के एक हिस्से को regex द्वारा मिलान किया गया था या नहीं, वैकल्पिक रूप से एक मैच ऑब्जेक्ट में कैप्चर करना
• regex_replace // इनपुट कैरेक्टर अनुक्रम को एक रीप्जेक्स द्वारा एक रिप्लेसमेंट फॉर्मेट स्ट्रिंग द्वारा संशोधित करके लौटाता है
• regex_token_iterator // पुनरावृत्तियों द्वारा परिभाषित वर्ण अनुक्रम की सूची के साथ प्रारंभ किया गया एक चरित्र अनुक्रम के साथ प्रारंभ, और एक regex। डेरेफ्रेंसिंग रेगेक्स के वर्तमान में अनुक्रमित मैच को लौटाता है। अगले कैप्चर इंडेक्स में वृद्धि बढ़ जाती है या यदि वर्तमान में अंतिम इंडेक्स पर है, तो इंडेक्स को रीसेट करता है और चरित्र अनुक्रम में रेगेक्स मैच की अगली घटना को याद दिलाता है
• regex_iterator // पुनरावृत्तियों द्वारा परिभाषित वर्ण अनुक्रम और एक regex के साथ प्रारंभ। डेरेफ्रेंसिंग चरित्र अनुक्रम के हिस्से को पूरा करता है जो वर्तमान में पूरे रेगेक्स से मेल खाता है। इंक्रीमेंटिंग चरित्र अनुक्रम में रेगेक्स मैच की अगली घटना को ढूंढता है

पैरामीटर

मूल regex_match और regex_search उदाहरण

const auto input = "Some people, when confronted with a problem, think \"I know, I'll use regular expressions.\""s;
smatch sm;

cout << input << endl;

// If input ends in a quotation that contains a word that begins with "reg" and another word begining with "ex" then capture the preceeding portion of input
if (regex_match(input, sm, regex("(.*)\".*\\breg.*\\bex.*\"\\s*$"))) {
    const auto capture = sm[1].str();
    
    cout << '\t' << capture << endl; // Outputs: "\tSome people, when confronted with a problem, think\n"
    
    // Search our capture for "a problem" or "# problems"
    if(regex_search(capture, sm, regex("(a|d+)\\s+problems?"))) {
        const auto count = sm[1] == "a"s ? 1 : stoi(sm[1]);
        
        cout << '\t' << count << (count > 1 ? " problems\n" : " problem\n"); // Outputs: "\t1 problem\n"
        cout << "Now they have " << count + 1 << " problems.\n"; // Ouputs: "Now they have 2 problems\n"
    }
}

लाइव उदाहरण

regex_replace उदाहरण

यह कोड विभिन्न ब्रेस स्टाइल में लेता है और उन्हें एक ट्रू ब्रेस स्टाइल में परिवर्तित करता है:

const auto input = "if (KnR)\n\tfoo();\nif (spaces) {\n    foo();\n}\nif (allman)\n{\n\tfoo();\n}\nif (horstmann)\n{\tfoo();\n}\nif (pico)\n{\tfoo(); }\nif (whitesmiths)\n\t{\n\tfoo();\n\t}\n"s;

cout << input << regex_replace(input, regex("(.+?)\\s*\\{?\\s*(.+?;)\\s*\\}?\\s*"), "$1 {\n\t$2\n}\n") << endl;

लाइव उदाहरण

regex_token_iterator उदाहरण

एक std::regex_token_iterator कॉमा सेपरेटेड वैल्यू फ़ाइल के तत्वों को निकालने के लिए एक जबरदस्त टूल प्रदान करता है। पुनरावृति के फायदों के अलावा, यह पुनरावृत्त भागे हुए अल्पविरामों को पकड़ने में सक्षम है जहाँ अन्य विधियाँ संघर्ष करती हैं:

const auto input = "please split,this,csv, ,line,\\,\n"s;
const regex re{ "((?:[^\\\\,]|\\\\.)+)(?:,|$)" };
const vector<string> m_vecFields{ sregex_token_iterator(cbegin(input), cend(input), re, 1), sregex_token_iterator() };

cout << input << endl;

copy(cbegin(m_vecFields), cend(m_vecFields), ostream_iterator<string>(cout, "\n"));

लाइव उदाहरण

रेगेक्स पुनरावृत्तियों के साथ एक उल्लेखनीय गोटा है, regex तर्क एक एल-मूल्य होना चाहिए। एक R- मान काम नहीं करेगा ।

regex_iterator उदाहरण

जब regex_iterator की regex_iterator को पुनरावृत्त करना regex_iterator है तो regex_iterator एक अच्छा विकल्प है। एक अपसंदर्भन regex_iterator एक रिटर्न match_result । यह सशर्त कैप्चर या कैप्चर के लिए बहुत अच्छा है जिसमें अन्योन्याश्रयता है। मान लीजिए कि हम कुछ C ++ कोड को टोकन देना चाहते हैं। दिया हुआ:

enum TOKENS {
    NUMBER,
    ADDITION,
    SUBTRACTION,
    MULTIPLICATION,
    DIVISION,
    EQUALITY,
    OPEN_PARENTHESIS,
    CLOSE_PARENTHESIS
};

हम इस स्ट्रिंग को टोकन कर सकते हैं: const auto input = "42/2 + -8\t=\n(2 + 2) * 2 * 2 -3"s इस तरह से एक regex_iterator साथ:

vector<TOKENS> tokens;
const regex re{ "\\s*(\\(?)\\s*(-?\\s*\\d+)\\s*(\\)?)\\s*(?:(\\+)|(-)|(\\*)|(/)|(=))" };

for_each(sregex_iterator(cbegin(input), cend(input), re), sregex_iterator(), [&](const auto& i) {
    if(i[1].length() > 0) {
        tokens.push_back(OPEN_PARENTHESIS);
    }
    
    tokens.push_back(i[2].str().front() == '-' ? NEGATIVE_NUMBER : NON_NEGATIVE_NUMBER);
    
    if(i[3].length() > 0) {
        tokens.push_back(CLOSE_PARENTHESIS);
    }        
    
    auto it = next(cbegin(i), 4);
    
    for(int result = ADDITION; it != cend(i); ++result, ++it) {
        if (it->length() > 0U) {
            tokens.push_back(static_cast<TOKENS>(result));
            break;
        }
    }
});

match_results<string::const_reverse_iterator> sm;

if(regex_search(crbegin(input), crend(input), sm, regex{ tokens.back() == SUBTRACTION ? "^\\s*\\d+\\s*-\\s*(-?)" : "^\\s*\\d+\\s*(-?)" })) {
    tokens.push_back(sm[1].length() == 0 ? NON_NEGATIVE_NUMBER : NEGATIVE_NUMBER);
}

लाइव उदाहरण

रेगेक्स पुनरावृत्तियों के साथ एक उल्लेखनीय गोटा यह है कि regex तर्क में एक एल-मूल्य होना चाहिए, एक आर-मूल्य काम नहीं करेगा: विज़ुअल स्टूडियो regex_iterator बग?

एक तार को विभाजित करना

std::vector<std::string> split(const std::string &str, std::string regex)
{
    std::regex r{ regex };
    std::sregex_token_iterator start{ str.begin(), str.end(), r, -1 }, end;
    return std::vector<std::string>(start, end);
}

split("Some  string\t with whitespace ", "\\s+"); // "Some", "string", "with", "whitespace"

परिमाणकों

मान लीजिए कि हमें एक फ़ोन नंबर के रूप में मान्य const string input दिया गया है। हम एक शून्य या अधिक क्वांटिफायर के साथ एक संख्यात्मक इनपुट की आवश्यकता द्वारा शुरू कर सकते हैं: regex_match(input, regex("\\d*")) या एक या एक से अधिक क्वांटिफायर : regex_match(input, regex("\\d+")) लेकिन यदि input में कोई अमान्य संख्यात्मक स्ट्रिंग है, तो दोनों वास्तव में कम हो जाते हैं जैसे: "123" चलो यह सुनिश्चित करने के लिए कि हम कम से कम 7 अंक प्राप्त कर रहे हैं, एक n या अधिक मात्रा का उपयोग करें:

regex_match(input, regex("\\d{7,}"))

यह गारंटी देगा कि हम कम से कम एक फोन नंबर प्राप्त करेंगे, लेकिन input में एक संख्यात्मक स्ट्रिंग भी हो सकती है जो बहुत लंबा है: "123456789012"। तो चलिए n और m क्वांटिफायर के बीच चलते हैं ताकि input कम से कम 7 अंकों का हो लेकिन 11 से अधिक न हो:

regex_match(input, regex("\\d{7,11}"));

यह हमें करीब आता है, लेकिन [7, 11] की श्रेणी में आने वाले अवैध संख्यात्मक तार अभी भी स्वीकार किए जाते हैं, जैसे: "123456789" तो चलिए देश को एक आलसी मात्रा के साथ वैकल्पिक बनाते हैं:

regex_match(input, regex("\\d?\\d{7,10}"))

यह ध्यान रखना महत्वपूर्ण है कि आलसी क्वांटिफायर संभव के रूप में कुछ वर्णों से मेल खाता है , इसलिए इस चरित्र से मेल खाने का एकमात्र तरीका है यदि पहले से ही 10 वर्ण हैं जो \d{7,10} से मेल खाते हैं। (पहले किरदार का लालच करने के लिए हमें करना होगा: \d{0,1} ।) आलसी क्वांटिफायर को किसी अन्य क्वांटिफायर में जोड़ा जा सकता है।

अब, हम क्षेत्र कोड को कैसे वैकल्पिक बनाएंगे और केवल एक देश कोड स्वीकार करेंगे यदि क्षेत्र कोड मौजूद था?

regex_match(input, regex("(?:\\d{3,4})?\\d{7}"))

इस अंतिम रेगेक्स में, \d{7} को 7 अंकों की आवश्यकता होती है । ये 7 अंक वैकल्पिक रूप से 3 या 4 अंकों से पहले हैं।

ध्यान दें कि हमने आलसी परिमाणक को जोड़ा नहीं था: \d{3,4}?\d{7} , \d{3,4}? 3 या 4 अक्षरों से मेल खाता होगा, पसंद करते हैं। 3. इसके बजाय हम गैर-कैप्चरिंग ग्रुप मैच को एक बार में बना रहे हैं, मैच नहीं करना पसंद करते हैं। एक बेमेल होने के कारण यदि input में क्षेत्र कोड शामिल नहीं है जैसे: "1234567"।

क्वांटिफायर विषय के निष्कर्ष में, मैं अन्य अपीलीय क्वांटिफायर का उल्लेख करना चाहूंगा जिनका आप उपयोग कर सकते हैं, जिसके पास मात्रात्मक मात्रात्मक है । या तो आलसी क्वांटिफायर या किसी भी क्वांटिफायर को पास किया जा सकता है। अपने पास रखने वाले मात्रात्मक एकमात्र फ़ंक्शन को रेगेक्स इंजन की सहायता करके यह बताना है कि लालच इन पात्रों को लेता है और यदि रेगेक्स विफल होने का कारण बनता है, तो भी उन्हें कभी न दें । उदाहरण के लिए यह बहुत मायने नहीं रखता है: regex_match(input, regex("\\d{3,4}+\\d{7})) क्योंकि ऐसा input :" 1234567890 " \d{3,4}+ रूप में मेल नहीं खाएगा \d{3,4}+ हमेशा 4 वर्णों से मेल खाएगा भले ही 3 मिलान ने रेगेक्स को सफल होने दिया हो।
जब मात्रा निर्धारित टोकन परिपक्व पात्रों की संख्या को सीमित करता है, तो सबसे अधिक मात्रात्मक मात्रा का उपयोग किया जाता है। उदाहरण के लिए:

regex_match(input, regex("(?:.*\\d{3,4}+){3}"))

मिलान करने के लिए उपयोग किया जा सकता है यदि input में निम्न में से कोई भी हो:

1 2 3 4 5 6 7 8 9 0
123-456-7890
(123)456-7890
(1 2 3 4 5 6 7 8 9 0

लेकिन जब यह रेगीक्स वास्तव में चमकता है जब input में एक अवैध इनपुट होता है:

1 2 3 4 5 6 7 8 9 0

प्रॉपर्टीज क्वांटिफायर के बिना रेगेक्स इंजन को वापस जाना पड़ता है और प्रत्येक संयोजन का परीक्षण करना पड़ता है .* और या तो 3 या 4 वर्ण यह देखने के लिए कि क्या यह मैच्योर कॉम्बिनेशन पा सकता है। प्रॉपर्टीज क्वांटिफायर के साथ रेगेक्स शुरू होता है जहां 2 ^{एन डी के} पास क्वांटिफायर छूट जाता है, '0' वर्ण, और रेगेक्स इंजन समायोजित करने की कोशिश करता है .* मिलान करने के लिए \d{3,4} को अनुमति देने के लिए; जब यह रेगेक्स बस विफल नहीं हो सकता है, तो पहले देखने के लिए कोई बैक ट्रैकिंग नहीं की जाती है .* समायोजन एक मैच की अनुमति दे सकता था।

लंगर

C ++ केवल 4 एंकर प्रदान करता है:

• ^ जो स्ट्रिंग की शुरुआत का दावा करता है
• $ जो स्ट्रिंग के अंत का दावा करता है
• \b जो a \W वर्ण या स्ट्रिंग की शुरुआत या अंत का दावा करता है
• \B जो एक \w वर्ण का दावा करता है

आइए कहते हैं, उदाहरण के लिए हम इसे के संकेत के साथ एक नंबर पर कब्जा करना चाहते हैं:

auto input = "+1--12*123/+1234"s;
smatch sm;

if(regex_search(input, sm, regex{ "(?:^|\\b\\W)([+-]?\\d+)" })) {

    do {
        cout << sm[1] << endl;
        input = sm.suffix().str();
    } while(regex_search(input, sm, regex{ "(?:^\\W|\\b\\W)([+-]?\\d+)" }));
}

लाइव उदाहरण

यहाँ एक महत्वपूर्ण बात यह है कि लंगर किसी भी पात्र का उपभोग नहीं करता है।