[/ Copyright 2006-2007 John Maddock. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt). ] [section:mfc_strings Using Boost Regex With MFC Strings] [section:mfc_intro Introduction to Boost.Regex and MFC Strings] The header `` provides Boost.Regex support for MFC string types: note that this support requires Visual Studio .NET (Visual C++ 7) or later, where all of the MFC and ATL string types are based around the CSimpleStringT class template. In the following documentation, whenever you see CSimpleStringT, then you can substitute any of the following MFC/ATL types (all of which inherit from CSimpleStringT): CString CStringA CStringW CAtlString CAtlStringA CAtlStringW CStringT CFixedStringT CSimpleStringT [endsect] [section:mfc_regex_types Regex Types Used With MFC Strings] The following typedefs are provided for the convenience of those working with TCHAR's: typedef basic_regex tregex; typedef match_results tmatch; typedef regex_iterator tregex_iterator; typedef regex_token_iterator tregex_token_iterator; If you are working with explicitly narrow or wide characters rather than TCHAR, then use the regular Boost.Regex types `regex` and `wregex` instead. [endsect] [section:mfc_regex_create Regular Expression Creation From an MFC String] The following helper function is available to assist in the creation of a regular expression from an MFC/ATL string type: template basic_regex make_regex(const ATL::CSimpleStringT& s, ::boost::regex_constants::syntax_option_type f = boost::regex_constants::normal); [*Effects]: returns `basic_regex(s.GetString(), s.GetString() + s.GetLength(), f);` [endsect] [section:mfc_algo Overloaded Algorithms For MFC String Types] For each regular expression algorithm that's overloaded for a `std::basic_string` argument, there is also one overloaded for the MFC/ATL string types. These algorithm signatures all look a lot more complex than they actually are, but for completeness here they are anyway: [h4 regex_match] There are two overloads, the first reports what matched in a match_results structure, the second does not. All the usual caveats for [regex_match] apply, in particular the algorithm will only report a successful match if all of the input text matches the expression, if this isn't what you want then use [regex_search] instead. template bool regex_match( const ATL::CSimpleStringT& s, match_results& what, const basic_regex& e, boost::regex_constants::match_flag_type f = boost::regex_constants::match_default); [*Effects]: returns `::boost::regex_match(s.GetString(), s.GetString() + s.GetLength(), what, e, f);` [*Example:] // // Extract filename part of a path from a CString and return the result // as another CString: // CString get_filename(const CString& path) { boost::tregex r(__T("(?:\\A|.*\\\\)([^\\\\]+)")); boost::tmatch what; if(boost::regex_match(path, what, r)) { // extract $1 as a CString: return CString(what[1].first, what.length(1)); } else { throw std::runtime_error("Invalid pathname"); } } [h4 regex_match (second overload)] template bool regex_match( const ATL::CSimpleStringT& s, const basic_regex& e, boost::regex_constants::match_flag_type f = boost::regex_constants::match_default) [*Effects]: returns `::boost::regex_match(s.GetString(), s.GetString() + s.GetLength(), e, f);` [*Example:] // // Find out if *password* meets our password requirements, // as defined by the regular expression *requirements*. // bool is_valid_password(const CString& password, const CString& requirements) { return boost::regex_match(password, boost::make_regex(requirements)); } [h4 regex_search] There are two additional overloads for [regex_search], the first reports what matched the second does not: template bool regex_search(const ATL::CSimpleStringT& s, match_results& what, const basic_regex& e, boost::regex_constants::match_flag_type f = boost::regex_constants::match_default) [*Effects]: returns ::boost::regex_search(s.GetString(), s.GetString() + s.GetLength(), what, e, f); [*Example]: Postcode extraction from an address string. CString extract_postcode(const CString& address) { // searches throw address for a UK postcode and returns the result, // the expression used is by Phil A. on www.regxlib.com: boost::tregex r(__T("^(([A-Z]{1,2}[0-9]{1,2})|([A-Z]{1,2}[0-9][A-Z]))\\s?([0-9][A-Z]{2})$")); boost::tmatch what; if(boost::regex_search(address, what, r)) { // extract $0 as a CString: return CString(what[0].first, what.length()); } else { throw std::runtime_error("No postcode found"); } } [h4 regex_search (second overload)] template inline bool regex_search(const ATL::CSimpleStringT& s, const basic_regex& e, boost::regex_constants::match_flag_type f = boost::regex_constants::match_default) [*Effects]: returns `::boost::regex_search(s.GetString(), s.GetString() + s.GetLength(), e, f);` [h4 regex_replace] There are two additional overloads for [regex_replace], the first sends output to an output iterator, while the second creates a new string template OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, const basic_regex& e, const ATL::CSimpleStringT& fmt, match_flag_type flags = match_default) [*Effects]: returns `::boost::regex_replace(out, first, last, e, fmt.GetString(), flags);` template ATL::CSimpleStringT regex_replace(const ATL::CSimpleStringT& s, const basic_regex& e, const ATL::CSimpleStringT& fmt, match_flag_type flags = match_default) [*Effects]: returns a new string created using [regex_replace], and the same memory manager as string /s/. [*Example]: // // Take a credit card number as a string of digits, // and reformat it as a human readable string with "-" // separating each group of four digits: // const boost::tregex e(__T("\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z")); const CString human_format = __T("$1-$2-$3-$4"); CString human_readable_card_number(const CString& s) { return boost::regex_replace(s, e, human_format); } [endsect] [section:mfc_iter Iterating Over the Matches Within An MFC String] The following helper functions are provided to ease the conversion from an MFC/ATL string to a [regex_iterator] or [regex_token_iterator]: [h4 regex_iterator creation helper] template regex_iterator make_regex_iterator( const ATL::CSimpleStringT& s, const basic_regex& e, ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default); [*Effects]: returns `regex_iterator(s.GetString(), s.GetString() + s.GetLength(), e, f);` [*Example]: void enumerate_links(const CString& html) { // enumerate and print all the links in some HTML text, // the expression used is by Andew Lee on www.regxlib.com: boost::tregex r( __T("href=[\"\']((http:\\/\\/|\\.\\/|\\/)?\\w+" "(\\.\\w+)*(\\/\\w+(\\.\\w+)?)*" "(\\/|\\?\\w*=\\w*(&\\w*=\\w*)*)?)[\"\']")); boost::tregex_iterator i(boost::make_regex_iterator(html, r)), j; while(i != j) { std::cout << (*i)[1] << std::endl; ++i; } } [h4 regex_token_iterator creation helpers] template regex_token_iterator make_regex_token_iterator( const ATL::CSimpleStringT& s, const basic_regex& e, int sub = 0, ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default); [*Effects]: returns `regex_token_iterator(s.GetString(), s.GetString() + s.GetLength(), e, sub, f);` template regex_token_iterator make_regex_token_iterator( const ATL::CSimpleStringT& s, const basic_regex& e, const std::vector& subs, ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default); [*Effects]: returns `regex_token_iterator(s.GetString(), s.GetString() + s.GetLength(), e, subs, f);` template regex_token_iterator make_regex_token_iterator( const ATL::CSimpleStringT& s, const basic_regex& e, const int (& subs)[N], ::boost::regex_constants::match_flag_type f = boost::regex_constants::match_default); [*Effects]: returns `regex_token_iterator(s.GetString(), s.GetString() + s.GetLength(), e, subs, f);` [*Example]: void enumerate_links2(const CString& html) { // enumerate and print all the links in some HTML text, // the expression used is by Andew Lee on www.regxlib.com: boost::tregex r( __T("href=[\"\']((http:\\/\\/|\\.\\/|\\/)?\\w+" "(\\.\\w+)*(\\/\\w+(\\.\\w+)?)*" "(\\/|\\?\\w*=\\w*(&\\w*=\\w*)*)?)[\"\']")); boost::tregex_token_iterator i(boost::make_regex_token_iterator(html, r, 1)), j; while(i != j) { std::cout << *i << std::endl; ++i; } } [endsect] [endsect]