用法 · Beyond the C++ Standard Library 中文版

## 用法要使用Boost.Regex, 你需要包含頭文件`"boost/regex.hpp"`. Regex是本書中兩個需要獨立編譯的庫之一(另一個是Boost.Signals)。你會很高興獲知如果你已經構建了Boost— —那只需在命令提示符下打一行命令——就可以自動鏈接了(對于Windows下的編譯器)，所以你不需要為指出那些庫文件要用而費心。你要做的第一件事就是聲明一個類型 `basic_regex` 的變量。這是該庫的核心類之一，也是存放正則表達式的地方。創建這樣一個變量很簡單；只要將一個含有你要用的正則表達式的字符串傳遞給構造函數就行了。 ``` boost::regex reg("(A.*)"); ``` 這個正則表達式具有三個有趣的特性。第一個是，用圓括號把一個子表達式括起來，這樣可以稍后在同一個正則表達式中引用它，或者取出匹配它的文本。我們稍后會詳細討論它，所以如果你還不知道它有什么用也不必擔心。第二個是，通配符(wildcard)字符，點。這個通配符在正則表達式中有非常特殊的意義；這可以匹配任意字符。最后一個是，這個表達式用到了一個重復符，`*`, 稱為Kleene star, 表示它前面的表達式可以被匹配零次或多次。這個正則表達式已可以用于某個算法了，如下： ``` bool b=boost::regex_match( "This expression could match from A and beyond.", reg); ``` 如你所見，你把正則表達式和要分析的字符串傳遞給算法 `regex_match`. 如果的確存在與正則表達式的匹配，則該函數調用返回結果 `true` ；否則，返回 `false`. 在這個例子中，結果是 `false`, 因為 `regex_match` 僅當整個輸入數據被正則表達式成功匹配時才返回 `true` 。你知道為什么是這樣嗎？再看一下那個正則表達式。第一個字符是大寫的 `A`,?很明顯能夠匹配這個表達式的第一個字符在哪。所以，輸入的一部分`"A and beyond."`可以匹配這個表達式，但這不是整個輸入。讓我們試一下另一個輸入字符串。 ``` bool b=boost::regex_match( "As this string starts with A, does it match? ", reg); ``` 這一次，`regex_match` 返回 `true`. 當正則表達式引擎匹配了 `A`, 它接著看后續有什么。在我們的regex變量中，`A` 后跟一個通配符和一個Kleene star, 這意味著任意字符可以被匹配任意次。因而，分析過程開始扔掉輸入字符串的剩余部分，即匹配了輸入的所有部分。接下來，我們看看如何使用regexes 和 `regex_match` 來進行數據驗證。 ### 驗證輸入正則表達式常用于對輸入數據的格式進行驗證。應用軟件通常要求輸入符合某種結構。考慮一個應用軟件，它要求輸入一定要符合如下格式，"3個數字, 一個單詞, 任意字符, 2個數字或字符串"N/A," 一個空格, 然后重復第一個單詞." 手工編寫代碼來驗證這個輸入既沉悶又容易出錯，而且這些格式還很可能會改變；在你弄明白之前，可能就需要支持其它的格式，你精心編寫的分析器可能就需要修改并重新調試。讓我們寫出一個可以驗證這個輸入的正則表達式。首先，我們需要一個匹配3個數字的表達式。對于數字，我們應該使用一個特別的縮寫，`\d`。要表示它被重復3次，需要一個稱為bounds operator的特定重復，它用花括號括起來。把這兩個合起來，就是我們的正則表達式的開始部分了。 ``` boost::regex reg("\\d{3}"); ``` 注意，我們需要在轉義字符(\)之前加一個轉義字符，即在我們的字符串中，縮寫 `\d` 變成了 `\\d` 。這是因為編譯器會把第一個\當成轉義字符扔掉；我們需要對\進行轉義，這樣\才可以出現在我們的正則表達式中。接下來，我們需要定義一個單詞的方法，即定義一個字符序列，該序列結束于一個非字母字符。有不只一種方法可以實現它，我們將使用字符類別(也稱為字符集)和范圍這兩個正則表達式的特性來做。字符類別即一個用方括號括起來的表達式。例如，一個匹配字符`a`, `b`, 和 `c`中任一個的字符類別表示為：`[abc]`. 如果用范圍來表示同樣的東西，我們要寫：`[a-c]`. 要寫一個包含所有字母的字符類型，我們可能會有點發瘋，如果要把它寫成： `[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]`, 但不用這樣；我們可以用范圍來表示：`[a-zA-Z]`. 要注意的是，象這樣使用范圍要依賴于當前所用的locale，如果正則表達式的 `basic_regex::collate` 標志被打開。使用以上工具以及重復符 `+`, 它表示前面的表達式可以重復，但至少重復一次，我們現在可以表示一個單詞了。 ``` boost::regex reg("[a-zA-Z]+"); ``` 以上正則表達式可以工作，但由于經常要表示一個單詞，所以有一個更簡單的方法：`\w`. 這個符號匹配所有單詞，不僅是ASCII的單詞，因此它不僅更短，而且也更適用于國際化的環境。接下來的字符是一個任意字符，我們已經知道要用點來表示。 ``` boost::regex reg("."); ``` 再接下來是 2個數字或字符串 "N/A." 為了匹配它，我們需要用到一個稱為選擇的特性。選擇即是匹配兩個或更多子表達式中的任意一個，每種選擇之間用 `|` 分隔開。就象這樣： ``` boost::regex reg("(\\d{2}|N/A)"); ``` 注意，這個表達式被圓括號括了起來，以確保整個表達式被看作為兩個選擇。在正則表達式中增加一個空格是很簡單的；用縮寫`\s`. 把以上每一樣東西合并起來，就得到了以下表達式： ``` boost::regex reg("\\d{3}[a-zA-Z]+.(\\d{2}|N/A)\\s"); ``` 現在事情變得有點復雜了。我們需要某種方法，來驗證接下來的輸入數據中的單詞是否匹配第一個單詞(即那個我們用表達式`[a-zA-Z]+`所捕獲的單詞)。關鍵是要使用后向引用(back reference)，即對前面的子表達式的引用。為了可以引用表達式 `[a-zA-Z]+`, 我們必須先把它用圓括號括起來。這使得表達式`([a-zA-Z]+)`成為我們的正則表達式中的第一個子表達式，我們就可以用索引1來建立一個后向引用了。這樣，我們就得到了整個正則表達式，用于表示"3個數字, 一個單詞, 任意字符, 2個數字或字符串"N/A," 一個空格, 然后重復第一個單詞."： ``` boost::regex reg("\\d{3}([a-zA-Z]+).(\\d{2}|N/A)\\s\\1"); ``` 干的好！下面是一個簡單的程序，把這個表達式用于算法 `regex_match`, 驗證兩個輸入字符串。 ``` #include <iostream> #include <cassert> #include <string> #include "boost/regex.hpp" int main() { // 3 digits, a word, any character, 2 digits or "N/A", // a space, then the first word again 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); } ``` 第一個字符串，`123Hello N/A Hello`, 是正確的；`123` 是3個數字，`Hello` 是一個后跟任意字符(一個空格)的單詞，然后是N/A和另一個空格，最后重復單詞`Hello` 。第二個字符串是不正確的，因為單詞 `Hello` 沒有被嚴格重復。缺省情況下，正則表達式是大小寫敏感的，因而反向引用不能匹配。寫出正則表達式的一個關鍵是成功地分解問題。看一下你剛才建立的最終的那個表達式，對于未經過訓練的人來說它的確很難懂。但是，如果把這個表達式分解成小的部分，它就不太復雜了。 ### 查找現在我們來看一下另一個Boost.Regex算法, `regex_search`. 與 `regex_match` 不同的是，`regex_search` 不要求整個輸入數據完全匹配，則僅要求部分數據可以匹配。作為說明，考慮一個程序員的問題，他可能在他的程序中有一至兩次忘記了調用 `delete` 。雖然他知道這個簡單的測試可能沒什么意義，他還是決定計算一下new 和 delete出現的次數，看看數字是否符合。這個正則表達式很簡單；我們有兩個選擇，new 和 delete. ``` boost::regex reg("(new)|(delete)"); ``` 有兩個原因我們要把子表達式用括號括起來：一個是為了表明我們的選擇是兩個組。另一個原因是我們想在調用`regex_search`時引用這些子表達式，這樣我們就可以判斷是哪一個選擇被匹配了。我們使用`regex_search`的一個重載，它接受一個`match_results`類型的參數。當 `regex_search` 執行匹配時，它通過一個`match_results`類型的對象報告匹配的子表達式。類模板 `match_results` 使用一個輸入序列所用的迭代器類型來參數化。 ``` template <class Iterator, class Allocator=std::allocator<sub_match<Iterator> > class match_results; typedef match_results<const char*> cmatch; typedef match_results<const wchar_t> wcmatch; typedef match_results<std::string::const_iterator> smatch; typedef match_results<std::wstring::const_iterator> wsmatch; ``` 我們將使用 `std::string`, 所以要留意 `typedef smatch`, 它是 `match_results<std::string::const_iterator>`的縮寫。如果 `regex_search` 返回 `true`, 傳遞給該函數的 `match_results` 引用將包含匹配的子表達式結果。在 `match_results`里，用已索引的`sub_match`來表示正則表達式中的每個子表達式。我們來看一下我們如何幫助這位困惑的程序員來計算對`new` 和 `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!"; if (boost::regex_search(s,m,reg)) { // Did new match? if (m[1].matched) std::cout << "The expression (new) matched!\n"; if (m[2].matched) std::cout << "The expression (delete) matched!\n"; } ``` 以上程序在輸入字符串中查找 `new` 或 `delete`, 并報告哪一個先被找到。通過傳遞一個類型 `smatch` 的對象給 `regex_search`, 我們可以得知算法如何執行成功的細節。我們的表達式中有兩個子表達式，因此我們可以通過`match_results`的索引1得到子表達式 `new` . 這樣我們得到一個 `sub_match`實例，它有一個Boolean成員，`matched`, 告訴我們這個子表達式是否參與了匹配。因此，對于上例的輸入，運行結果將輸出"The expression (new) matched!\n". 現在，你還有一些工作要做。你需要繼續把正則表達式應用于輸入的剩余部分，為此，你要使用另外一個 `regex_search`的重載，它接受兩個迭代器，指示出要查找的字符序列。因為 `std::string` 是一個容器，它提供了迭代器。現在，在每一次匹配時，你必須把指示范圍起始點的迭代器更新為上一次匹配的結束點。最后，增加兩個變量來記錄 `new` 和 `delete`的次數。以下是完整的程序： ``` #include <iostream> #include <string> #include "boost/regex.hpp" int main() { // "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"; } ``` 注意，這個程序總是把迭代器 `it` 設置為 `m[0].second`。`match_results[0]` 返回對匹配整個正則表達式的子匹配的引用，因此我們可以確認這個匹配的結束點就是下次運行`regex_search`的起始點。運行這個程序將輸出"Leak detected!", 因為這里有兩次 `new`, 而只有一次 `delete`. 當然，一個變量也可能在兩個地方刪除，還有可能調用 `new[]` 和 `delete[]`, 等等。現在，你應該已經對子表達式如何分組使用有了較好的了解。現在是時候進入到最后一個Boost.Regex算法，該算法用于執行替換工作。 ### 替換 Regex算法家族中的第三個算法是 `regex_replace`. 顧名思義，它是用于執行文本替換的。它在整個輸入數據中進行搜索，查找正則表達式的所有匹配。對于表達式的每一個匹配，該算法調用 `match_results::format` 并輸入結果到一個傳入函數的輸出迭代器。在本章的介紹部分，我給出了一個例子，將英式拼法的 colour 替換為美式拼法 color. 不使用正則表達式來進行這個拼寫更改會非常乏味，也很容易出錯。問題是可能存在不同的大小寫，而且會有很多單詞被影響，如colourize. 要正確地解決這個問題，我們需要把正則表達式分為三個子表達式。 ``` boost::regex reg("(Colo)(u)(r)", boost::regex::icase|boost::regex::perl); ``` 我們將要去掉的字母u獨立開，為了在所有匹配中可以很容易地刪掉它。另外，注意到這個正則表達式是大小寫無關的，我們要把格式標志 `boost::regex::icase` 傳給 `regex` 的構造函數。你還要傳遞你想要設置的其它標志。設置標志時一個常見的錯誤就是忽略了`regex`缺省打開的那些標志，如果你沒有設置這些標志，它們不會打開，你必須設置所有你要打開的標志。調用 `regex_replace`時，我們要以參數方式提供一個格式化字符串。該格式化字符串決定如何進行替換。在這個格式化字符串中，你可以引用匹配的子表達式，這正是我們想要的。你想保留第一個和第三個匹配的子表達式，而去掉第二個`(u)`。表達式 `$N`表示匹配的子表達式,?`N` 為子表達式索引。因此我們的格式化串應該是 `"$1$3"`, 表示替換文本為第一個和第三個子表達式。通過引用匹配的子表達式，我們可以保留匹配文本中的所有大小寫，而如果我們用字符串來作替換文本則不能做到這一點。以下是解決這個問題的完整程序。 ``` #include <iostream> #include <string> #include "boost/regex.hpp" int main() { 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; } ``` 程序的輸出是 `"Color, colors, color, colorize"`. `regex_replace` 對于這樣的文本替換非常有用。 ### 用戶常見的誤解我所見到的與Boost.Regex相關的最常見的問題與`regex_match`的語義有關。人們很容易忘記必須使`regex_match`的所有輸入匹配給定的正則表達式。因此，用戶常以為以下代碼會返回 `true`. ``` boost::regex reg("\\d*"); bool b=boost::regex_match("17 is prime",reg); ``` 無疑這個調用永遠不會得到成功的匹配。只有所有輸入被 `regex_match` 匹配才可以返回 `true`！幾乎所有的用戶都會問為什么 `regex_search` 不是這樣而 `regex_match` 是。 ``` boost::regex reg("\\d*"); bool b=boost::regex_search("17 is prime",reg); ``` 這次肯定返回 `true`. 值得注意的是，你可以用一些特定的緩沖操作符來讓 `regex_search` 象 `regex_match` 那樣運行。`\A` 匹配緩沖的起始點，而 `\Z` 匹配緩沖的結束點，因此如果你把 `\A` 放在正則表達式的開始，把 `\Z` 放在最后，你就可以讓 `regex_search` 象 `regex_match` 那樣使用，即必須匹配所有輸入。以下正則表達式要求所有輸入被匹配掉，而不管你使用的是 `regex_match` 或是 `regex_search`. ``` boost::regex reg("\\A\\d*\\Z"); ``` 請記住，這并不表示可以無需使用 `regex_match`；相反，它可以清晰地表明我們剛才說到的語義，即必須匹配所有輸入。 ### 關于重復和貪婪另一個容易混淆的地方是關于重復的貪婪。有些重復，如 `+` 和 `*`，是貪婪的。即是說，它們會消耗掉盡可能多的輸入。以下正則表達式并不罕見，它用于在一個貪婪的重復后捕獲兩個數字。 ``` boost::regex reg("(.*)(\\d{2})"); ``` 這個正則表達式是對的，但它可能不能匹配你想要的子表達式！表達式 `.*` 會吞掉所有東西而后續的子表達式將不能匹配。以下是示范這個行為的一個例子： ``` int main() { 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'; } } ``` 在這個程序中，我們使用了`match_results`的另一個特化版本，即類型 `cmatch`. 它就是 `match_results<const char*>` 的`typedef`, 之所以我們必須用它而不是用之前用過的 `smatch`，是因為我們現在是用一個字符序列調用 `regex_search` 而不是用類型 `std::string` 來調用。你期望這個程序的運行結果是什么？通常，一個剛開始使用正則表達式的用戶會首先想到 `m[1].matched` 和 `m[2].matched` 都為?`true`, 且第二個子表達式的結果會是 "`31`". 接著在認識到貪婪的重復所帶來的效果后，即重復會盡可能消耗輸入，用戶會想到只有第一個子表達式是 `true`，即 `.*` 成功地吞掉了所有的輸入。最后，新用戶得到了下結論，兩個子表達式都被匹配，但第二個表達式匹配的是最后一個可能的序列。即第一個子表達式匹配的是 "`Note that I'm 31 years old, not`" 而第二個匹配 "`32`". 那么，如果你想使用重復并匹配另一個子表達式的第一次出現，該怎么辦？要使用非貪婪的重復。在重復符后加一個 `?` ，重復就變為非貪婪的了。這意味著該表達式會嘗試發現最短的匹配可能而不再阻止表達式的剩余部分進行匹配。因此，要讓前面的正則表達式正確工作，我們需要把它改為這樣。 ``` boost::regex reg("(.*?)(\\d{2})"); ``` 如果我們用這個正則表達式來修改程序，那么 `m[1].matched` 和 `m[2].matched` 都會為 `true`. 表達式 `.*?` 只消耗最少可能的輸入，即它將在第一個字符 `3`處停止，因為這就是表達式要成功匹配所需要的。因此，第一個子表達式會匹配 "`Note that I'm`" 而第二個匹配 "`31`". ### 看一下 regex_iterator 我們已經看過如何用幾次 `regex_search` 調用來處理所有輸入，但另一方面，更為優雅的方法是使用 `regex_iterator`. 這個迭代器類型用一個序列來列舉正則表達式的所有匹配。解引用一個 `regex_iterator` 會產生對一個 `match_results` 實例的引用。構造一個 `regex_iterator` 時，你要把指示輸入序列的迭代器傳給它，并提供相應的正則表達式。我們來看一個例子，輸入數據是一組由逗號分隔的整數。相應的正則表達式很簡單。 ``` boost::regex reg("(\\d+),?"); ``` 在正則表達式的最后加一個 `?` (匹配零次或一次) 確保最后一個數字可以被成功分析，即使輸入序列不是以逗號結束。另外，我們還使用了另一個重復符 `+`. 這個重復符表示匹配一次或多次。現在，不需要多次調用 `regex_search`, 我們創建一個 `regex_iterator`, 并調用算法 `for_each`, 傳給它一個函數對象，該函數對象以迭代器的解引用進行調用。下面是一個接受任意形式的`match_results`的函數對象，它有一個泛型的調用操作符。它所執行的就是把當前匹配的值加到一個總和中(在我們的正則表達式中，第一個子表達式是我們要用的)。 ``` 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_; } }; ``` 現在把這個函數對象的一個實例傳遞給 `std::for_each`, 結果是對每一個迭代器`it`的解引用調用該函數對象，即對每一次匹配的子表達式進行調用。 ``` int main() { 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(); } ``` 如你所見，傳遞給`for_each`的end迭代器是 `regex_iterator` 一個缺省構造實例。`it` 和 `end` 的類型均為 `boost::sregex_iterator`, 即為 `regex_iterator<std::string::const_iterator>`的`typedef`. 這種使用 `regex_iterator` 的方法要比我們前面試過的多次匹配的方法更清晰，在多次匹配的方法中我們不得不在一個循環中讓起始迭代器不斷地前進并調用 `regex_search` 。 ### 用 regex_token_iterator 分割字符串另一個迭代器類型，或者說得更準確些，迭代器適配器，就是 `boost::regex_token_iterator`. 它與 `regex_iterator` 很類似，但卻是用于列舉不匹配某個正則表達式的每一個字符序列，這對于分割字符串很有用。它也可以用于選擇對哪一個子表達式感興趣，當解引用 `regex_token_iterator`時，只有預訂的那個子表達式被返回。考慮這樣一個應用程序，它接受一些用斜線號分隔的數據項作為輸入。兩個斜線號之間的數據組成應用程序要處理的項。使用 `regex_token_iterator`來分割這個字符串很容易。該正則表達式很簡單。 ``` boost::regex reg("/"); ``` 這個 regex 匹配各項間的分割符。要用它來分割輸入，只需簡單地把指定的索引 `1` 傳遞給 [`regex_token_iterator`](#ch05lev2sec10) 的構造函數。以下是完整的程序： ``` int main() { 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"); } ``` 就象 `regex_iterator` 一樣，`regex_token_iterator` 是一個模板類，它使用所包裝的序列的迭代器類型來進行特化。這里，我們用的是 `sregex_token_iterator`, 它是 `regex_token_iterator<std::string::const_iterator>` 的 `typedef` 。每一次解引用這個迭代器`it`，它返回當前的 `sub_match`, 當這個迭代器前進時，它嘗試再次匹配該正則表達式。這兩個迭代器類型，`regex_iterator` 和 `regex_token_iterator`, 都非常有用；你應該明白，當你考慮反復調用`regex_search`時，就該用它們了。 ### 更多的正則表達式你已經看到了不少正則表達式的語法，但還有更多的要了解。這一節簡單地示范一些你每天都會使用的正則表達式的其它功能。作為開始，我們先看一下一組完整的重復符；我們之前已經看到了 `*`, `+`, 以及使用 `{}` 進行限定重復。還有一個重復符，即是 `?`. 你可能已經留意到它也可以用于聲明非貪婪的重復，但對于它本身而言，它是表示一個表達式必須出現零次或一次。還有一點值得提及的是，限定重復符可以很靈活；下面是三種不同的用法： ``` boost::regex reg1("\\d{5}"); boost::regex reg2("\\d{2,4}"); boost::regex reg3("\\d{2,}"); ``` 第一個正則表達式匹配5個數字。第二個匹配 2個, 3個, 或者 4個數字。第三個匹配2個或更多個數字，沒有上限。另一種重要的正則表達式特性是使用元字符 `^` 表示非字符類別。用它來表示一個匹配任意不在給定字符類別中的字符；即你所列字符類別的補集。例如，看如下正則表達式。 ``` boost::regex reg("[^13579]"); ``` 它包含一個非字符類別，匹配任意不是奇數數字的字符。看一下以下這個小程序，試著給出程序的輸出。 ``` int main() { boost::regex reg4("[^13579]"); std::string s="0123456789"; boost::sregex_iterator it(s.begin(),s.end(),reg4); boost::sregex_iterator end; while (it!=end) std::cout << *it++; } ``` 你給出答案了嗎？輸出是 "`02468`"，即所有偶數數字。注意，這個字符類別不僅匹配偶數數字，如果輸入字符串是 "`AlfaBetaGamma`"，那么也會全部匹配。我們看到的這個元字符, `^`, 還有另一個意思。它可以用來表示一行的開始。而元字符 `$` 則表示一行的結束。 ### 錯的正則表達式一個錯的正則表達式就是一個不遵守規則的正則表達式。例如，你可能忘了一個右括號，這樣正則表達式引擎將無法成功編譯這個正則表達式。這時，將拋出一個 `bad_expression` 類型的異常。正如我前面提到的，這個異常的名字將會在下一版本的Boost.Regex中被修改，還有在即將加入Library Technical Report的版本中也是。異常類型 `bad_expression` 將被更名為 `regex_error`. 如果你的應用程序中的正則表達式全都是硬編碼的，你可能不用處理錯誤表達式，但如果你是接受了用戶的輸入來作為正則表達式，你就必須準備進行錯誤處理。這里有一個程序，提示用戶輸入一個正則表達式，接著輸入一個用來對正則表達式進行匹配的字符串。由用戶進行輸入時，總是有可能會導致無效的輸入。 ``` int main() { std::cout << "Enter a regular expression:\n"; std::string s; std::getline(std::cin, s); try { boost::regex reg(s); std::cout << "Enter a string to be matched:\n"; std::getline(std::cin,s); if (boost::regex_match(s,reg)) std::cout << "That's right!\n"; else std::cout << "No, sorry, that doesn't match.\n"; } catch(const boost::bad_expression& e) { std::cout << "That's not a valid regular expression! (Error: " << e.what() << ") Exiting...\n"; } } ``` 為了保護應用程序和用戶，一個 `try`/`catch` 塊用于處理構造時拋出 `boost::regex` 的情形，這時會打印一個提示信息，而程序會溫和地退出。用這個程序來測試，我們開始時輸入一些合理的數據。 ``` Enter a regular expression: \d{5} Enter a string to be matched: 12345 That's right! ``` 現在，給一些錯誤的數據，試著輸入一個錯誤的正則表達式。 ``` Enter a regular expression: (\w*)) That's not a valid regular expression! (Error: Unmatched ( or \() Exiting... ``` 在`regex reg`構造時，就會拋出一個異常，因為這個正則表達式不能被編譯。因此，進入到 `catch` 的處理例程中，程序將打印一個錯誤信息并退出。你只需知道有三個可能會發生異常的地方。一個是在構造一個正則表達式時，就象你剛剛看到的那樣；另一個是使用成員函數 `assign` 把正則表達式賦給一個 `regex` 時。最后一個是，regex迭代器和算法也可能拋出異常，如果內存不夠或者匹配的復雜度過快增長的話。