c_cpp CPP - 教程019 - C ++正则表达式

Posted 2021-05-14

// ----- BEGINNING REGEX -----

void PrintMatches(std::string str,
        std::regex reg){
    
    // Used when your searching a string
    std::smatch matches;
    
    // Show true and false in output
    std::cout << std::boolalpha;
       
    // Determines if there is a match and match 
    // results are returned in matches
    while(std::regex_search(str, matches, reg)){
        std::cout << "Checked for Results : " << 
                matches.ready() << "\n";
        
        std::cout << "Are there no matches : " << 
                matches.empty() << "\n";
        
        std::cout << "Number of matches : " << 
                matches.size() << "\n";
        
        // Get the first match
        std::cout << matches.str(1) << "\n";
        
        // Eliminate the previous match and create
        // a new string to search
        str = matches.suffix().str();
        
        std::cout << "\n";
    }
}

// ----- END BEGINNING REGEX -----

// ----- ITERATOR REGEX -----

void PrintMatches2(std::string str,
        std::regex reg){
    
    // This holds the first match
    std::sregex_iterator currentMatch(str.begin(),
            str.end(), reg);
    
    // Used to determine if there are any more matches
    std::sregex_iterator lastMatch;
    
    // While the current match doesn't equal the last
    while(currentMatch != lastMatch){
        std::smatch match = *currentMatch;
        std::cout << match.str() << "\n";
        currentMatch++;
    }
    std::cout << std::endl;
    
}

// ----- END ITERATOR REGEX -----

int main()
{
    // ----- BEGINNING REGEX -----
    
    std::string str = "The ape was at the apex";
      
    // Create the pattern to search for which is
    // the letters ape followed maybe by anything
    // that is not a space
    std::regex reg ("(ape[^ ]?)");
    
    PrintMatches(str,reg);
    
    // ----- END BEGINNING REGEX -----
    
    // ----- ITERATOR REGEX -----
    
    // Using an iterator with all matches
    
    std::string str2 = "I picked the pickle";
    
    // Match (+) 1 or more of anything not a space
    std::regex reg2 ("(pick([^ ]+)?)");
    
    PrintMatches2(str2,reg2);
    
    // ----- END ITERATOR REGEX -----
    
    // ----- MATCH 1 OF SEVERAL LETTERS -----
    
    std::string str3 = "Cat rat mat fat pat";
    
    // Match any character in [] plus what follows
    std::regex reg3 ("([crmfp]at)");
    
    PrintMatches2(str3,reg3);
    
    // We can also match characters in a range
    std::regex reg4("[C-Fc-f]at");
    PrintMatches2(str3,reg4);
    
    // Use ^ to denote any character except for
    // those in brackets
    std::regex reg5("[^Cr]at");
    PrintMatches2(str3,reg5);
    
    // ----- END MATCH 1 OF SEVERAL LETTERS -----
    
    // ----- REPLACE MATCHES -----
    
    std::string str6 = "Cat rat mat fat pat";
    std::regex reg6("[Cr]at");
    
    // Replace matches with Owl in the output
    std::string owlFood = std::regex_replace(str6,reg6,"Owl");
    std::cout << owlFood << "\n";
    
    // ----- END REPLACE MATCHES -----
    
    // ----- MATCHING ANY CHARACTER -----
    
    // . matches any character, but if we want to
    // search for a . we escape it with \
    
    std::string str7 = "F.B.I. I.R.S. CIA";
    std::regex reg7("([^ ]\..\..\.)");
    PrintMatches2(str7,reg7);
    
    
    // ----- END MATCHING ANY CHARACTER -----
    
    // ----- MATCHING WHITESPACE -----
    
    // We can match any whitespace character
    std::string str8 = "This is a\n multiline string\n"
            "that has many lines";
    std::regex reg8("\n");
    std::string noLBStr = std::regex_replace(str8,reg8," ");
    std::cout << noLBStr << "\n";
    
    // You can also replace
    // \b : Backspace
    // \f : Form Feed
    // \r : Carriage Return
    // \t : Tab
    // \v : Vertical Tab
    
    // ----- END MATCHING WHITESPACE -----
    
    // ----- MATCHING SINGLE NUMBERS -----
    
    // \d can be used instead of [0-9]
    // \D is the same as [^0-9]
    std::string str9 = "12345";
    std::regex reg9("\\d");
    PrintMatches2(str9, reg9);
    
    // You can also match within a range
    std::string str10 = "123 12345 123456 1234567";
    
    // Match values that are between 5 and 7 digits
    std::regex reg10("\\d{5,7}");
    PrintMatches2(str10, reg10);
    
    // ----- END MATCHING SINGLE NUMBERS -----
    
    // ----- MATCHING ANY SINGLE LETTER OR NUMBER -----
    
    // \w is the same as [a-zA-Z0-9_]
    // \W is the same as [^a-zA-Z0-9_]
    std::string str11 = "412-555-1212";
    
    // Check if it is a phone number
    std::regex reg11("\\w{3}-\\w{3}-\\w{4}");
    PrintMatches2(str11, reg11);
    
    // ----- END MATCHING ANY SINGLE LETTER OR NUMBER -----
    
    // ----- MATCHING WHITESPACE -----
    
    // \s is the same as [\f\n\r\t\v]
    // \S is the same as [^\f\n\r\t\v]
    
    std::string str12 = "Toshio Muramatsu";
    
    // Check if its a valid name
    std::regex reg12("\\w{2,20}\\s\\w{2,20}");
    PrintMatches2(str12, reg12);
    
    // ----- END MATCHING WHITESPACE -----
    
    // ----- MATCHING ONE OR MORE -----
    
    // Match a followed by 1 or more characters
    std::string str13 = "a as ape bug";
    
    std::regex reg13("a[a-z]+");
    PrintMatches2(str13, reg13);
    
    // ----- END MATCHING ONE OR MORE -----
    
    // ----- PROBLEM -----
    // Create a Regex that matches email addresses 
    // from a list
    // 1. 1 to 20 lowercase and uppercase letters, 
    // numbers, plus ._%+-
    // 2. An @ symbol
    // 3. 2 to 20 lowercase and uppercase letters, 
    // numbers, plus .-
    // 4. A period
    // 5. 2 to 3 lowercase and uppercase letters
    
    std::string str14 = "[e-mail] m@.com @apple.com db@.com";
    
    std::regex reg14("[\\w._%+-]{1,20}@[\\w.-]{2,20}.[A-Za-z]{2,3}");
    PrintMatches2(str14, reg14);
    
    
    // ----- END PROBLEM -----
    
    return 0;
}