正則表達式編譯
首先，正則表達式不僅在Java里有，其它語言裡面也有，它是一個數學上的概念，各個語言中的正則表達式是它的不同形式的實現。
其次，編譯原理的詞法分析里，會用到正則表達式去匹配源程序中的各種token(記號)，比如說
int a = 8;
里識別出：
類型名：int
變數名：a
運算符：=
數字：8
結尾分號：;
總之，二者有聯系，但不是一回事。
2. C語言中如何使用正則表達式 詳細�0�3
由於它可以極大地簡化處理字元串時的復雜度，因此現在已經在許多 L i n u x 實用工具中得到了應用。千萬不要以為正則表達式只是 P e r l 、 P y t h o n 、 B a s h 等腳本語言的專利，作為 C 語言程序員，用戶同樣可以在自己的程序中運用正則表達式。標準的 C 和 C + + 都不支持正則表達式，但有一些函數庫可以輔助 C / C + + 程序員完成這一功能，其中最著名的當數 P h i l i p H a z e l 的 P e r l - C o m p a t i b l e R e g u l a r E x p r e s s i o n 庫，許多 L i n u x 發行版本都帶有這個函數庫。編譯正則表達式為了提高效率，在將一個字元串與正則表達式進行比較之前，首先要用 r e g c o m p ( ) 函數對它進行編譯，將其轉化為 r e g e x _ t 結構： i n t r e g c o m p ( r e g e x _ t * p r e g , c o n s t c h a r * r e g e x , i n t c f l a g s ) ; 參數 r e g e x 是一個字元串，它代表將要被編譯的正則表達式；參數 p r e g 指向一個聲明為 r e g e x _ t 的數據結構，用來保存編譯結果；參數 c f l a g s 決定了正則表達式該如何被處理的細節。如果函數 r e g c o m p ( ) 執行成功，並且編譯結果被正確填充到 p r e g 中後，函數將返回 0 ，任何其它的返回結果都代表有某種錯誤產生。匹配正則表達式一旦用 r e g c o m p ( ) 函數成功地編譯了正則表達式，接下來就可以調用 r e g e x e c ( ) 函數完成模式匹配： i n t r e g e x e c ( c o n s t r e g e x _ t * p r e g , c o n s t c h a r * s t r i n g , s i z e _ t n m a t c h , r e g m a t c h _ t p m a t c h [ ] , i n t e f l a g s ) ; t y p e d e f s t r u c t { r e g o f f _ t r m _ s o ; r e g o f f _ t r m _ e o ; } r e g m a t c h _ t ; 參數 p r e g 指向編譯後的正則表達式，參數 s t r i n g 是將要進行匹配的字元串，而參數 n m a t c h 和 p m a t c h 則用於把匹配結果返回給調用程序，最後一個參數 e f l a g s 決定了匹配的細節。在調用函數 r e g e x e c ( ) 進行模式匹配的過程中，可能在字元串 s t r i n g 中會有多處與給定的正則表達式相匹配，參數 p m a t c h 就是用來保存這些匹配位置的，而參數 n m a t c h 則告訴函數 r e g e x e c ( ) 最多可以把多少個匹配結果填充到 p m a t c h 數組中。當 r e g e x e c ( ) 函數成功返回時，從 s t r i n g + p m a t c h [ 0 ] . r m _ s o 到 s t r i n g + p m a t c h [ 0 ] . r m _ e o 是第一個匹配的字元串，而從 s t r i n g + p m a t c h [ 1 ] . r m _ s o 到 s t r i n g + p m a t c h [ 1 ] . r m _ e o ，則是第二個匹配的字元串，依此類推。釋放正則表達式無論什麼時候，當不再需要已經編譯過的正則表達式時，都應該調用函數 r e g f r e e ( ) 將其釋放，以免產生內存泄漏。 v o i d r e g f r e e ( r e g e x _ t * p r e g ) ; 函數 r e g f r e e ( ) 不會返回任何結果，它僅接收一個指向 r e g e x _ t 數據類型的指針，這是之前調用 r e g c o m p ( ) 函數所得到的編譯結果。如果在程序中針對同一個 r e g e x _ t 結構調用了多次 r e g c o m p ( ) 函數， P O S I X 標准並沒有規定是否每次都必須調用 r e g f r e e ( ) 函數進行釋放，但建議每次調用 r e g c o m p ( ) 函數對正則表達式進行編譯後都調用一次 r e g f r e e ( ) 函數，以盡早釋放佔用的存儲空間。報告錯誤信息如果調用函數 r e g c o m p ( ) 或 r e g e x e c ( ) 得到的是一個非 0 的返回值，則表明在對正則表達式的處理過程中出現了某種錯誤，此時可以通過調用函數 r e g e r r o r ( ) 得到詳細的錯誤信息。 s i z e _ t r e g e r r o r ( i n t e r r c o d e , c o n s t r e g e x _ t * p r e g , c h a r * e r r b u f , s i z e _ t e r r b u f _ s i z e ) ; 參數 e r r c o d e 是來自函數 r e g c o m p ( ) 或 r e g e x e c ( ) 的錯誤代碼，而參數 p r e g 則是由函數 r e g c o m p ( ) 得到的編譯結果，其目的是把格式化消息所必須的上下文提供給 r e g e r r o r ( ) 函數。在執行函數 r e g e r r o r ( ) 時，將按照參數 e r r b u f _ s i z e 指明的最大位元組數，在 e r r b u f 緩沖區中填入格式化後的錯誤信息，同時返回錯誤信息的長度。應用正則表達式最後給出一個具體的實例，介紹如何在 C 語言程序中處理正則表達式。 # i n c l u d e < s t d i o . h > ; # i n c l u d e < s y s / t y p e s . h > ; # i n c l u d e < r e g e x . h > ; / * 取子串的函數 * / s t a t i c c h a r * s u b s t r ( c o n s t c h a r * s t r , u n s i g n e d s t a r t , u n s i g n e d e n d ) { u n s i g n e d n = e n d - s t a r t ; s t a t i c c h a r s t b u f [ 2 5 6 ] ; s t r n c p y ( s t b u f , s t r + s t a r t , n ) ; s t b u f [ n ] = 0 ; r e t u r n s t b u f ; } / * 主程序 * / i n t m a i n ( i n t a r g c , c h a r * * a r g v ) { c h a r * p a t t e r n ; i n t x , z , l n o = 0 , c f l a g s = 0 ; c h a r e b u f [ 1 2 8 ] , l b u f [ 2 5 6 ] ; r e g e x _ t r e g ; r e g m a t c h _ t p m [ 1 0 ] ; c o n s t s i z e _ t n m a t c h = 1 0 ; / * 編譯正則表達式 * / p a t t e r n = a r g v [ 1 ] ; z = r e g c o m p ( & r e g , p a t t e r n , c f l a g s ) ; i f ( z ! = 0 ) { r e g e r r o r ( z , & r e g , e b u f , s i z e o f ( e b u f ) ) ; f p r i n t f ( s t d e r r , " % s : p a t t e r n ' % s ' \ n " , e b u f , p a t t e r n ) ; r e t u r n 1 ; } / * 逐行處理輸入的數據 * / w h i l e ( f g e t s ( l b u f , s i z e o f ( l b u f ) , s t d i n ) ) { + + l n o ; i f ( ( z = s t r l e n ( l b u f ) ) > ; 0 & & l b u f [ z - 1 ] = = ' \ n ' ) l b u f [ z - 1 ] = 0 ; / * 對每一行應用正則表達式進行匹配 * / z = r e g e x e c ( & r e g , l b u f , n m a t c h , p m , 0 ) ; i f ( z = = R E G _ N O M A T C H ) c o n t i n u e ; e l s e i f ( z ! = 0 ) { r e g e r r o r ( z , & r e g , e b u f , s i z e o f ( e b u f ) ) ; f p r i n t f ( s t d e r r , " % s : r e g c o m ( ' % s ' ) \ n " , e b u f , l b u f ) ; r e t u r n 2 ; } / * 輸出處理結果 * / f o r ( x = 0 ; x < n m a t c h & & p m [ x ] . r m _ s o ! = - 1 ; + + x ) { i f ( ! x ) p r i n t f ( " % 0 4 d : % s \ n " , l n o , l b u f ) ; p r i n t f ( " $ % d = ' % s ' \ n " , x , s u b s t r ( l b u f , p m [ x ] . r m _ s o , p m [ x ] . r m _ e o ) ) ; } } / * 釋放正則表達式 * / r e g f r e e ( & r e g ) ; r e t u r n 0 ; } 上述程序負責從命令行獲取正則表達式，然後將其運用於從標准輸入得到的每行數據，並列印出匹配結果。執行下面的命令可以編譯並執行該程序： # g c c r e g e x p . c - o r e g e x p # . / r e g e x p ' r e g e x [ a - z ] * ' < r e g e x p . c 0 0 0 3 : # i n c l u d e < r e g e x . h > ; $ 0 = ' r e g e x ' 0 0 2 7 : r e g e x _ t r e g ; $ 0 = ' r e g e x ' 0 0 5 4 : z = r e g e x e c ( & r e g , l b u f , n m a t c h , p m , 0 ) ; $ 0 = ' r e g e x e c ' 小結對那些需要進行復雜數據處理的程序來說，正則表達式無疑是一個非常有用的工具。本文重點在於闡述如何在 C 語言中利用正則表達式來簡化字元串處理，以便在數據處理方面能夠獲得與 P e r l 語言類似的靈活性。
3. 正則表達式概述 什麼是正則表達式
正則表達式概述
正則表達式在程序設計語言中存在著廣泛的應用，特別是用來處理字元串。如匹配字元串、查找字元串、替換字元串等。可以說，正則表達式是一段文本或一個公式，它是用來描述用某種模式去匹配一類字元串的公式，並且該公式具有一定的模式。
本小節將介紹正則表達式的基本概念、第一個正則表達式，以及測試正則表達式的工具Code Architects Regex Tester。
什麼是正則表達式
正則表達式（Regular
Expression）起源於人類神經系統的早期研究。神經生理學家Warren McCulloch和Walter
Pitts研究出一種使用數學方式描述神經網路的方法。1956年，數學家Stephen
Kleene發表了一篇標題為「神經網事件的表示法」的論文，並在該論文中引入了「正則表達式」這一個概念。該論文稱正則表達式是：「正則集的代數」的表達式。因此，採用「正則表達式」這個術語。正則表達式的定義存在多種說法，具體如下：
正則表達式就是用某種模式去匹配一類字元串的公式，主要用來描述字元串匹配的工具。
正則表達式描述了一種字元串匹配的模式。它可以用來檢查字元串是否含有某種子串、將匹配的子串做替換或者從某個串中取出符合某個條件的子串等。
正則表達式是由普通字元（如字元a到z）以及特殊字元（稱為元字元）組成的文字模式。正則表達式作為一個模板，將某個字元模式與所搜索的字元串進行匹配。
正則表達式就是用於描述某些規則的工具。這些規則經常用於處理字元串中的查找或替換字元串。換句話說，正則表達式就是記錄文本規則的代碼。
正則表達式就是用一個「字元串」來描述一個特徵，然後去驗證另一個「字元串」是否符合這個特徵。
學過《編譯原理》的讀者可能知道不確定有限自動機（Non-deterministic
finite automaton，簡稱NFA）和確定有限自動機（Deterministic finite
automaton，簡稱DFA）。其實，正則表達式是一個不確定有限自動機。NFA和DFA的最大區別在於它們的狀態轉換函數。NFA可以對同一個字元串產生多種理解方式，而DFA則只有唯一的一種理解方式。也正因為如此，NFA在匹配過程中可能會回溯，NFA的效率一般要低於DFA。因此，在書寫正則表達式時盡量減少回溯來提高正則表達式的效率。
如果你使用過Windows或DOS下用於文件查找的通配符*和?，那麼你不難理解正則表達式。如果你需要查找所有Word文檔，那麼可能使用表達式*.doc。其中，字元*是一個通配符，它可以代表任意字元串。正則表達式和通配符具有相似性，它也可以使用一些字元（如字元.）表示任意字元。然而，它比通配符更具有精確性。
在正則表達式中，匹配是最常用的一個詞語，它描述了正則表達式動作結果。給定一段文本或字元串，使用正則表達式從文本或字元串中查找出符合正則表達式的字元串。有可能文本或字元存在不止一個部分滿足給定的正則表達式，這時每一個這樣的部分被稱為一個匹配。其中，匹配存在下面3種類型：
形容詞性的匹配，即一個字元串匹配一個正則表達式。
動詞性的匹配，即在文本或字元串里匹配正則表達式。
名詞性的匹配，即字元串中滿足給定的正則表達式的一部分。
正則表達式的應用非常廣泛，特別是在字元串處理方面。目前來說，正則表達式已經在很多軟體中得到廣泛了應用，如Linux、Unix、HP等操作系統，C#、PHP、Java等程序開發環境，以及很多的應用軟體中，都可以看到正則表達式的這樣或那樣的應用。正則表達式常見的應用如下：
驗證字元串，即驗證給定的字元串或子字元串是否符合指定特徵，譬如驗證是否是合法的郵件地址、驗證是否為合法的HTTP地址等。
查找字元串，從給定的文本中查找符合指定特徵的字元串，比查找固定字元串更加靈活方便。
替換字元串，即把給定的字元串中的符合指定特徵的子字元串替換為其他字元串，比普通的替換更強大。
提取字元串，即從給定的字元串中提取符合指定特徵的子字元串。
4. 為什麼C語言中使用正則表達式時要先對其進行編譯
這個跟你用的正則表達式庫有關，要求編譯階段確定正則表達式的運行會快一些。 也有可以運行時編譯的，那個要慢一些
boost中帶有3個正則表達式庫，靜態和動態的都有，需要的話可以查一下怎麼用
5. 編譯原理，正則表達式的低級基礎問題
1、正則表達式：0(0|1)*1
2、由於不方便畫圖，最簡DFA用狀態表表示如下：
（1）開始狀態S------輸入0------->狀態A
（2）狀態A-------輸入0-------->狀態A
（3）狀態A-------輸入1-------->狀態B（可接受狀態）
（4）狀態B-------輸入0-------->狀態A
（5）狀態B-------輸入1-------->狀態B（可接受狀態）
6. java正則表達式
正則表達式定義了字元串的模式。
正則表達式可以用來搜索、編輯或處理文本。
正則表達式並不僅限於某一種語言，但是在每種語言中有細微的差別。
Java正則表達式和Perl的是最為相似的。
java.util.regex包主要包括以下三個類：
Pattern類：
pattern對象是一個正則表達式的編譯表示。Pattern類沒有公共構造方法。要創建一個Pattern對象，你必須首先調用其公共靜態編譯方法，它返回一個Pattern對象。該方法接受一個正則表達式作為它的第一個參數。
Matcher類：
Matcher對象是對輸入字元串進行解釋和匹配操作的引擎。與Pattern類一樣，Matcher也沒有公共構造方法。你需要調用Pattern對象的matcher方法來獲得一個Matcher對象。
PatternSyntaxException：
PatternSyntaxException是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。
7. js正則表達式之RegExp對象之compile方法 編譯正則表達式
功能說明：該方法可以編譯指定的正則表達式，編譯之後的正則表達式執行速度將會提高，如果正則表達式多次被調用，那麼調用compile方法可以有效的提高代碼的執行速度，如果該正則表達式只能被使用一次，則不會有明顯的效果。
基本語法：objReg.compile(pattern[,flag])
objReg必選項，RegExp對象變數的名稱
pattern
必選項
正則表達式
flag
可選項
匹配選項
復制代碼
代碼如下:
<html>
<script
language="javascript"
type="text/javascript">
//要匹配的字元串
var
objStr="我的手機號13522222222，他的手機號碼13233333333她的手機號碼13988888888";
//設置正則表達式匹配以13開頭的11為手機號碼，全局匹配（這里是匹配移動手機號）
var
reg=new
RegExp("13[4-9](//d){8}","g");
//提示用戶發現移動號碼，然後列印出結果
document.write("發現移動手機號碼");
//調用函數列印匹配的結果
findPhoneNumbers(objStr.match(reg));
//重新編譯正則表達式
reg.compile("13[0-3](//d){8}","g");
document.write("發現聯通手機號碼");
findPhoneNumbers(objStr.match(reg));
//定義輸出返回結果函數
function
findPhoneNumbers(arr){
//使用循環輸出數據
for(var
i=0;i<arr.length;i++){
document.write("<li>"+arr[i]+"<br>");
}
}
</script>
</html>
使用compile方法還可以對指定的正則表達式進行修改並且重新編譯，提高了正則表達式的適應性！
8. 正則表達式怎麼編寫
<%
Function RegExpTest(patrn, strng)
Dim regEx, Match, Matches '建立變數。
Set regEx = New RegExp '建立正則表達式。
regEx.Pattern = patrn '設置模式。
regEx.IgnoreCase = True '設置是否區分字元大小寫。
regEx.Global = True '設置全局可用性。
Set Matches = regEx.Execute(strng) '執行搜索。
For Each Match in Matches '遍歷匹配集合。
RetStr = RetStr & "Match found at position "
RetStr = RetStr & Match.FirstIndex & ". Match Value is '"
RetStr = RetStr & Match.Value & "'." & "<BR>"
Next
RegExpTest = RetStr
End Function
response.write RegExpTest("[ij]s.", "IS1 Js2 IS3 is4")
%>
在這個例子中，我們查找字元串中有無is或者js這兩個詞，忽略大小寫。運行的結果如下：
Match found at position 0. Match Value is 'IS1'.
Match found at position 4. Match Value is 'Js2'.
Match found at position 8. Match Value is 'IS3'.
Match found at position 12. Match Value is 'is4'.
下面我們就介紹這三個對象和集合。
1、RegExp對象是最重要的一個對象，它有幾個屬性，其中：
○Global 屬性，設置或返回一個 Boolean 值，該值指明在整個搜索字元串時模式是全部匹配還是只匹配第一個。如果搜索應用於整個字元串，Global 屬性的值為 True，否則其值為 False。默認的設置為 False。
○IgnoreCase 屬性，設置或返回一個Boolean值，指明模式搜索是否區分大小寫。如果搜索是區分大小寫的，則 IgnoreCase 屬性為 False；否則為 True。預設值為 False。
○Pattern 屬性，設置或返回被搜索的正則表達式模式。必選項。總是一個 RegExp 對象變數。
2、Match 對象
匹配搜索的結果是存放在Match對象中，提供了對正則表達式匹配的只讀屬性的訪問。 Match 對象只能通過 RegExp 對象的 Execute 方法來創建，該方法實際上返回了 Match 對象的集合。所有的 Match 對象屬性都是只讀的。在執行正則表達式時，可能產生零個或多個 Match 對象。每個 Match 對象提供了被正則表達式搜索找到的字元串的訪問、字元串的長度，以及找到匹配的索引位置等。
○FirstIndex 屬性，返回在搜索字元串中匹配的位置。FirstIndex 屬性使用從零起算的偏移量，該偏移量是相對於搜索字元串的起始位置而言的。換言之，字元串中的第一個字元被標識為字元 0
○Length 屬性，返回在字元串搜索中找到的匹配的長度。
○Value 屬性，返回在一個搜索字元串中找到的匹配的值或文本。
3、Matches 集合
正則表達式 Match 對象的集合。Matches 集合中包含若干獨立的 Match 對象，只能使用 RegExp 對象的 Execute 方法來創建之。與獨立的 Match 對象屬性相同，Matches `集合的一個屬性是只讀的。在執行正則表達式時，可能產生零個或多個 Match 對象。每個 Match 對象都提供了與正則表達式匹配的字元串的訪問入口、字元串的長度，以及標識匹配位置的索引。
學習了這三個對象和集合，如何應用於字元串的判斷和替換呢？regExp對象的三個方法正好解決了這個問題，它們是Replace方法、Test方法和Execute方法。
1、Replace 方法
替換在正則表達式查找中找到的文本。我們還是先看個例子：下面的例子說明了 Replace 方法的用法。
<%
Function ReplaceTest(patrn, replStr)
Dim regEx, str1 ' 建立變數。
str1 = "The quick brown fox jumped over the lazy dog."
Set regEx = New RegExp ' 建立正則表達式。
regEx.Pattern = patrn ' 設置模式。
regEx.IgnoreCase = True ' 設置是否區分大小寫。
ReplaceTest = regEx.Replace(str1, replStr) ' 作替換。
End Function
Response.write ReplaceTest("fox", "cat") & "<BR>" ' 將 'fox' 替換為 'cat'。
Response.write ReplaceTest("(\S+)(\s+)(\S+)", "$3$2$1") ' 交換詞對.
%>
2、Test 方法
對指定的字元串執行一個正則表達式搜索，並返回一個 Boolean 值指示是否找到匹配的模式。正則表達式搜索的實際模式是通過RegExp對象的Pattern屬性來設置的。RegExp.Global屬性對Test方法沒有影響。
如果找到了匹配的模式，Test方法返回True；否則返回False。下面的代碼說明了Test 方法的用法。
<%
Function RegExpTest(patrn, strng)
Dim regEx, retVal ' 建立變數。
Set regEx = New RegExp ' 建立正則表達式。
regEx.Pattern = patrn ' 設置模式。
regEx.IgnoreCase = False ' 設置是否區分大小寫。
retVal = regEx.Test(strng) ' 執行搜索測試。
If retVal Then
RegExpTest = "找到一個或多個匹配。"
Else
RegExpTest = "未找到匹配。"
End If
End Function
Response.write RegExpTest("is.", "IS1 is2 IS3 is4")
%>
3、Execute 方法
對指定的字元串執行正則表達式搜索。正則表達式搜索的設計模式是通過 RegExp 對象的 Pattern 來設置的。
Execute 方法返回一個 Matches 集合，其中包含了在 string 中找到的每一個匹配的 Match 對象。如果未找到匹配，Execute 將返回空的 Matches 集合。
9. C語言怎麼用正則表達式
1、標準的C和C++都不支持正則表達式，但有一些函數庫可以輔助C/C++程序員完成這一功能，其中最著名的當數Philip Hazel的Perl-Compatible Regular Expression庫，許多Linux發行版本都帶有這個函數庫。
2、C/C++ 中使用正則表達式一般分為三步：
1）編譯正則表達式 regcomp()
int regcomp (regex_t *compiled, const char *pattern, int cflags)
這個函數把指定的正則表達式pattern編譯成一種特定的數據格式compiled，這樣可以使匹配更有效。函數regexec 會使用這個數據在目標文本串中進行模式匹配。執行成功返回0。
2）匹配正則表達式 regexec()
int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr [], int eflags)
當編譯好正則表達式後，就可以用regexec 匹配我們的目標文本串了，如果在編譯正則表達式的時候沒有指定cflags的參數為REG_NEWLINE，則默認情況下是忽略換行符的，也就是把整個文本串當作一個字元串處理。執行成功返回0。
3）釋放正則表達式 regfree()
void regfree (regex_t *compiled)
當使用完編譯好的正則表達式後，或者要重新編譯其他正則表達式的時候，可以用這個函數清空compiled指向的regex_t結構體的內容。請注意，如果是重新編譯的話，一定要先清空regex_t結構體。