Boost C++ Libraries

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:

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 <class charT, class T, class A>
bool regex_match(
   const ATL::CSimpleStringT<charT>& s,
   match_results<const B*, A>& what,
   const basic_regex<charT, T>& 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");
   }
}

regex_match (second overload)

template <class charT, class T>
bool regex_match(
   const ATL::CSimpleStringT<charT>& s,
   const basic_regex<B, T>& 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));
}

regex_search

There are two additional overloads for regex_search, the first reports what matched the second does not:

template <class charT, class A, class T>
bool regex_search(const ATL::CSimpleStringT<charT>& s,
                  match_results<const charT*, A>& what,
                  const basic_regex<charT, T>& 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");
   }
}

regex_search (second overload)

template <class charT, class T>
inline bool regex_search(const ATL::CSimpleStringT<charT>& s,
               const basic_regex<charT, T>& 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);

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 <class OutputIterator, class BidirectionalIterator, class traits, class
         charT>
OutputIterator regex_replace(OutputIterator out,
                           BidirectionalIterator first,
                           BidirectionalIterator last,
                           const basic_regex<charT, traits>& e,
                           const ATL::CSimpleStringT<charT>& fmt,
                           match_flag_type flags = match_default)

Effects: returns ::boost::regex_replace(out, first, last, e, fmt.GetString(), flags);

template <class traits, charT>
ATL::CSimpleStringT<charT> regex_replace(const ATL::CSimpleStringT<charT>& s,
                           const basic_regex<charT, traits>& e,
                           const ATL::CSimpleStringT<charT>& 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);
}