精华内容
下载资源
问答
  • Regex

    2016-05-04 09:54:00
    #include "boost/regex.hpp" //完全匹配 void boostregex_match(void); //部分数据可以匹配 void boostregex_search(void); //替换 void boostregex_replace(void); //关于重复和贪婪 void Test1(void)
    #include <iostream>
    #include <cassert>
    #include <string>
    #include "boost/regex.hpp"
    
    //完全匹配
    void boostregex_match(void);
    
    //部分数据可以匹配
    void boostregex_search(void);
    
    //替换
    void boostregex_replace(void);
    
    //关于重复和贪婪
    void Test1(void);
    
    //regex_iterator
    void Test2(void);
    
    //regex_token_iterator 
    void Test3(void);
    
    int main() 
    { 
    	//boostregex_search();
    	//boostregex_replace();
    	//Test1();
    	//Test2();
    	Test3();
    	return 0;
    }
    
    void boostregex_match(void)
    {
    	// 3 digits, a word, any character, 2 digits or "N/A",   // a space, then the first word again 
    	//用于表示"3个数字, 一个单词, 任意字符, 2个数字或字符串"N/A," 一个空格, 然后重复第一个单词.":
    	boost::regex reg("\\d{3}([a-zA-Z]+).(\\d{2}|N/A)\\s\\1");
    	std::string correct = "123Hello N/A Hello";
    	std::string incorrect = "123Hello 12 hello";
    	assert(boost::regex_match(correct, reg) == true);
    	assert(boost::regex_match(incorrect, reg) == false);
    	return;
    }
    
    //部分数据可以匹配
    void boostregex_search(void)
    {
    	// "new" and "delete" 出现的次数是否一样? 
    	boost::regex reg("(new)|(delete)"); 
    	boost::smatch m;  
    	std::string s=    "Calls to new must be followed by delete. \     Calling simply new results in a leak!";  
    	int new_counter=0; 
    	int delete_counter=0; 
    	std::string::const_iterator it=s.begin();  
    	std::string::const_iterator end=s.end();  
    	while (boost::regex_search(it,end,m,reg)) 
    	{    // 是 new 还是 delete?  
    		m[1].matched ? ++new_counter : ++delete_counter; 
    		it=m[0].second; 
    	} 
    	if (new_counter!=delete_counter) 
    		std::cout << "Leak detected!\n";  
    	else    
    		std::cout << "Seems ok...\n";
    	return;
    	/*
    	Leak detected!
    请按任意键继续. . .
    	*/
    }
    
    //替换
    void boostregex_replace(void)
    {
    	boost::regex reg("(Colo)(u)(r)", 
    	boost::regex::icase | boost::regex::perl);  
    	std::string s = "Colour, colours, color, colourize";  
    	s = boost::regex_replace(s, reg, "$1$3");  
    	std::cout << s;
    	return;
    	/*
    	Color, colors, color, colorize请按任意键继续. . .
    	*/
    }
    
    //关于重复和贪婪
    void Test1(void)
    {
    	boost::regex reg("(.*)(\\d{2})");  
    	boost::cmatch m;  
    	const char* text = "Note that I'm 31 years old, not 32.";  
    	if (boost::regex_search(text, m, reg)) {
    		if (m[1].matched)      
    			std::cout << "(.*) matched: " << m[1].str() << '\n';   
    		if (m[2].matched)      
    			std::cout << "Found the age: " << m[2] << '\n'; }
    	return;
    	/*
    	(.*) matched: Note that I'm 31 years old, not
    Found the age: 32
    请按任意键继续. . .
    	*/
    }
    
    
    class regex_callback 
    { 
    	int sum_; 
    public: 
    	regex_callback() : sum_(0) {}  
    	template <typename T> void operator()(const T& what) 
    	{
    		sum_ += atoi(what[1].str().c_str()); 
    	}  
    	int sum() const { return sum_; }
    
    };
    
    //regex_iterator
    void Test2(void)
    {
    	boost::regex reg("(\\d+),?");  
    	std::string s = "1,1,2,3,5,8,13,21";  
    	boost::sregex_iterator it(s.begin(), s.end(), reg);  
    	boost::sregex_iterator end;  regex_callback c;  
    	int sum = for_each(it, end, c).sum();
    	return;
    }
    
    //regex_token_iterator 
    void Test3(void)
    {
    	boost::regex reg("/");  
    	std::string s = "Split/Values/Separated/By/Slashes,"; 
    	std::vector<std::string> vec;  
    	boost::sregex_token_iterator it(s.begin(), s.end(), reg, -1);  
    	boost::sregex_token_iterator end;  
    	while (it != end)    
    		vec.push_back(*it++); 
    
    	assert(vec.size() == std::count(s.begin(), s.end(), '/') + 1);  
    	assert(vec[0] == "Split");
    	return;
    }

    展开全文
  • regex

    2016-02-07 00:40:18
    The regex match and search interface //main.cpp #include #include using namespace std; void out(bool b) { cout (b ? "found" : "not found") ; } int main() { // find XML/HTML-tagged

    The regex match and search interface


    //main.cpp
    #include <regex>
    #include <iostream>
    using namespace std;
    
    void out(bool b)
    {
    	cout << (b ? "found" : "not found") << endl;
    }
    
    int main()
    {
    	// find XML/HTML-tagged value (using default syntax):
    	regex reg1("<.*>.*</.*>");
    	bool found = regex_match("<tag>value</tag>",   // data
    		reg1);                // regular expression
    	out(found);
    
    	// find XML/HTML-tagged value (tags before and after the value must match):
    	regex reg2("<(.*)>.*</\\1>");
    	found = regex_match("<tag>value</tag>",        // data
    		reg2);                     // regular expression
    	out(found);
    
    	// find XML/HTML-tagged value (using grep syntax):
    	regex reg3("<\\(.*\\)>.*</\\1>", regex_constants::grep);
    	found = regex_match("<tag>value</tag>",        // data
    		reg3);                     // regular expression
    	out(found);
    
    	// use C-string as regular expression (needs explicit cast to regex):
    	found = regex_match("<tag>value</tag>",        // data
    		regex("<(.*)>.*</\\1>"));  // regular expression
    	out(found);
    	cout << endl;
    
    	// regex_match() versus regex_search():
    	found = regex_match("XML tag: <tag>value</tag>",
    		regex("<(.*)>.*</\\1>"));         // fails to match
    	out(found);
    	found = regex_match("XML tag: <tag>value</tag>",
    		regex(".*<(.*)>.*</\\1>.*"));     // matches
    	out(found);
    	found = regex_search("XML tag: <tag>value</tag>",
    		regex("<(.*)>.*</\\1>"));        // matches
    	out(found);
    	found = regex_search("XML tag: <tag>value</tag>",
    		regex(".*<(.*)>.*</\\1>.*"));    // matches
    	out(found);
    }



    dealing with subexpressions

    #include <string>
    #include <regex>
    #include <iostream>
    #include <iomanip>
    using namespace std;
    
    int main()
    {
    	string data = "XML tag: <tag-name>the value</tag-name>.";
    	cout << "data:             " << data << "\n\n";
    
    	smatch m;  // for returned details of the match
    	bool found = regex_search(data,
    		m,
    		regex("<(.*)>(.*)</(\\1)>"));
    
    	// print match details:
    	cout << "m.empty():        " << boolalpha << m.empty() << endl;
    	cout << "m.size():         " << m.size() << endl;
    	if (found) {
    		cout << "m.str():          " << m.str() << endl;
    		cout << "m.length():       " << m.length() << endl;
    		cout << "m.position():     " << m.position() << endl;
    		cout << "m.prefix().str(): " << m.prefix().str() << endl;
    		cout << "m.suffix().str(): " << m.suffix().str() << endl;
    		cout << endl;
    
    		// iterating over all matches (using the match index):
    		for (int i = 0; i<m.size(); ++i) {
    			cout << "m[" << i << "].str():       " << m[i].str() << endl;
    			cout << "m.str(" << i << "):         " << m.str(i) << endl;
    			cout << "m.position(" << i << "):    " << m.position(i)
    				<< endl;
    		}
    		cout << endl;
    
    		// iterating over all matches (using iterators):
    		cout << "matches:" << endl;
    		for (auto pos = m.begin(); pos != m.end(); ++pos) {
    			cout << " " << *pos << " ";
    			cout << "(length: " << pos->length() << ")" << endl;
    		}
    	}
    }
    

    data:             XML tag: <tag-name>the value</tag-name>


    m.empty():        false
    m.size():         4
    m.str():          <tag-name>the value</tag-name>
    m.length():       30
    m.position():     9
    m.prefix().str(): XML tag:
    m.suffix().str(): .


    m[0].str():       <tag-name>the value</tag-name>
    m.str(0):         <tag-name>the value</tag-name>
    m.position(0):    9
    m[1].str():       tag-name
    m.str(1):         tag-name
    m.position(1):    10
    m[2].str():       the value
    m.str(2):         the value
    m.position(2):    19
    m[3].str():       tag-name
    m.str(3):         tag-name
    m.position(3):    30


    matches:
     <tag-name>the value</tag-name> (length: 30)
     tag-name (length: 8)
     the value (length: 9)
     tag-name (length: 8)
    请按任意键继续. . .


    find all matches of a regular expression

    #include <string>
    #include <regex>
    #include <iostream>
    using namespace std;
    
    int main()
    {
    	string data = "<person>\n"
    		" <first>Nico</first>\n"
    		" <last>Josuttis</last>\n"
    		"</person>\n";
    
    	regex reg("<(.*)>(.*)</(\\1)>");
    
    	// iterate over all matches
    	auto pos = data.cbegin();
    	auto end = data.cend();
    	smatch m;
    	for (; regex_search(pos, end, m, reg); pos = m.suffix().first) {
    		cout << "match:  " << m.str() << endl;
    		cout << " tag:   " << m.str(1) << endl;
    		cout << " value: " << m.str(2) << endl;
    	}
    }
    

    match:  <first>Nico</first>
     tag:   first
     value: Nico
    match:  <last>Josuttis</last>
     tag:   last
     value: Josuttis
    请按任意键继续. . .


    Regex iterators


    #include <string>
    #include <regex>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
    	string data = "<person>\n"
    		" <first>Nico</first>\n"
    		" <last>Josuttis</last>\n"
    		"</person>\n";
    
    	regex reg("<(.*)>(.*)</(\\1)>");
    
    	// iterate over all matches (using a regex_iterator):
    	sregex_iterator pos(data.cbegin(), data.cend(), reg);
    	sregex_iterator end;
    	for (; pos != end; ++pos) {
    		cout << "match:  " << pos->str() << endl;
    		cout << " tag:   " << pos->str(1) << endl;
    		cout << " value: " << pos->str(2) << endl;
    	}
    
    	// use a regex_iterator to process each matched substring as element in an algorithm:
    	sregex_iterator beg(data.cbegin(), data.cend(), reg);
    	for_each(beg, end, [](const smatch& m) {
    		cout << "match:  " << m.str() << endl;
    		cout << " tag:   " << m.str(1) << endl;
    		cout << " value: " << m.str(2) << endl;
    	});
    }
    

    match:  <first>Nico</first>
     tag:   first
     value: Nico
    match:  <last>Josuttis</last>
     tag:   last
     value: Josuttis
    match:  <first>Nico</first>
     tag:   first
     value: Nico
    match:  <last>Josuttis</last>
     tag:   last
     value: Josuttis
    请按任意键继续. . .


    regex Token iterators


    #include <string>
    #include <regex>
    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    int main()
    {
    	string data = "<person>\n"
    		" <first>Nico</first>\n"
    		" <last>Josuttis</last>\n"
    		"</person>\n";
    
    	regex reg("<(.*)>(.*)</(\\1)>");
    
    	// iterate over all matches (using a regex_token_iterator):
    	sregex_token_iterator pos(data.cbegin(), data.cend(), // sequence
    		reg,                       // token separator
    		{ 0,2 });      // 0: full match, 2: second substring
    	sregex_token_iterator end;
    	for (; pos != end; ++pos) {
    		cout << "match:  " << pos->str() << endl;
    	}
    	cout << endl;
    
    	string names = "nico, jim, helmut, paul, tim, john paul, rita";
    	regex sep("[ \t\n]*[,;.][ \t\n]*");  // separated by , ; or . and spaces
    	sregex_token_iterator p(names.cbegin(), names.cend(),  // sequence
    		sep,                          // separator
    		-1);        // -1: values between separators
    	sregex_token_iterator e;
    	for (; p != e; ++p) {
    		cout << "name:  " << *p << endl;
    	}
    }
    

    match:  <first>Nico</first>
    match:  Nico
    match:  <last>Josuttis</last>
    match:  Josuttis


    name:  nico
    name:  jim
    name:  helmut
    name:  paul
    name:  tim
    name:  john paul
    name:  rita
    请按任意键继续. . .


    replacing regular expressions

    #include <string>
    #include <regex>
    #include <iostream>
    #include <iterator>
    using namespace std;
    int main()
    {
    	string data = "<person>\n"
    		" <first>Nico</first>\n"
    		" <last>Josuttis</last>\n"
    		"</person>\n";
    	regex reg("<(.*)>(.*)</(\\1)>");
    	// print data with replacement for matched patterns
    	cout << regex_replace(data, // data
    		reg, // regular expression
    		"<$1 value=\"$2\"/>") // replacement
    		<< endl;
    	// same using sed syntax
    	cout << regex_replace(data, // data
    		reg, // regular expression
    		"<\\1 value=\"\\2\"/>", // replacement
    		regex_constants::format_sed) // format flag
    		<< endl;
    	// use iterator interface, and
    	// - format_no_copy: don’t copy characters that don’t match
    	// - format_first_only: replace only the first match found
    	string res2;
    	regex_replace(back_inserter(res2), // destination
    		data.begin(), data.end(), // source range
    		reg, // regular expression
    		"<$1 value=\"$2\"/>", // replacement
    		regex_constants::format_no_copy // format flags
    		| regex_constants::format_first_only);
    	cout << res2 << endl;
    }

    <person>
     <first value="Nico"/>
     <last value="Josuttis"/>
    </person>


    <person>
     <first value="Nico"/>
     <last value="Josuttis"/>
    </person>


    <first value="Nico"/>
    请按任意键继续. . .


    Regex Flags

    #include <string>
    #include <regex>
    #include <iostream>
    using namespace std;
    
    int main()
    {
    	// case-insensitive find LaTeX index entries
    	string pat1 = R"(\\.*index\{([^}]*)\})";       // first capture group
    	string pat2 = R"(\\.*index\{(.*)\}\{(.*)\})";  // 2nd and 3rd capture group
    	regex pat(pat1 + "\n" + pat2,
    		regex_constants::egrep | regex_constants::icase);
    	//Using the egrep grammar, we can put a newline character between these two regular expressions.
    
    	// initialize string with characters from standard input:
    	string data((istreambuf_iterator<char>(cin)),
    		istreambuf_iterator<char>());
    
    	// search and print matching index entries:
    	smatch m;
    	auto pos = data.cbegin();
    	auto end = data.cend();
    	for (; regex_search(pos, end, m, pat); pos = m.suffix().first) {
    		cout << "match: " << m.str() << endl;
    		cout << "  val: " << m.str(1) + m.str(2) << endl;
    		cout << "  see: " << m.str(3) << endl;
    	}
    }
    


    \chapter{The Standard Template Library}
    \index{STL}%
    \MAININDEX{standard template library}%
    \SEEINDEX{standard template library}{STL}%
    This is the basic chapter about the STL.
    \section{STL Components}
    \hauptindex{STL, introduction}%
    The \stl{} is based on the cooperation of
    ^Z
    match: \index{STL}
      val: STL
      see:
    match: \MAININDEX{standard template library}
      val: standard template library
      see:
    match: \SEEINDEX{standard template library}{STL}
      val: standard template library
      see: STL
    match: \hauptindex{STL, introduction}
      val: STL, introduction
      see:
    请按任意键继续. . .


    Regex exceptions

    //regexexception.hpp
    #include <regex>
    #include <string>
    
    template <typename T>
    std::string regexCode(T code)
    {
    	switch (code) {
    	case std::regex_constants::error_collate:
    		return "error_collate: "
    			"regex has invalid collating element name";
    	case std::regex_constants::error_ctype:
    		return "error_ctype: "
    			"regex has invalid character class name";
    	case std::regex_constants::error_escape:
    		return "error_escape: "
    			"regex has invalid escaped char. or trailing escape";
    	case std::regex_constants::error_backref:
    		return "error_backref: "
    			"regex has invalid back reference";
    	case std::regex_constants::error_brack:
    		return "error_brack: "
    			"regex has mismatched '[' and ']'";
    	case std::regex_constants::error_paren:
    		return "error_paren: "
    			"regex has mismatched '(' and ')'";
    	case std::regex_constants::error_brace:
    		return "error_brace: "
    			"regex has mismatched '{' and '}'";
    	case std::regex_constants::error_badbrace:
    		return "error_badbrace: "
    			"regex has invalid range in {} expression";
    	case std::regex_constants::error_range:
    		return "error_range: "
    			"regex has invalid character range, such as '[b-a]'";
    	case std::regex_constants::error_space:
    		return "error_space: "
    			"insufficient memory to convert regex into finite state";
    	case std::regex_constants::error_badrepeat:
    		return "error_badrepeat: "
    			"one of *?+{ not preceded by valid regex";
    	case std::regex_constants::error_complexity:
    		return "error_complexity: "
    			"complexity of match against regex over pre-set level";
    	case std::regex_constants::error_stack:
    		return "error_stack: "
    			"insufficient memory to determine regex match";
    	}
    	return "unknown/non-standard regex error code";
    }
    

    //Source.cpp
    #include <regex>
    #include <iostream>
    #include "regexexception.hpp"
    using namespace std;
    
    int main()
    {
    	try {
    		// initialize regular expression with invalid syntax:
    		regex pat("\\\\.*index\\{([^}]*)\\}",
    			regex_constants::grep | regex_constants::icase);
    		//...
    	}
    	catch (const regex_error& e) {
    		cerr << "regex_error: \n"
    			<< " what(): " << e.what() << "\n"
    			<< " code(): " << regexCode(e.code()) << endl;
    	}
    }
    

    regex_error:
     what(): regex_error(error_badbrace): The expression contained an invalid range
    in a { expression }.
     code(): error_badbrace: regex has invalid range in {} expression
    请按任意键继续. . .




    展开全文
  • regexregex:基于regex的正则表达式工具包
  • regex.h regex.cpp

    2018-01-19 18:25:12
    linux下的C语言正则表达式头文件和源文件: regex.h regex.cpp
  • regex c语言

    2019-08-20 02:07:35
    最近一直在补习c语言的底子功夫,关于正则表达式的c教程,看...REGEX(3) Linux Programmer's Manual REGEX(3) NAME regcomp, regexec, regerror, regfree - POSIX regex functions SYNOPSIS #include <sys/typ...

    最近一直在补习c语言的底子功夫,关于正则表达式的c教程,看了man手册感觉还不错。

    REGEX(3) Linux Programmer's Manual REGEX(3)

    NAME
    regcomp, regexec, regerror, regfree - POSIX regex functions

    SYNOPSIS
    #include <sys/types.h>
    #include <regex.h>

    int regcomp(regex_t *preg, const char *regex, int cflags);

    int regexec(const regex_t *preg, const char *string, size_t nmatch,
    regmatch_t pmatch[], int eflags);

    size_t regerror(int errcode, const regex_t *preg, char *errbuf,
    size_t errbuf_size);

    void regfree(regex_t *preg);

     

    如果还不够

    另外

    https://www.jianshu.com/p/9cda6b29a12b

    http://blog.chinaunix.net/uid-20448327-id-3189854.html

    也可以看看,我就是不明白为啥子“\\b”就不行了,估计是有个bug,不过我用[0-9]代替了,无伤大雅

    转载于:https://www.cnblogs.com/Hocker/p/8407481.html

    展开全文
  • C++regex

    千次阅读 2017-11-10 08:28:33
    匹配字符串的基本规则 1. 匹配固定的字符串 ...regex e("abc", regex_constants::icase); 3. 匹配固定字符串之外多一个字符,不区分大小写 regex e("abc.", regex_constants::icase); // . Any

    匹配字符串的基本规则

    1. 匹配固定的字符串

    regex e("abc");

    2. 匹配固定字符串,不区分大小写

    regex e("abc", regex_constants::icase);

    3. 匹配固定字符串之外多一个字符,不区分大小写

    regex e("abc.", regex_constants::icase);		// .  Any character except newline. 1个字符

    4. 匹配0个或1个字符

    regex e("abc?");				// ?		Zero or 1 preceding character. 匹配?前一个字符

    5. 匹配0个或多个字符

    regex e("abc*");				// *		Zero or more preceding character. 匹配*前一个字符

    6. 匹配1个或多个字符

    regex e("abc+");				// +		One or more preceding character. 匹配+前一个字符

    7. 匹配特定字符串中的字符

    regex e("ab[cd]*");				// [...]	Any character inside square brackets. 匹配[]内的任意字符

    8. 匹配非特定字符串的字符

    regex e("ab[^cd]*");				// [...]	Any character not inside square brackets. 匹配非[]内的任意字符

    9. 匹配特定字符串,且指定数量

    regex e("ab[cd]{3}");				// {n}		匹配{}之前任意字符,且字符个数为3个

    10. 匹配特定字符串,指定数量范围

    regex e("ab[cd]{3,}");				// {n}		匹配{}之前任意字符,且字符个数为3个或3个以上
    regex e("ab[cd]{3,5}");			// {n}		匹配{}之前任意字符,且字符个数为3个以上,5个以下闭区间

    11. 匹配规则中的某一个规则

    regex e("abc|de[fg]");				// |		匹配|两边的任意一个规则
    12. 匹配分组
    regex e("(abc)de+");				// ()       ()表示一个子分组

    13. 匹配子分组

    regex e("(abc)de+\\1");			// ()       ()表示一个子分组,而\1表示在此位置匹配第一个分组的内容
    regex e("(abc)c(de+)\\2\\1");			// \2		表示的是在此匹配第二个分组的内容

    14. 匹配某个字符串开头

    regex e("^abc.");				// ^	begin of the string		查找以abc开头的子字符串

    15. 匹配某个字符串结尾

    regex e("abc.$");				// $	end of the string		查找以abc结尾的子字符串

          以上是最基本的匹配模式的书写。通常如果要匹配特定的字符,需要使用\进行转义,比如在匹配字符串中需要匹配".",那么在匹配字符串中应该在特定字符前加上\。出了以上的基本规则,如果还不满足特定的需要,那么可以参考此链接。使用了解基本的匹配模式后,需要使用正则表达式进行匹配、查找或者替代。

    正则匹配、查找与替代

          书写好模式字符串后,需要将待匹配的字符串和模式字符串进行一定规则的匹配。包括三种方式:匹配(regex_match)、查找(regex_search)、替换(regex_replace)。

          匹配很简单,直接将待匹配字符串和模式字符串传入到regex_match中,返回一个bool量来指明待匹配的字符串是否满足模式字符串的规则。匹配整个str字符串。

    bool match = regex_match(str, e);		// 匹配整个字符串str

          查找是在整个字符串中找到和满足模式字符串的子字符串。也就是只要str中存在满足模式字符串就会返回true。

    bool match = regex_search(str, e);		// 查找字符串str中匹配e规则的子字符串

          但是很多情况下,光是返回一个是否匹配的bool量是不够的,我们需要拿到匹配的子字符串。那么就需要在模式字符串中将匹配字符串分组,参考【匹配字符串的基本规则】第12点。再将smatch传入到regex_search中,就可以获得满足每个子分组的字符串。

    复制代码
    smatch m;
    bool found = regex_search(str, m, e);

    for (int n = 0; n < m.size(); ++n)
        {
            cout << "m[" << n << "].str()=" << m[n].str() << endl;
        }

    复制代码

          替换也是基于模式字符串在分组情况下完成的。

    cout << regex_replace(str, e, "$1 is on $2");

          此时,会在满足分组1和分组2的字符串中间加上“ is on”。

          以上三个函数有很多版本的重载,可以满足不同情况下的需求。

    实战

          要求:找出满足sectionA("sectionB")或者sectionA ("sectionB")的模式字符串。且分离出sectionA、sectionB。sectionA和sectionB不会出现数字,字符可大小写,至少有一个字符。

          分析:根据要求,大致可分为两个部分,也就是sectionA和sectionaB。这是就需要用到分组。

    第一步:写出满足section情况的模式字符串

    [a-zA-Z]+

    第二步:在sectionA和sectionB中可能会出现空格。暂且假设至多有1个空格

    \\s?
    将以上两个情况组合起来,也就是能满足我们需求的模式字符串。但是如何组织才能让其分为两组呢?
    [a-zA-Z]+\\s[a-zA-Z]+

    上面这种写法肯定不对的,根据分组规则,需要将分组以()进行区分

    regex e("([a-zA-Z]+)\\s?\\(\"([a-zA-Z]+)\"\\)");

          此时,在\\s?后面的\\(\"是为了满足sectionB外层的引号和括号进行的转义。

          以上完成后,可先用regex_match进行匹配,如果匹配,那么继续使用regex_search对字符串进行查找

    复制代码
    if (regex_match(str, e))
    {
    	smatch m;
    	auto found = regex_search(str, m, e);
    	for (int n = 0; n < m.size(); ++n)
    	{
    		cout << "m[" << n << "].str()=" << m[n].str() << endl;
    	}
    }
    else
    {
    	cout << "Not matched" << endl;
    }
    复制代码


    表达式 匹配
    /^\s*$/ 匹配空行。
    /\d{2}-\d{5}/ 验证由两位数字、一个连字符再加 5 位数字组成的 ID 号。
    /<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*\/\1\s*>/ 匹配 HTML 标记。

    下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为:

    字符 说明
    \ 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,“n”匹配字符“n”。“\n”匹配换行符。序列“\\”匹配“\”,“\(”匹配“(”。
    ^ 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与“\n”或“\r”之后的位置匹配。
    $ 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$ 还会与“\n”或“\r”之前的位置匹配。
    * 零次或多次匹配前面的字符或子表达式。例如,zo* 匹配“z”和“zoo”。* 等效于 {0,}。
    + 一次或多次匹配前面的字符或子表达式。例如,“zo+”与“zo”和“zoo”匹配,但与“z”不匹配。+ 等效于 {1,}。
    ? 零次或一次匹配前面的字符或子表达式。例如,“do(es)?”匹配“do”或“does”中的“do”。? 等效于 {0,1}。
    {n} 是非负整数。正好匹配 n 次。例如,“o{2}”与“Bob”中的“o”不匹配,但与“food”中的两个“o”匹配。
    {n,} 是非负整数。至少匹配 次。例如,“o{2,}”不匹配“Bob”中的“o”,而匹配“foooood”中的所有 o。“o{1,}”等效于“o+”。“o{0,}”等效于“o*”。
    {n,m} M 和 n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。例如,“o{1,3}”匹配“fooooood”中的头三个 o。'o{0,1}' 等效于 ‘o?'。注意:您不能将空格插入逗号和数字之间。
    ? 当此字符紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是“非贪心的”。“非贪心的”模式匹配搜索到的、尽可能短的字符串,而默认的“贪心的”模式匹配搜索到的、尽可能长的字符串。例如,在字符串“oooo”中,“o+?”只匹配单个“o”,而“o+”匹配所有“o”。
    . 匹配除“\n”之外的任何单个字符。若要匹配包括“\n”在内的任意字符,请使用诸如“[\s\S]”之类的模式。
    (pattern) 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果“匹配”集合中检索捕获的匹配。若要匹配括号字符 ( ),请使用“\(”或者“\)”。
    (?:pattern) 匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用“or”字符 (|) 组合模式部件的情况很有用。例如,'industr(?:y|ies) 是比 ‘industry|industries' 更经济的表达式。
    (?=pattern) 执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?=95|98|NT|2000)' 匹配“Windows 2000”中的“Windows”,但不匹配“Windows 3.1”中的“Windows”。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。
    (?!pattern) 执行反向预测先行搜索的子表达式,该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?!95|98|NT|2000)' 匹配“Windows 3.1”中的 “Windows”,但不匹配“Windows 2000”中的“Windows”。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。
    x|y 匹配 x 或 y。例如,'z|food' 匹配“z”或“food”。'(z|f)ood' 匹配“zood”或“food”。
    [xyz] 字符集。匹配包含的任一字符。例如,“[abc]”匹配“plain”中的“a”。
    [^xyz] 反向字符集。匹配未包含的任何字符。例如,“[^abc]”匹配“plain”中的“p”。
    [a-z] 字符范围。匹配指定范围内的任何字符。例如,“[a-z]”匹配“a”到“z”范围内的任何小写字母。
    [^a-z] 反向范围字符。匹配不在指定的范围内的任何字符。例如,“[^a-z]”匹配任何不在“a”到“z”范围内的任何字符。
    \b 匹配一个字边界,即字与空格间的位置。例如,“er\b”匹配“never”中的“er”,但不匹配“verb”中的“er”。
    \B 非字边界匹配。“er\B”匹配“verb”中的“er”,但不匹配“never”中的“er”。
    \cx 匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样,则假定 c 就是“c”字符本身。
    \d 数字字符匹配。等效于 [0-9]。
    \D 非数字字符匹配。等效于 [^0-9]。
    \f 换页符匹配。等效于 \x0c 和 \cL。
    \n 换行符匹配。等效于 \x0a 和 \cJ。
    \r 匹配一个回车符。等效于 \x0d 和 \cM。
    \s 匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
    \S 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
    \t 制表符匹配。与 \x09 和 \cI 等效。
    \v 垂直制表符匹配。与 \x0b 和 \cK 等效。
    \w 匹配任何字类字符,包括下划线。与“[A-Za-z0-9_]”等效。
    \W 与任何非单词字符匹配。与“[^A-Za-z0-9_]”等效。
    \xn 匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如,“\x41”匹配“A”。“\x041”与“\x04”&“1”等效。允许在正则表达式中使用 ASCII 代码。
    \num 匹配 num,此处的 num 是一个正整数。到捕获匹配的反向引用。例如,“(.)\1”匹配两个连续的相同字符。
    \n 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么 n 是反向引用。否则,如果 n 是八进制数 (0-7),那么 n 是八进制转义码。
    \nm 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式,那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获,则 n 是反向引用,后面跟有字符m。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 和 m 是八进制数字 (0-7)。
    \nml 当 n 是八进制数 (0-3),m 和 l 是八进制数 (0-7) 时,匹配八进制转义码 nml
    \un 匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9 匹配版权符号 (©)。

    用户名

    /^[a-z0-9_-]{3,16}$/

    密码

    /^[a-z0-9_-]{6,18}$/

    十六进制值

    /^#?([a-f0-9]{6}|[a-f0-9]{3})$/

    电子邮箱

    /^([wd_.-]+)@([wd_-]+.)+w{2,4}$/

    /^([a-z0-9_.-]+)@([da-z.-]+).([a-z.]{2,6})$/

    /^[a-zd]+(.[a-zd]+)*@([da-z](-[da-z])?)+(.{1,2}[a-z]+)+$/

    URL

    /^(https?://)?([da-z.-]+).([a-z.]{2,6})([/w .-]*)*/?$/

    /^(https?://)?([wd_-]+.)+w{2,4}(/[wd.?-_%=&]+)*$/

    IP 地址

    /((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)/

    /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/

    HTML 标签

    /^<([a-z]+)([^<]+)*(?:>(.*)</1>|s+/>)$/


    展开全文
  • 易语言源码RegEx.rar

    2020-03-30 01:35:17
    易语言源码RegEx.rar 易语言源码RegEx.rar 易语言源码RegEx.rar 易语言源码RegEx.rar 易语言源码RegEx.rar 易语言源码RegEx.rar
  • 易语言模块RegEx.rar

    2020-03-29 11:50:47
    易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar 易语言模块RegEx.rar
  • 前言 1 转义字符 2 regex_match 2.1 基本概念 2.2 匹配结果 2.3 实例 3 regex_search 3.1 基本概念 3.2 实例 4 regex_replace 4.1 基本概念 4.2 扩展 ... regex_match("123", regex(...
  • boost regex

    2019-04-10 12:15:08
    Boost.Regex库在linux上的编译安装,使用 1. 什么是Boost.Regex? Boost是C++中仅次于STL的一套库,它的功能比STL更加全面。这里是Boost的主页,想了解Boost的朋友可以看一下:...
  • Regex正则

    2018-02-26 17:40:26
    Regex正则第三方库1、Python的regex模块——更强大的正则表达式引擎
  • Training: Regex (Training, Regex) 题目描述 Your objective in this challenge is to learn the regex syntax. Regular Expressions are a powerful tool in your way to master programming, so you should be ...
  • Regex操作

    2017-07-06 13:29:12
    string str = Regex.Match(body, "期間.*?(年齢|スキル|単価|期間|場所)").Value;  StringBuilder sb = new StringBuilder();  Regex regex = new Regex("[ぁ-んァ-ヶ亜-熙0-9〇-九a-zA-Z\r\n]");  
  • C++ regex

    2017-08-13 16:43:45
    C++ regex正则表达式的规则和其他语言差不多,如下:特殊字符(用于匹配很难形容的字符) characters description matches \d digit a decimal digit character 注意: 在C++中反斜杠(\)会转义std::regex e1("\...
  • 易语言模块RegEx1.rar

    2020-03-29 11:51:39
    易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar 易语言模块RegEx1.rar
  • 1、regex_search:在整个字符串中匹配到符合正则表达式规则中的一部分就返回true,也就是子串。 2、regex_match:在整个字符串中匹配到符合整个表达式的整个字符串时返回true,也就是匹配的是整个字符串。 3...
  • 使用Regex类需要引用命名空间:using System.Text.RegularExpressions;利用Regex类实现验证示例1:注释的代码所起的作用是相同的,不过一个是静态方法,一个是实例方法var source = "刘备关羽张飞孙权";//Regex ...
  • regex 正则软件

    2011-10-08 08:26:23
    regex 正则软件regex 正则软件regex 正则软件regex 正则软件regex 正则软件 让你很好的上手测试正则表达式
  • c++11 regex

    2019-10-26 11:08:23
    c++ regex 库,通过 #include <regex>来使用,是c++11标准引入的功能。 regex 库提供三个最基本的正则表达式函数 regex_match -> 完全匹配 regex_search -> 局部匹配 regex_replace -> 匹配后替换...
  • std::regex v.s. boost regex

    2020-11-17 16:00:46
    目前boost regex性能更优,使用更广泛。c++11的Regular expressions library的std::regex待改进。
  • 正则表达式(regex)入门

    万次阅读 多人点赞 2018-04-04 10:23:46
    正则表达式,又称正规表示法、常规表示法(英语:Regular Expression,在代码中常简写为regex、regexp或RE),它是计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。...
  • java regex

    2014-06-19 20:36:51
    [code="java"] import java.util.regex.Matcher; import java.util.regex.Pattern; ... public static boolean regex(String regex, String str) { Pattern p = Pattern.comp...
  • C#正则表达式Regex类的使用C#中为正则表达式的使用提供了非常强大的功能,这就是Regex类。这个包包含于System.Text.RegularExpressions命名空间下面,而这个命名空间所在DLL基本上在所有的项目模板中都不需要单独去...
  • C++11: regex #1

    2015-12-18 18:46:44
    regex
  • regex_iterator

    2019-02-24 14:20:00
    应该改为regex_iterator或则regex_token_iterator,一般情况下需要位一个特定的容器来指定一个尾迭代器,但是在std::regex_iterator 里边直接调用构造函数就会生成一个尾迭代器;例如: std::regex_iterator end; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,827
精华内容 22,730
关键字:

regex