Для каждого алгоритма регулярного выражения, который перегружен для аргумента<std::basic_string>, есть также один перегруженный для типов строк MFC/ATL. Все эти алгоритмические сигнатуры выглядят намного сложнее, чем они есть на самом деле, но для полноты здесь они все равно:

regex_match

Есть две перегрузки, первая сообщает, что совпало в структуре match_results, вторая — нет.

Применяются все обычные предостережения для<regex_match>, в частности, алгоритм сообщит об успешном совпадении только в том случае, если весь входной текст соответствует выражению, если это не то, что вы хотите, то используйте вместо этого<regex_search>.

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);

Эффекты: возвраты<::boost::regex_match(s.GetString(), s.GetString() +s.GetLength(),what,e,f);>

Пример:

//
// 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)

Эффекты: возвращение<::boost::regex_match(s.GetString(), s.GetString() +s.GetLength(),e,f);>

Пример:

//
// 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

Для<regex_search>есть две дополнительные перегрузки, первая сообщает, что не соответствует второй:

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)

Эффекты: возвращается::boost::regex_search(s.GetString(), s.GetString() + s.GetLength(), что, e, f);

Пример: Извлечение почтового кода из строки адреса.

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)

Эффекты: возврат<::boost::regex_search(s.GetString(), s.GetString() +s.GetLength(),e,f);>

regex_replace

Для<regex_replace>есть две дополнительные перегрузки, первая отправляет выход на выходной итератор, а вторая создает новую строку.

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)

Эффекты: возвращается<::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)

Эффекты: Возвращает новую строку, созданную с использованием<regex_replace>, и тот же менеджер памяти, что и строка.

Пример:

//
// 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);
}