regex_search . Boost , Boost.Regex 5.1.2 , Reference

regex_search

#include <boost/regex.hpp>

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

template <class BidirectionalIterator,
         class Allocator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
                  match_results<BidirectionalIterator, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);
template <class ST, class SA,
         class Allocator, class charT, class traits>
bool regex_search(const basic_string<charT, ST, SA>& s,
                  match_results<
                  typename basic_string<charT, ST,SA>::const_iterator,
                  Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);
template<class charT, class Allocator, class traits>
bool regex_search(const charT* str,
                  match_results<const charT*, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);
template <class BidirectionalIterator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);
template <class charT, class traits>
bool regex_search(const charT* str,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);
template<class ST, class SA, class charT, class traits>
bool regex_search(const basic_string<charT, ST, SA>& s,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);

Description

template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
                  match_results<BidirectionalIterator, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);

Требуется: Двунаправленный итератор соответствует требованиям двухнаправленного итератора (24.1.4).

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

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

Постусловия: Если функция возвращается ложной, то влияние на параметрмне определено, иначе эффекты на параметрмприведены в таблице:

Элемент	ценность
<`m.size()`>	<`1+ e.mark_count()`>
<`m.empty()`>	<`false`>
<`m.prefix().first`>	<`first`>
<`m.prefix().last`>	<`m[0].first`>
<`m.prefix().matched`>	<`m.prefix().first!= m.prefix().second`>
<`m.suffix().first`>	<`m[0].second`>
<`m.suffix().last`>	<`last`>
<`m.suffix().matched`>	<`m.suffix().first!= m.suffix().second`>
<`m[0].first`>	Начало последовательности символов, соответствующих регулярному выражению
<`m[0].second`>	Конец последовательности символов, соответствующих регулярному выражению
<`m[0].matched`>	истинно, если был найден полный матч, и ложно, если это был частичный матч (найден в результате матча_частичный флаг устанавливается).
<`m[n].first`>	Для всех целых чисел<`n<m.size()`>начало последовательности, которая соответствовала субэкспрессииn. Альтернативно, если в матче не участвовало подвыражениеn, то последнее.
<`m[n].second`>	Для всех целых чисел<`n<m.size()`>конец последовательности, которая соответствовала субэкспрессииn. Альтернативно, если в матче не участвовало подвыражениеn, то<`last`> .
<`m[n].matched`>	Для всех целых чисел<`n<m.size()`>истинно, если в матче участвовало подвыражениеn, ложное иначе.

template <class charT, class Allocator, class traits>
bool regex_search(const charT* str, match_results<const charT*, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);

Эффекты: Возвращает результат<regex_search(str,str +char_traits<charT>::length(str), m,e,flags)>.

template <class ST, class SA, class Allocator, class charT,
         class traits>
bool regex_search(const basic_string<charT, ST, SA>& s,
                  match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);

Эффекты: Возвращает результат<regex_search(s.begin(),s.end(),m,e,flags)>.

template <class iterator, class charT, class traits>
bool regex_search(iterator first, iterator last,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);

Эффекты: Поступайте так, как если бы вы построили экземпляр<match_results<BidirectionalIterator>what>, а затем вернули результат<regex_search(first,last,what,e, flags)>.

template <class charT, class traits>
bool regex_search(const charT* str
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);

Эффекты: Возвращает результат<regex_search(str,str +char_traits<charT>::length(str), e,flags)>.

template <class ST, class SA, class charT, class traits>
bool regex_search(const basic_string<charT, ST, SA>& s,
                  const basic_regex<charT, traits>& e,
                  match_flag_type flags = match_default);

Эффекты: Возвращает результат<regex_search(s.begin(),s.end(),e,flags)>.

Examples

В следующем примере, берет содержимое файла в виде строки и ищет все объявления класса C++ в файле. Код будет работать независимо от способа реализации<std::string>, например, его можно легко модифицировать для работы с классом веревок SGI, который использует стратегию непрерывного хранения.

#include <string>
#include <map>
#include <boost/regex.hpp>
// 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, int, std::less<std::string> > map_type;
boost::regex expression(
   "^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
   "(class|struct)[[:space:]]*"
   "(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?"
   "[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*"
   "(<[^;:{]+>[[:space:]]*)?(\\{|:[^;\\{()]*\\{)");
void IndexClasses(map_type& m, const std::string& file)
{
   std::string::const_iterator start, end;
   start = file.begin();
   end = file.end();
      boost::match_results<std::string::const_iterator> what;
   boost::match_flag_type flags = boost::match_default;
   while(regex_search(start, end, what, expression, flags))
   {
      // 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: 
      m[std::string(what[5].first, what[5].second)
            + std::string(what[6].first, what[6].second)]
         = what[5].first - file.begin();
      // update search position: 
      start = what[0].second;
      // update flags: 
      flags |= boost::match_prev_avail;
      flags |= boost::match_not_bob;
   }
}

Статья regex_search раздела Boost.Regex 5.1.2 Reference может быть полезна для разработчиков на c++ и boost.

regex_search

Boost , Boost.Regex 5.1.2 , Reference

Boost C++ Libraries

regex_search

Description

Examples