Overloaded Algorithms For MFC String Types

| Home | Libraries | People | FAQ | More

##### 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:

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