Throws: std::runtime_error если сложность сопоставления выражения с строкой N начинает превышать O(N²), или если программа выходит из стека пространства при сопоставлении выражения (если Boost). Regex настроена в рекурсивном режиме), или если спикер исчерпал свое разрешенное распределение памяти (если увеличить. Regex настроен в нерекурсивном режиме).

regex_iterator(const regex_iterator& that);

Следы: строит копию что.

Почтовые условия: *это == это.

regex_iterator& operator=(const regex_iterator&);

Effects: sets * this equal to those in that.

Почтовые условия: *это = это.

bool operator==(const regex_iterator& that)const;

Effects: возвратится, если *это равно этому.

bool operator!=(const regex_iterator&)const;

Следы: возврат !(*это == это).

const value_type& operator*()const;

Effects: dereferencing a regex_iterator объект, который дает ссылку на match_results объект, члены которого установлены следующим образом:

const value_type* operator->()const;

Effects: returns &(*This).

regex_iterator& operator++();

Effects: перемещает итератор на следующий матч в основной последовательности или конец итератора последовательности, если он не найден. Когда последний матч сопоставлен с нулевой длиной строки, то regex_iterator найдет следующий матч следующим: если есть ненулевой матч длиной, который начинается в том же месте, что и последний, то возвращает его, иначе начинает искать следующий (возможно, нулевая длина) матч от одной позиции к правому от последнего.

Throws: std::runtime_error если сложность сопоставления выражения с строкой N начинает превышать O(N²), или если программа выходит из стека пространства при сопоставлении выражения (если Boost). Regex настроена в рекурсивном режиме), или если спикер исчерпал свое разрешенное распределение памяти (если увеличить. Regex настроен в нерекурсивном режиме).

Возвращения: *это.

regex_iterator operator++(int);

Эффекты: конструирует результат копии *<37>это, затем вызывает ++(*это).

Возвращения: результат.

template <class charT, class traits>
regex_iterator<const charT*, charT, traits>
   make_regex_iterator(const charT* p, const basic_regex<charT, traits>& e,
                     regex_constants::match_flag_type m = regex_constants::match_default);
template <class charT, class traits, class ST, class SA>
regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>
   make_regex_iterator(const std::basic_string<charT, ST, SA>& p,
                     const basic_regex<charT, traits>& e,
                     regex_constants::match_flag_type m = regex_constants::match_default);

Effects: возвращает итератор, который перечисляет все случаи выражения e в тексте p, используя match_flag_type m.

Examples

Следующий пример берет исходный файл C++ и создает индекс названий классов, а также местоположение этого класса в файле.

#include <string>
#include <map>
#include <fstream>
#include <iostream>
#include <boost/regex.hpp>
using namespace std;
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, std::string::difference_type, std::less<std::string> > map_type;
const char* re =
   // possibly leading whitespace:   
   "^[[:space:]]*"
   // possible template declaration:
   "(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
   // class or struct:
   "(class|struct)[[:space:]]*"
   // leading declspec macros etc:
   "("
      "\\<\\w+\\>"
      "("
         "[[:blank:]]*\\([^)]*\\)"
      ")?"
      "[[:space:]]*"
   ")*"
   // the class name
   "(\\<\\w*\\>)[[:space:]]*"
   // template specialisation parameters
   "(<[^;:{]+>)?[[:space:]]*"
   // terminate in { or :
   "(\\{|:[^;\\{()]*\\{)";
boost::regex expression(re);
map_type class_index;
bool regex_callback(const boost::match_results<std::string::const_iterator>& what)
{
   // what[0] contains the whole string
   // what[5] contains the class name.
   // what[6] contains the template specialisation if any.
   // add class name and position to map:
   class_index[what[5].str() + what[6].str()] = what.position(5);
   return true;
}
void load_file(std::string& s, std::istream& is)
{
   s.erase();
   s.reserve(is.rdbuf()->in_avail());
   char c;
   while(is.get(c))
   {
      if(s.capacity() == s.size())
         s.reserve(s.capacity() * 3);
      s.append(1, c);
   }
}
int main(int argc, const char** argv)
{
   std::string text;
   for(int i = 1; i < argc; ++i)
   {
      cout << "Processing file " << argv[i] << endl;
      std::ifstream fs(argv[i]);
      load_file(text, fs);
      // construct our iterators:
      boost::sregex_iterator m1(text.begin(), text.end(), expression);
      boost::sregex_iterator m2;
      std::for_each(m1, m2, &regex_callback);
      // copy results:
      cout << class_index.size() << " matches found" << endl;
      map_type::iterator c, d;
      c = class_index.begin();
      d = class_index.end();
      while(c != d)
      {
         cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
         ++c;
      }
      class_index.erase(class_index.begin(), class_index.end());
   }
   return 0;
}