Boost::Regex代码示例

看一个别人给出的例子，当我们输入“select 字符串 from 字符串”的时候，会得到输出；如果不符合这个格式，就会输出error。注意：在命令行下输入的时候，按ctrl+Z、回车表示行输入结束。

1. #include 
2. #include 
3. #include 
4. #include 
5. #include 
6. using namespace std;
7. using namespace boost;
9. regex expression("select ([a-zA-Z]*) from ([a-zA-Z]*)");
11. int main(int argc, char* argv[])
12. {
13.     std::string in;
14.     cmatch what;
15.     cout << "enter test string" << endl;
16.     getline(cin,in);
17.     if(regex_match(in.c_str(), what, expression))
18.     {
19.         for(int i=0;i
20.             cout<<"str :"<
21.     }
22.     else
23.     {
24.         cout<<"Error Input"<
25.     }
26.     return 0;
27. }

regex对象与regex_match()函数

下面是一个检测两个字符串是否符合指定表达式的例子：

1. #include 
2. #include 
3. #include 
4. #include 
5. using namespace std;
6. using namespace boost;
7. int main()
8. {
9.     regex reg("\\d{3}([a-zA-Z]+).(\\d{2}|N/A)\\s\\1");
10.     string correct = "123Hello N/A Hello";
11.     string incorrect = "123Hello 12 hello";
12.     assert(regex_match(correct,reg)==true);
13.     assert(regex_match(incorrect,reg)==false);
14.     return 0;
15. }

reg的格式含义是：三个数字，1个单词，一个任意字符，2个数字或者字符串N/A，1个空格，然后再重复第一个单词。

 

下面是一个匹配邮件地址的表达式例子：

1. #include 
2. #include 
3. #include 
4. #include 
5. using namespace std;
6. using namespace boost;
7. int main()
8. {
9.     regex reg("\\w(.+)@(.+)\\.com");
10.     string correct = "[e-mail]";
11.     assert(regex_match(correct,reg)==true);
12.     return 0;
13. }

很有意思吧！

regex_search()函数的使用

1. #include  
   #include  
   #include  
   #include  
   using namespace std; 
   using namespace boost; 
   int main() 
   { 
       regex reg("(new)|(delete)"); 
    smatch m; 
       string s = "Calls to new mustbe followed by delete.  Calling simply new results in aleak!"; 
    int new_counter = 0; 
       int delete_counter = 0; 
       string::const_iterator it = s.begin(); 
   //    string::const_iterator end = s.end(); 
       while (regex_search(it,(string::const_iterator)s.end(),m,reg))  
       { 
           m[1].matched ? ++new_counter : ++delete_counter; 
           it = m[0].second; 
       } 
       if (new_counter != delete_counter) 
           cout<<"Leak detected!\n"; 
       else 
           cout<<"Seems OK...\n"; 
       return 0; 
   }

在上面的例子中，统计new和delete这两个单词的数目是不是一样。注意：smatch对象，它其实是一个match_results类型，分别用来记录reg中的索引是否被匹配。如果“new”被匹配了，那么m[1].matched就会为真(true)；m[0].second表示it向后移动了，继续匹配剩下的字符串。

m[0]，返回的是对匹配整个正则表达式的子匹配的引用，因此可以确定这个匹配的结束点通常是下次运行regex_search函数的起始点。

regex_replace()函数的使用

顾名思义，它可以用于执行文本替换。它在输入数据中进行搜索，查找正则表达式的所有匹配，对于每个匹配，该算法调用match_results::format，并将结果输出到一个传递给该函数的输出迭代器(output iterator)中。

下面的例子将英式拼法的colour替换为美式拼法的color。如果不使用正则表达式来进行这个拼写的修改，将会非常单调乏味，而且容易出错。问题在于单词中可能存在不同的大小写，而且单词可能还有很多的变形——例如colourize。为了正确地解决这个问题，需要把正则表达式分为3个子表达式：

1. regex reg("(Colo)(u)(r)",boost::regex::icase|boost::regex::perl);

 

为了在任何匹配中能够很容易地删除字母u，我们对它进行了隔离。后面的是regex构造函数的标志参数，表示这个正则表达式不区分大小写；设置格式标志过程中的一个常见错误是忽略了regex需要默认启用的那些标志，如果没有设置这些标志，那么它们就不会启用，因此通常情况下必须使用应用应该设置的所有标志。

在使用regex_replace替换时，我们需要以参数的方式提供一个格式化字符串，该字符串决定如何进行替换。如果我们希望保留第一个和第三个匹配的子表达式，那么可以使用$N（N为子表达式的索引）来实现。下面是解决问题的完整代码：

1. #include  
2. #include  
3. #include  
4. #include  
5. using namespace std; 
6. using namespace boost; 
7. int main() 
8. {
9.     regex reg("(Colo)(u)(r)",regex::icase | regex::perl);
10.     string s = "Colour, colours,color,colourize";
11.     s = regex_replace(s,reg,"$1$3");
12. //  s = regex_replace(s,reg,"$1 wocao $3");//尝试在输出字符串中加空格   cout<
13.     return 0; 
14. }

关于重复和贪婪

 

1. #include  
2. #include  
3. #include  
4. #include  
5. using namespace std; 
6. using namespace boost; 
7. int main() 
8. {
9.     regex reg("(.*)(\\d{2})");
10.     cmatch m;
11.     const char * text = "Note that I'm 31 years old, not 32.";
12.     if (regex_search(text,m,reg))
13.     {
14.         if (m[1].matched)
15.         {
16.             cout<'\n';
17.         }
18.         if (m[2].matched)
19.         {
20.             cout<'\n';
21.         }
22.     }
23. }

上面代码的输出结果是：

Note that I'm 31, not

32

也就是说，正则表达式中的".*"选项贪婪地吞掉了所有的输入！从而致使后面的子表达式无法获得匹配。按照我们的想法：31应该是符合\d{2}的条件的，应该被输出！但是可惜，它被*吞掉了。在正则表达式中，+和*都是重复性贪婪的。

为了非贪婪的重复，怎么办呢？可以在重复记号后面加一个问号"?"，重复就会变成非贪婪的。修改上面代码的表达式：

1. regex reg("(.*?)(\\d{2})");

再运行程序，结果就变成：

Note that I'm

31

明白了吧？

regex_iterator的介绍和使用

 

1. #include   
2. #include   
3. #include   
4. #include   
5. using namespace std; 
6. using namespace boost; 
7. class regex_callback
8. {
9.     int sum_;
10. public:
11.     regex_callback():sum_(0){}
12.     template<typename T> void operator()(const T& what)
13.     {
14.         sum_+=atoi(what[1].str().c_str());
15.     }
16.     int sum() const
17.     {
18.         return sum_;
19.     }
20. };
21. int main() 
22. {
23.     regex reg("(\\d+),?");
24.     string s = "1,1,2,3,5,8,13,21";
25.     sregex_iterator it(s.begin(),s.end(),reg);
26.     sregex_iterator end;
28.     regex_callback c;
29.     int sum = for_each(it,end,c).sum();
30. }

sregex_iterator是regex_iterator的typedef，现在的使用方法更加清晰了。我们可以对比一下前面使用regex_search的时候，不得不在循环中手动地让起始迭代器前进，而且还要手动调用regex_search函数。

regex_token_iterator的介绍和使用

它和regex_iterator相似，但是它列举的是与正则表达式不匹配的字符序列，该特性对于字符串分割非常有用。当解引用regex_token_iterator时，只有被“预订”的子表达式才可以返回。下面这个例子：输入数据的条目之间用“/”分隔，要获得两个斜杠之间的数据；使用regex_token_iterator来分隔处理就特别简单，因为它的表达式简单：regex reg("/")；为了使用这个正则表达式来分割输入，需要将一个特殊的索引-1传递给regex_token_iteraotr的构造函数。

 

1. #include 
2. #include 
3. #include 
4. using namespace std;
5. using namespace boost;
7. int main()
8. {
9.     regex reg("/");
10.     string s = "Split/Values/Separated/By/Slashes,";
11.     vector vec;
12.     sregex_token_iterator it(s.begin(),s.end(),reg,-1);
13.     sregex_token_iterator end;
14.     while (it!=end)
15.         vec.push_back(*it++);
16.     assert(vec.size()==count(s.begin(),s.end(),'/')+1);
17.     assert(vec[0]=="Split");
18.     
19.     return 0;
20. }

regex_token_iterator是一个模板类，sregex_token_iterator是迭代器类型，是regex_token_iterator的typedef。在上面的程序中，每次解引用返回的都是当前的sub_match，当迭代器前进时，它会尝试再次匹配该正则表达式。

 

换一个不同类型的输入，也应该能够写出程序来！

 

 

1. #include 
2. #include 
3. #include 
4. #include 
5. using namespace std;
6. using namespace boost;
8. int main()
9. {
10.     regex reg(" ");
11.     char* s="123 456 789 12345";
12. //  cregex_token_iterator it;   //This is correct, too.
13.     regex_token_iterator<char*> it(s,s+strlen(s),reg,-1);
14.     regex_token_iterator<char*> end;
15.     while (it!=end)
16.     {
17.         cout<<*it++<
18.     }
19.     return 0;
20. }

当需要反复调用regex_search时，考虑使用这两个iterator，比较方便。

\A和\Z的使用

如果把\A放在正则表达式的开始，把\Z放在正则表达式的最后，那么regex_search函数的行为就可以与regex_match函数的相同——也就是说，regex_search函数必须匹配所有的输入后才能匹配成功。

下面的表达式通常要求所有的输入都能获得匹配，而不管使用regex_match还是regex_search：

1. regex reg("");

对比regex_search和regex_match的使用：

 

1. regex reg("\\d*");
2. bool b=regex_match("17 is prime",reg);
3. //返回失败
5. regex reg("\\d*");
6. bool b=regex_search("17 is prime",reg);
7. //返回true
9. regex reg("\\d*");
10. bool b=regex_search("17 is prime",reg);
11. //仍然返回失败

元字符(^)的使用

元字符用来表示取反。regex reg("[^13579]");它表示一个取反的字符类，可以匹配任意非奇数的字符。

 

1. #include 
2. #include 
3. #include 
4. using namespace std;
5. using namespace boost;
7. int main()
8. {
9.     regex reg("[^13579]");
10.     string s="0123456789";
11.     sregex_iterator it(s.begin(),s.end(),reg);
12.     sregex_iterator end;
13.     while (it!=end)
14.         cout<<*it++;
15.     return 0;
16. }

上面程序的输出结果为“02468”，如果输入字符串是“abcd”，也会全部匹配（因为它们不是奇数）。

另外，元字符^还可以用来表示一行的开始，元字符$则表示一行的结束。

无效正则表达式与异常抛出

下面这个程序还可以当作正则表达式格式输入的练习：）

 

1. #include 
2. #include 
3. #include 
4. #include 
5. using namespace std;
6. using namespace boost;
8. int main()
9. {
10.     cout<<"Enter a regular expression:\n";
11.     string s;
12.     getline(cin,s);
13.     try
14.     {
15.         regex reg(s);
16.         cout<<"Now enter a string to be matched:\n";
17.         getline(cin,s);
18.         if (regex_match(s,reg))
19.             cout<<"That's right!\n";
20.         else
21.             cout<<"No, that doesn't match!";
22.     }
23.     catch (bad_expression & e)
24.     {
25.         cout<<"That's not a valid expression! Error: "<
26.     }
27.     return 0;
28. }

输入\d{5}，输入：12345，输出：That's right!（奇怪，为什么这里输入\d而不是呢？输入没有抛出异常，却不能正确匹配！如果我输入，而这又是一个合法的正则表达式，那么它的匹配字符串是怎样的？）

输入错误的正则表达式：(\w*))，程序会抛出异常。

 

参考文献：超越c++标准库 Boos