正则表达式有语言区分吗？比如java语言的正则表达式和C++的正则表达式是否是一样的？_百度知道
正则表达式有语言区分吗？比如java语言的正则表达式和C++的正则表达式是否是一样的？
例子：[a-z]表示a到z的26个字母中的一个在任何语言中都是这个意思吗？
我有更好的答案
在基础规则上可能有所扩展，这时就有所不同一般语言中的正则都是PERL兼容的(PCRE)，即不是元音的小写字母，这种语法只在JAVA中有效果,是PCRE正则的子集象[a-z]这种最基础的正则几乎在所有语言中都是表示字母a-z但是 [[a-z]&&[^aeiou]] 在JAVA中表示[a-z]和[^aeiou]的交集基本的规则是一样
采纳率：82%
来自团队：
为您推荐：
其他类似问题
正则表达式的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。51CTO旗下网站
C++ 11 中正则表达式使用示例及源码分析
正则表达式Regex(regular expression)是一种强大的描述字符序列的工具。在许多语言中都存在着正则表达式，C++11中也将正则表达式纳入了新标准的一部分，不仅如此， 它还支持了6种不同的正则表达式的语法，分别是：ECMASCRIPT、basic、extended、awk、grep和egrep。
作者：来源：| 09:15
正则表达式Regex(regular
expression)是一种强大的描述字符序列的工具。在许多语言中都存在着正则表达式，C++11中也将正则表达式纳入了新标准的一部分，不仅如此， 它还支持了6种不同的正则表达式的语法，分别是：ECMASCRIPT、basic、extended、awk、grep和egrep。其中 ECMASCRIPT是默认的语法，具体使用哪种语法我们可以在构造正则表达式的时候指定。
注：ECMAScript是一种由Ecma国际（前身为欧洲计算机制造商协会,英文名称是European
Computer Manufacturers
Association）通过ECMA-262标准化的脚本程序设计语言。它往往被称为JavaScript，但实际上后者是ECMA-262标准的实现 和扩展。
下面我们就以本篇博客的页面（http://www.cnblogs.com/ittinybird/p/4853532.html）源码为例，从 零开始演示如何在C++中使用正则表达式提取一个网页源码中所有可用的http链接。如果有时间的话，近期我想用C++11的新特性，改写一下以前的 C++爬虫程序，分享出来。
确保你的编译器支持Regex
如果你的编译器是GCC-4.9.0或者VS2013以下版本，请升级后，再使用。我之前使用的C++编译器，是GCC 4.8.3，有regex头文件，但是GCC很不厚道的没有实现，语法完全支持，但是库还没跟上，所以编译的时候是没有问题的，但是一运行就会直接抛出异常，非常完美的一个坑有木有！具体错误如下：
terminate called after throwing an instance of 'std::regex_error'
& what():& regex_error
Aborted (core dumped)
如果你也遇到了这个问题，请不要先怀疑自己，GCC这一点是非常坑爹的！！！我在这个上面浪费了半天的时间才找了出来。所以在尝鲜C++的正则表达式之前，请升级你的编译器，确保你的编译器支持它。
regex库概览
在头文件&regex&中包含了多个我们使用正则表达式时需要用到的组件，大致有：
basic_regex
正则表达式对象,是一个通用的模板，有typedef&basic_regex&char& regex 和 typedef basic_regex&char_t&wregex；
regex_match
将一个字符序列和正则表达式匹配
regex_search
寻找字符序列中的子串中与正则表达式匹配的结果,在找到第一个匹配的结果后就会停止查找
regex_replace
使用格式化的替换文本，替换正则表达式匹配到字符序列的地方
regex_iterator
迭代器，用来匹配所有 的子串
match_results
容器类，保存正则表达式匹配的结果。
容器类，保存子正则表达式匹配的字符序列.
ECMASCRIPT正则表达式语法
正则表达式式的语法基本大同小异，在这里就浪费篇幅细抠了。ECMASCRIPT正则表达式的语法知识可以参考。
构造正则表达式
构造正则表达式用到一个类：basic_regex。basic_regex是一个正则表达式的通用类模板，对char和wchar_t类型都有对应的特化：
typedef basic_regex&char&&&&
typedef basic_regex&wchar_t&
构造函数比较多，但是非常简单：
//默认构造函数，将匹配任何的字符序列
basic_regex();
//用一个以&\0&结束的字符串s构造一个正则表达式
explicit basic_regex( const CharT* s,flag_type f =std::regex_constants::ECMAScript );
//同上，但是制定了用于构造的字符串s的长度为count
basic_regex( const CharT* s, std::size_t count,flag_type f = std::regex_constants::ECMAScript );
//拷贝构造，不赘述
basic_regex( const basic_regex& other );
&//移动构造函数
basic_regex( basic_regex&& other );
//以basic_string类型的str构造正则表达式
template& class ST, class SA &
explicit basic_regex( const std::basic_string&CharT,ST,SA&& str, flag_type f = std::regex_constants::ECMAScript );
//指定范围[first,last)内的字符串构造正则表达式
template& class ForwardIt &
basic_regex( ForwardIt first, ForwardIt last, flag_type f = std::regex_constants::ECMAScript );
//使用initializer_list构造
basic_regex( std::initializer_list&CharT& init, flag_type f = std::regex_constants::ECMAScript );
以上除默认构造之外的构造函数，都有一个flag_type类型的参数用于指定正则表达式的语法，ECMASCRIPT、basic、 extended、awk、grep和egrep均是可选的值。除此之外还有其他几种可能的的标志，用于改变正则表达式匹配时的规则和行为：
在匹配过程中忽略大小写
不保存匹配的子表达式
执行速度优于构造速度
有了构造函数之后，现在我们就可以先构造出一个提取http链接的正则表达式：
std::string pattern(&http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?&);&&& //匹配规则很简单，如果有疑惑，可以对照语法查看
std::regex r(pattern);
值得一提的是在C++中&\'这个字符需要转义，因此所有ECMASCRIPT正则表达式语法中的&\'都需要写成&\\&的形式。我测试的时候，这段regex如果没有加转义，在gcc中会给出警告提示，vs2013编译后后运行直接崩溃了。
正确地处理输入
先扯一个题外话，假设我们不是使用了网络库自动在程序中下载的网页，在我们手动下载了网页并保存到文件后，首先我们要做的还是先把网页的内容(html源码)存入一个std::string中，我们可能会使用这样的错误方式：
int main()
&&&&std::string tmp,
&&&&while(std::cin && tmp)
&&&&&&&&html +=
这样一来源代码中所有的空白字符就无意中被我们全处理了，这显然不合适。这里我们还是使用getline()这个函数来处理：
int main()
&&&&std::string tmp,
&&&&while(getline(std::cin,tmp))
&&&&&&&&html +=
&&&&&&&&html += '\n';
这样一来原来的文本才能得到正确的输入。当然个人以为这些小细节还是值得注意的，到时候出错debug的时候，我想我们更多地怀疑的是自己的正则表达式是否是有效。
regex_search()只查找到第一个匹配的子序列
根据函数的字面语义，我们可能会错误的选择regex_search()这个函数来进行匹配。其函数原型也有6个重载的，用法也是大同小异，函数返回值是bool值，成功返回true，失败返回false。鉴于篇幅，我们只看我们下面要使用的这个：
template& class STraits, class SAlloc,class Alloc, class CharT, class Traits &
bool regex_search( const std::basic_string&CharT,STraits,SAlloc&& s,
&&&&&&&&&&&&&&&&&&&std::match_results&typename std::basic_string&CharT,STraits,SAlloc&::const_iterator, Alloc&& m,
&&&&&&&&&&&&&&&&&&&const std::basic_regex&CharT, Traits&& e,
&&&&&&&&&&&&&&&&&&&std::regex_constants::match_flag_type flags = std::regex_constants::match_default );
第一个参数s是std::basic_string类型的，它是我们待匹配的字符序列，参数m是一个match_results的容器用于存放匹配 到的结果，参数e则是用来存放我们之前构造的正则表达式对象。flags参数值得一提，它的类型是 std::regex_constants::match_flag_type，语义上匹配标志的意思。正如在构造正则表达式对象时我们可以指定选项如何 处理正则表达式一样，在匹配的过程中我们依然可以指定另外的标志来控制匹配的规则。这些标志的具体含义，我从&引用过来，用的时候查一下就可以了：
Explanation
match_not_bol
The first character in&[first,last)&will be treated as if it is&not&at the beginning of a line (i.e.&^&will not match&[first,first)
match_not_eol
The last character in&[first,last)&will be treated as if it is&not&at the end of a line (i.e.&$&will not match[last,last)
match_not_bow
&\b&&will not match&[first,first)
match_not_eow
&\b&&will not match&[last,last)
If more than one match is possible, then any match is an acceptable result
match_not_null
Do not match empty sequences
match_continuous
Only match a sub-sequence that begins at&first
match_prev_avail
--first&is a valid iterator position. When set, causes&match_not_bol&and&match_not_bow&to be ignored
format_default
Use ECMAScript rules to construct strings in&&()
format_sed
Use POSIX&sed&utility rules in&. ()
format_no_copy
Do not copy un-matched strings to the output in&
根据参数类型，于是我们构造了这样的调用：
std::&br&regex_search(html,results,r);
不过，标准库规定regex_search()在查找到第一个匹配的子串后，就会停止查找！在本程序中，results参数只带回了第一个满足条件的http链接。这显然并不能满足我们要提取网页中所有HTTP链接需要。
使用regex_iterator匹配所有子串
严格意义上regex_iterator是一种迭代器适配器，它用来绑定要匹配的字符序列和regex对象。regex_iterator的默认构造函数比较特殊，就直接构造了一个尾后迭代器。另外一个构造函数原型：
regex_iterator(BidirIt a, BidirIt b,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& //分别是待匹配字符序列的首迭代器和尾后迭代器
&&&&&&&&&&&&&&&const regex_type& re,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& //regex对象
&&&&&&&&&&&&&&&std::regex_constants::match_flag_type m = std::regex_constants::match_default); //标志，同上面的regex_search()中的
和上边的regex_search()一样，regex_iterator的构造函数中也有 std::regex_constants::match_flag_type类型的参数，用法一样。其实regex_iterator的内部实现就是调 用了regex_search()，这个参数是用来传递给regex_search()的。用gif或许可以演示的比较形象一点，具体是这样工作的（颜色 加深部分，表示可以匹配的子序列）：
首先在构造regex_iterator的时候，构造函数中首先就调用一次regex_search()将迭代器it指向了第一个匹配的子序列。以 后的每一次迭代的过程中（++it），都会在以后剩下的子序列中继续调用regex_search()，直到迭代器走到最后。it就一直&指向&了匹配的 子序列。
知道了原理，我们写起来代码就轻松多了。结合前面的部分我们，这个程序就基本写好了：
#include &iostream&
#include &regex&
#include &string&
int main()
&&&&std::string tmp,
&&&&while(getline(std::cin,tmp))
&&&&&&&&tmp += '\n';
&&&&&&&&html +=
&&&&std::string pattern(&http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?&);
&&&&pattern = &[[:alpha:]]*& + pattern + &[[:alpha:]]*&;
&&&&std::regex r(pattern);
&&&&for (std::sregex_iterator it(html.begin(), html.end(), r),&&&& //end是尾后迭代器，regex_iterator是regex_iterator的string类型的版本
&&&&&&&&it !=
&&&&&&&&++it)
&&&&&&&&std::cout && it-&str() && std::
下载本页的html源码保存为test.html，编译这个源码测试一下，大功告成：
[regex]g++ regex.cpp& -std=c++11 -omain
[regex]main & test.html
http://www.cnblogs.com/ittinybird/rss
http://www.cnblogs.com/ittinybird/rsd.xml
http://www.cnblogs.com/ittinybird/wlwmanifest.xml
http://common.cnblogs.com/script/jquery.js
http://files.cnblogs.com/files/ittinybird/mystyle.css
http://www.cnblogs.com/ittinybird/
http://www.cnblogs.com/ittinybird/
http://www.cnblogs.com/ittinybird/
http://i.cnblogs.com/EditPosts.aspx?opt=1
http://msg.cnblogs.com/send/%E6%88%91%E6%98%AF%E4%B8%80%E5%8F%AAC%2B%2B%E5%B0%8F%E5%B0%8F%E9%B8%9F
http://www.cnblogs.com/ittinybird/rss
http://www.cnblogs.com/ittinybird/rss
http://www.cnblogs.com/images/xml.gif
http://i.cnblogs.com/
http://www.cnblogs.com/ittinybird/p/4853532.html
http://www.cnblogs.com/ittinybird/p/4853532.html
http://www.w3school.com.cn/jsref/jsref_obj_regexp.asp
http://www.cnblogs.com/ittinybird/
http://i.cnblogs.com/EditPosts.aspx?postid=4853532
http://www.cnblogs.com/
http://q.cnblogs.com/
http://news.cnblogs.com/
http://home.cnblogs.com/ing/
http://job.cnblogs.com/
http://kb.cnblogs.com/
regex和异常处理
如果我们的正则表达式存在错误，则在运行的时候标准库会抛出一个regex_error异常，他有一个名为code的成员，用于标记错误的类型，具体错误值和语义如下表所示：
error_collate
无效的元素校对
error_ctype
无效的字符类
error_escape
无效的转移字符或者无效的尾置转义
error_backref
无效的向后引用
error_brack
方括号不匹配
error_paren
小括号不匹配
error_brace
大括号不匹配
error_badbrace
大括号中的范围无效
error_range
无效的（不合法）字符范围
error_space
error_badrepeat
重复字符之前没有正则表达式（* + ?）
error_complexity
太复杂了，标准库君hold不住了
error_stack
栈空间不足了
有关异常处理的基本内容，不是本篇要讨论的内容，就不赘述了。
C++11标准库中的正则表达式部分还有部分内容本文没有涉及，个人以为掌握了以上的内容后，基本上看一看就知道怎么使用了，这里就不浪费篇幅了。
谢谢你的阅读，错误之处还请您指正，我将万分感谢。
【编辑推荐】
【责任编辑： TEL：（010）】
大家都在看猜你喜欢
关注热点热点头条关注
24H热文一周话题本月最赞
讲师：95676人学习过
讲师：41371人学习过
讲师：149350人学习过
精选博文论坛热帖下载排行
以Linux为代表的自由软件及其稳定性，逐渐在全世界崭露头角且备受重视。由于可以支持多种网络环境，因此在采用Linux系统之前，必须熟悉各种...
订阅51CTO邮刊C++正则表达式整理备忘_深圳达内龙岗校区_深圳C++培训机构
C++正则表达式整理备忘_深圳达内龙岗校区
发布：深圳C++培训班
来源：达内新闻
&&&&&&&&&&&& C#正则表达式整理备忘
有一段时间，正则表达式学习很火热很潮流，当时在CSDN一天就能看到好几个正则表达式的帖子，那段时间借助论坛以及Wrox Press出版的《C#字符串和正则表达式参考手册》学习了一些基础的知识，同时也为我在CSDN大概赚了1000分，今天想起来，去找《C#字符串和正则表达式参考手册》时，已经不知所踪了。现在用到正则的时候也比较少，把以前的笔记等整理一下，以志不忘。
(1)“@”符号
符下两ows表研究室的火热，当晨在“@”虽然并非C#正则表达式的“成员”，但是它经常与C#正则表达式出双入对。“@”表示，跟在它后面的字符串是个“逐字字符串”，不是很好理解，举个例子，以下两个声明是等效的：
string x="D://My Huang//My Doc";
string y = @"D:/My Huang/My Doc";
事实上，如果按如下声明，C#将会报错，因为“/”在C#中用于实现转义，如“/n”换行：
string x = "D:/My Huang/My Doc";
(2)基本的语法字符。
/d 0-9的数字
/D /d的补集(以所以字符为全集，下同)，即所有非数字的字符/w 单词字符，指大小写字母、0-9的数字、下划线
/W /w的补集
/s 空白字符，包括换行符/n、回车符/r、制表符/t、垂直制表符/v、换页符/f/S /s的补集
. 除换行符/n外的任意字符
[…] 匹配[]内所列出的所有字符
[^…] 匹配非[]内所列出的字符
下面提供一些简单的示例：
[c-sharp] view plaincopy
string i = "/n";
string m = "3";
Regex r = new Regex(@"/D");
//同Regex r = new Regex("//D");
//r.IsMatch(i)结果：true
//r.IsMatch(m)结果：false
string i = "%";
string m = "3";
Regex r = new Regex("[a-z0-9]");
//匹配小写字母或数字字符
//r.IsMatch(i)结果：false
//r.IsMatch(m)结果：true
(3)定位字符
“定位字符”所代表的是一个虚的字符，它代表一个位置，你也可以直观地认为“定位字符”所代表的是某个字符与字符间的那个微小间隙。
^ 表示其后的字符必须位于字符串的开始处
$ 表示其前面的字符必须位于字符串的结束处
/b 匹配一个单词的边界
/B 匹配一个非单词的边界
另外，还包括：/A 前面的字符必须位于字符处的开始处，/z 前面的字符必须位于字符串的结束处，/Z 前面的字符必须位于字符串的结束处，或者位于换行符前下面提供一些简单的示例：
[c-sharp] view plaincopy
string i = "Live for nothing,die for something";Regex r1 = new Regex("^Live for nothing,die for something$");//r1.IsMatch(i) true
Regex r2 = new Regex("^Live for nothing,die for some$");//r2.IsMatch(i) false
Regex r3 = new Regex("^Live for nothing,die for some");//r3.IsMatch(i) true
string i = @"Live for nothing,
die for something";//多行
Regex r1 = new Regex("^Live for nothing,die for something$");Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0Regex r2 = new Regex("^Live for nothing,die for something$", RegexOptions.Multiline);
Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//0Regex r3 = new Regex("^Live for nothing,/r/ndie for something$");Console.WriteLine("r3 match count:" + r3.Matches(i).Count);//1Regex r4 = new Regex("^Live for nothing,$");
Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//0Regex r5 = new Regex("^Live for nothing,$", RegexOptions.Multiline);Console.WriteLine("r5 match count:" + r5.Matches(i).Count);//0Regex r6 = new Regex("^Live for nothing,/r/n$");Console.WriteLine("r6 match count:" + r6.Matches(i).Count);//0Regex r7 = new Regex("^Live for nothing,/r/n$", RegexOptions.Multiline);
Console.WriteLine("r7 match count:" + r7.Matches(i).Count);//0Regex r8 = new Regex("^Live for nothing,/r$");Console.WriteLine("r8 match count:" + r8.Matches(i).Count);//0Regex r9 = new Regex("^Live for nothing,/r$", RegexOptions.Multiline);Console.WriteLine("r9 match count:" + r9.Matches(i).Count);//1Regex r10 = new Regex("^die for something$");Console.WriteLine("r10 match count:" + r10.Matches(i).Count);//0Regex r11 = new Regex("^die for something$", RegexOptions.Multiline);Console.WriteLine("r11 match count:" + r11.Matches(i).Count);//1Regex r12 = new Regex("^");
Console.WriteLine("r12 match count:" + r12.Matches(i).Count);//1Regex r13 = new Regex("$");
Console.WriteLine("r13 match count:" + r13.Matches(i).Count);//1Regex r14 = new Regex("^", RegexOptions.Multiline);Console.WriteLine("r14 match count:" + r14.Matches(i).Count);//2Regex r15 = new Regex("$", RegexOptions.Multiline);Console.WriteLine("r15 match count:" + r15.Matches(i).Count);//2Regex r16 = new Regex("^Live for nothing,/r$/n^die for something$", RegexOptions.Multiline);
Console.WriteLine("r16 match count:" + r16.Matches(i).Count);//1//对于一个多行字符串，在设置了Multiline选项之后，^和$将出现多次匹配。
string i = "Live for nothing,die for something";string m = "Live for nothing,die for some thing";Regex r1 = new Regex(@"/bthing/b");
Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0Regex r2 = new Regex(@"thing/b");
Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//2Regex r3 = new Regex(@"/bthing/b");
Console.WriteLine("r3 match count:" + r3.Matches(m).Count);//1Regex r4 = new Regex(@"/bfor something/b");
Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//1///b通常用于约束一个完整的单词
(4)重复描述字符
“重复描述字符”是体现C#正则表达式“很好很强大”的地方之一：
{n} 匹配前面的字符n次
{n,} 匹配前面的字符n次或多于n次
{n,m} 匹配前面的字符n到m次
? 匹配前面的字符0或1次
+ 匹配前面的字符1次或多于1次
* 匹配前面的字符0次或式于0次
以下提供一些简单的示例：
[c-sharp] view plaincopy
string x = "1024";
string y = "+1024";
string z = "1,024";
string a = "1";
string b="-1024";
string c = "10000";
Regex r = new Regex(@"^/+?[1-9],?/d{3}$");
Console.WriteLine("x match count:" + r.Matches(x).Count);//1Console.WriteLine("y match count:" + r.Matches(y).Count);//1Console.WriteLine("z match count:" + r.Matches(z).Count);//1Console.WriteLine("a match count:" + r.Matches(a).Count);//0Console.WriteLine("b match count:" + r.Matches(b).Count);//0Console.WriteLine("c match count:" + r.Matches(c).Count);//0//匹配的整数。
(5)择一匹配
C#正则表达式中的 (|)
符号似乎没有一个专门的称谓，姑且称之为“择一匹配”吧。事实上，像[a-z]也是一种择一匹配，只不过它只能匹配单个字符，而(|)则提供了更大的范围，(ab|xy)表示匹配ab或匹配xy。注意“|”与“()”在此是一个整体。下面提供一些简单的示例：
[c-sharp] view plaincopy
string x = "0";
string y = "0.23";
string z = "100";
string a = "100.01";
string b = "9.9";
string c = "99.9";
string d = "99.";
string e = "00.1";
Regex r = new Regex(@"^/+?((100(.0+)*)|([1-9]?[0-9])(/./d+)*)$");Console.WriteLine("x match count:" + r.Matches(x).Count);//1Console.WriteLine("y match count:" + r.Matches(y).Count);//1Console.WriteLine("z match count:" + r.Matches(z).Count);//1Console.WriteLine("a match count:" + r.Matches(a).Count);//0Console.WriteLine("b match count:" + r.Matches(b).Count);//1Console.WriteLine("c match count:" + r.Matches(c).Count);//1Console.WriteLine("d match count:" + r.Matches(d).Count);//0Console.WriteLine("e match count:" + r.Matches(e).Count);//0//匹配0到100的数。最外层的括号内包含两部分“(100(.0+)*)”，“([1-9]?[0-9])(/./d+)*”，这两部分是“OR”的关系，即正则表达式引擎会先尝试匹配100，如果失败，则尝试匹配后一个表达式(表示[0,100)范围中的数字)。
(6)特殊字符的匹配
下面提供一些简单的示例：
[c-sharp] view plaincopy
string x = "//";
Regex r1 = new Regex("^////$");
Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1Regex r2 = new Regex(@"^//$");
Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1Regex r3 = new Regex("^//$");
Console.WriteLine("r3 match count:" + r3.Matches(x).Count);//0//匹配“/”
string x = "/"";
Regex r1 = new Regex("^/"$");
Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1Regex r2 = new Regex(@"^""$");
Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1//匹配双引号
(7)组与非捕获组
以下提供一些简单的示例：
[c-sharp] view plaincopy
string x = "Live for nothing,die for something";string y = "Live for nothing,die for somebody";Regex r = new Regex(@"^Live ([a-z]{3}) no([a-z]{5}),die /1 some/2$");Console.WriteLine("x match count:" + r.Matches(x).Count);//1Console.WriteLine("y match count:" + r.Matches(y).Count);//0//正则表达式引擎会记忆“()”中匹配到的内容，作为一个“组”，并且可以通过索引的方式进行引用。表达式中的“/1”，用于反向引用表达式中出现的第一个组，即粗体标识的第一个括号内容，“/2”则依此类推。
string x = "Live for nothing,die for something";Regex r = new Regex(@"^Live for no([a-z]{5}),die for some/1$");if (r.IsMatch(x))
{Console.WriteLine("group1 value:" +
r.Match(x).Groups[1].Value);//输出：thing
//获取组中的内容。注意，此处是Groups[1]，因为Groups[0]是整个匹配的字符串，即整个变量x的内容。
string x = "Live for nothing,die for something";Regex r = new Regex(@"^Live for no(?[a-z]{5}),die for some/1$");if (r.IsMatch(x))
{Console.WriteLine("group1 value:" +
r.Match(x).Groups["g1"].Value);//输出：thing
//可根据组名进行索引。使用以下格式为标识一个组的名称(?…)。
string x = "Live for nothing nothing";
Regex r = new Regex(@"([a-z]+) /1");
if (r.IsMatch(x))
{x = r.Replace(x, "$1");
Console.WriteLine("var x:" + x);//输出：Live for nothing}
//删除原字符串中重复出现的“nothing”。在表达式之外，使用“$1”来引用第一个组，下面则是通过组名来引用：
string x = "Live for nothing nothing";
Regex r = new Regex(@"(?[a-z]+) /1");
if (r.IsMatch(x))
{x = r.Replace(x, "${g1}");
Console.WriteLine("var x:" + x);//输出：Live for nothing}
string x = "Live for nothing";
Regex r = new Regex(@"^Live for no(?:[a-z]{5})$");if (r.IsMatch(x))
{Console.WriteLine("group1 value:" +
r.Match(x).Groups[1].Value);//输出：(空)
//在组前加上“?:”表示这是个“非捕获组”，即引擎将不保存该组的内容。
(8)贪婪与非贪婪
正则表达式的引擎是贪婪，只要模式允许，它将匹配尽可能多的字符。通过在“重复描述字符”(*,+)后面添加“?”，可以将匹配模式改成非贪婪。请看以下示例：
[c-sharp] view plaincopy
string x = "Live for nothing,die for something";Regex r1 = new Regex(@".*thing");
if (r1.IsMatch(x))
{Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,die for something
Regex r2 = new Regex(@".*?thing");
if (r2.IsMatch(x))
{Console.WriteLine("match:" + r2.Match(x).Value);//输出：Live for nothing}
(9)回溯与非回溯
使用“(?&…)”方式进行非回溯声明。由于正则表达式引擎的贪婪特性，导致它在某些情况下，将进行回溯以获得匹配，请看下面的示例：
[c-sharp] view plaincopy
string x = "Live for nothing,die for something";Regex r1 = new Regex(@".*thing,");
if (r1.IsMatch(x))
{Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,}
Regex r2 = new Regex(@"(?&.*)thing,");
if (r2.IsMatch(x))//不匹配
{Console.WriteLine("match:" + r2.Match(x).Value);}
//在r1中，“.*”由于其贪婪特性，将一直匹配到字符串的最后，随后匹配“thing”，但在匹配“,”时失败，此时引擎将回溯，并在“thing,”处匹配成功。
在r2中，由于强制非回溯，所以整个表达式匹配失败。
(10)正向预搜索、反向预搜索
正向预搜索声明格式：正声明 “(?=…)”，负声明 “(?!...)” ，声明本身不作为最终匹配结果的一部分，请看下面的示例：
[c-sharp] view plaincopy
string x = "1024 used 2048 free";
Regex r1 = new Regex(@"/d{4}(?= used)");
if (r1.Matches(x).Count==1)
{Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024}
Regex r2 = new Regex(@"/d{4}(?! used)");
if (r2.Matches(x).Count==1)
{Console.WriteLine("r2 match:" + r2.Match(x).Value); //输出：2048}
//r1中的正声明表示必须保证在四位数字的后面必须紧跟着“ used”，r2中的负声明表示四位数字之后不能跟有“ used”。
反向预搜索声明格式：正声明“(?&=)”，负声明“(?
[c-sharp] view plaincopy
string x = "used:1024 free:2048";
Regex r1 = new Regex(@"(?&=used:)/d{4}");
if (r1.Matches(x).Count==1)
{Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024}
Regex r2 = new Regex(@"(?
if (r2.Matches(x).Count==1)
{Console.WriteLine("r2 match:" + r2.Match(x).Value);//输出：2048}
//r1中的反向正声明表示在4位数字之前必须紧跟着“used:”，r2中的反向负声明表示在4位数字之前必须紧跟着除“used:”之外的字符串。
(11)十六进制字符范围
正则表达式中，可以使用 "/xXX" 和 "/uXXXX" 表示一个字符("X" 表示一个十六进制数)形式字符范围：
/xXX 编号在 0到255 范围的字符，比如：空格可以使用 "/x20" 表示。
/uXXXX 任何字符可以使用 "/u" 再加上其编号的4位十六进制数表示，比如：汉字可以使用“[/u4e00-/u9fa5]”表示。
(12)对[0,100]的比较完备的匹配
下面是一个比较综合的示例，对于匹配[0,100]，需要特殊考虑的地方包括*00合法，00.合法，00.00合法，001.100合法
*空字符串不合法，仅小数点不合法，大于100不合法*数值是可带后缀的，如“1.07f”表示该值为一个float类型(未考虑)[c-sharp] view plaincopy
Regex r = new
Regex(@"^/+?0*(?:100(/.0*)?|(/d{0,2}(?=/./d)|/d{1,2}(?=($|/.$)))(/./d*)?)$");string x = "";
while (true)
{x = Console.ReadLine();
if (x != "exit")
{if (r.IsMatch(x))
{Console.WriteLine(x + " succeed!");
{Console.WriteLine(x + " failed!");
(13)精确匹配有时候是困难的
有些需求要做到精确匹配比较困难，例如：日期、Url、Email地址等，其中一些你甚至需要研究一些专门的文档写出精确完备的表达式，对于这种情况，只能退而求其次，保证比较精确的匹配。例如对于日期，可以基于应用系统的实际情况考虑一段较短的时间，或者对于像Email的匹配，可以只考虑最常见的形式。
达内深圳校区温馨提示：如果你在阅读文章时碰到什么不清楚或不明白的地方，可以进行在线咨询；如果你需要报名，也可以通过在线预约，我们将免费为你安排，或者关注深圳达内微信公众平台：tarenasz（更多内容请点击：）
马上预约三天免费体验课
怕钱不够？就业挣钱后再付学费; &&&&
怕学不会？
真正0基础入学，120天精通;&&&&
担心就业？
7万家雇主企业，名企内部就业
原则上我们按照算法采用的方法和思路来给它们分类。这样给算法分类的一个原因是：如果我们理解了它采用的一般思路我们常常就能够对该算法获得一些深入的了解。在解决一些没有现成算法求解，但与现有问题类似的问题时，我们从中可以得到一些启发和灵感。当然，有些算法有悖于分类原则，而另一些则是多种方法相结合的产物。深圳C++培训(sz.c.tedu.cn)专家将介绍一些常用的方法。
企业级开发人们都会想到java、c++语言，但是很多人都知道所有语言的基础就是C语言，随着移动互联日益占据主角，iOS产品的热度更是与日俱增，很多企业都开发iOS产品，这也让iOS培训占据了培训业的主角。达内教育是iOS培训业领导者，培养了很多优秀的iOS开发，让很多想成为iOS产品开发的程序员获得了技术上的提升，从而让自身的发展获得了直线上升
随着移动互联系统的不断完善和客户端软件的不断更新，C++程序员已经深入大众生活，毫不夸张的说，用户已经离不开移动互联网了，在火热的背后一条完善的产业链逐步成型，但这些存在的基础离不开C++程序员程序员。很多人也都知道C++程序员的潜力，因此C++程序员开发纷纷转向C++程序员开发，一些毫无开发基础的人也都从头学起，进入C++程序员开发行业，因为这是一次改变职业的机会。
今天，达内深圳C++培训机构的小编将要为大家带来的是：值得阅读学习的 10 个 C 语言开源项目代码。
1. Webbench
Webbench是一个在linux下使用的非常简单的网站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL，测试网站在压力下工作的性能，可以模拟3万个并发连接去测试网站的负载能力。Webbench使用C语言编写, 代码实在太简洁，源码加起来不到600行。
Copyright (C)
Tedu.cn All Rights Reserved 京ICP备号-56 版权所有
选择城市和中心
达内北京亦庄大学生实训基地
达内北京网络营销中心
达内北京会计中心