精华内容
参与话题
问答
  • 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
    请按任意键继续. . .




    展开全文
  • regex.h regex.cpp

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

    2020-11-23 09:36:28
    正则表达式在线测试地址: https://tool.oschina.net/regex

    正则表达式在线测试地址:

     

     

    https://tool.oschina.net/regex

    展开全文
  • 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
  • 易语言源码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
  • 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
  • <p>Note that the fancy-regex implementation doesn't compile yet, but I thought it would be useful to get this reviewed earlier rather than later. <p>I haven't ported over the regex rewriting ...
  • 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 -> 匹配后替换...
  • 正则表达式(regex)入门

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

    2020-11-17 16:00:46
    目前boost regex性能更优,使用更广泛。c++11的Regular expressions library的std::regex待改进。
  • 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
收藏数 54,819
精华内容 21,927
关键字:

regex