match_results . Boost , Boost.Regex 5.1.2 , Reference

match_results

Synopsis

#include <boost/regex.hpp>

Регулярные выражения отличаются от многих простых алгоритмов сопоставления шаблонов тем, что, а также нахождение общего соответствия они также могут производить подэкспрессионные совпадения: каждое подэкспрессия ограничивается в шаблоне парой скобок (...). Должен быть какой-то метод для сообщения о подэкспрессионных матчах пользователю: это достигается путем определения класса match_results, который действует как индексированный набор подэкспрессионных матчей, причем каждый подэкспрессионный матч содержится в объекте типа sub_match.

Класс шаблонов match_results обозначает набор последовательностей символов, представляющих результат соответствия регулярного выражения. Объекты типа match_results передаются алгоритмам regex_match и regex_search и возвращаются итератором regex_iterator. Хранение для коллекции выделяется и освобождается по мере необходимости функциями-членами класса match_results.

Класс шаблонов match_results соответствует требованиям последовательности, как указано в (lib.sequence.reqmts), за исключением того, что поддерживаются только операции, определенные для конст-квалифицированных последовательностей.

Шаблон класса match_results чаще всего используется в качестве одного из типдефов cmatch, wcmatch, smatch или wsmatch:

template <class BidirectionalIterator,
         class Allocator = std::allocator<sub_match<BidirectionalIterator> >
class match_results;
typedef match_results<const char*>              cmatch;
typedef match_results<const wchar_t*>           wcmatch;
typedef match_results<string::const_iterator>   smatch;
typedef match_results<wstring::const_iterator>  wsmatch;
template <class BidirectionalIterator,
         class Allocator = std::allocator<sub_match<BidirectionalIterator> >
class match_results
{
public:
   typedef          sub_match<BidirectionalIterator>                        value_type;
   typedef          const value_type&                                       const_reference;
   typedef          const_reference                                         reference;
   typedef          implementation defined                                  const_iterator;
   typedef          const_iterator                                          iterator;
   typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
   typedef typename Allocator::size_type                                    size_type;
   typedef          Allocator                                               allocator_type;
   typedef typename iterator_traits<BidirectionalIterator>::value_type      char_type;
   typedef          basic_string<char_type>                                 string_type;
   // construct/copy/destroy:
   explicit match_results(const Allocator& a = Allocator());
   match_results(const match_results& m);
   match_results& operator=(const match_results& m);
   ~match_results();
   // size:
   size_type size() const;
   size_type max_size() const;
   bool empty() const;
   // element access:
   difference_type length(int sub = 0) const;
   difference_type length(const char_type* sub) const;
   template <class charT>
   difference_type length(const charT* sub) const;
   template <class charT, class Traits, class A>
   difference_type length(const std::basic_string<charT, Traits, A>& sub) const;
   difference_type position(unsigned int sub = 0) const;
   difference_type position(const char_type* sub) const;
   template <class charT>
   difference_type position(const charT* sub) const;
   template <class charT, class Traits, class A>
   difference_type position(const std::basic_string<charT, Traits, A>& sub) const;
   string_type str(int sub = 0) const;
   string_type str(const char_type* sub)const;
   template <class Traits, class A>
   string_type str(const std::basic_string<char_type, Traits, A>& sub)const;
   template <class charT>
   string_type str(const charT* sub)const;
   template <class charT, class Traits, class A>
   string_type str(const std::basic_string<charT, Traits, A>& sub)const;
   const_reference operator[](int n) const;
   const_reference operator[](const char_type* n) const;
   template <class Traits, class A>
   const_reference operator[](const std::basic_string<char_type, Traits, A>& n) const;
   template <class charT>
   const_reference operator[](const charT* n) const;
   template <class charT, class Traits, class A>
   const_reference operator[](const std::basic_string<charT, Traits, A>& n) const;
   const_reference prefix() const;
   const_reference suffix() const;
   const_iterator begin() const;
   const_iterator end() const;
   // format:
   template <class OutputIterator, class Formatter>
   OutputIterator format(OutputIterator out,
                        Formatter fmt,
                        match_flag_type flags = format_default) const;
   template <class Formatter>
   string_type format(Formatter fmt,
                     match_flag_type flags = format_default) const;
   allocator_type get_allocator() const;
   void swap(match_results& that);
#ifdef BOOST_REGEX_MATCH_EXTRA
   typedef typename value_type::capture_sequence_type capture_sequence_type;
   const capture_sequence_type& captures(std::size_t i)const;
#endif
};
template <class BidirectionalIterator, class Allocator>
bool operator == (const match_results<BidirectionalIterator, Allocator>& m1,
                  const match_results<BidirectionalIterator, Allocator>& m2);
template <class BidirectionalIterator, class Allocator>
bool operator != (const match_results<BidirectionalIterator, Allocator>& m1,
                  const match_results<BidirectionalIterator, Allocator>& m2);
template <class charT, class traits, class BidirectionalIterator, class Allocator>
basic_ostream<charT, traits>&
   operator << (basic_ostream<charT, traits>& os,
               const match_results<BidirectionalIterator, Allocator>& m);
template <class BidirectionalIterator, class Allocator>
void swap(match_results<BidirectionalIterator, Allocator>& m1,
         match_results<BidirectionalIterator, Allocator>& m2);

Description

Во всех конструкторах match_results используется копия аргумента Аллокатора для любого выделения памяти, выполняемого конструктором или функциями-членами в течение срока службы объекта.

match_results(const Allocator& a = Allocator());

Эффекты: Построение объекта класса Матч_результаты. Постусловия этой функции указаны в таблице:

Элемент	Ценность
пустой()	правда
размер()	0
стр()	basic_string()

match_results(const match_results& m);

Последствия: Построение объекта класса match_results, как копия m.

match_results& operator=(const match_results& m);

Последствия: Назначает m на *это. Постусловия этой функции указаны в таблице:

Элемент	Ценность
пустой()	m.empty().
размер()	m.size().
str(n)	m.str(n) для всех целых чисел n < m.size().
префикс()	m.prefix().
суффикс()	m.suffix().
(*это)[n]	m[n] для всех целых чисел n < m.size().
длина(n)	m.length(n) для всех целых чисел n < m.size().
положение(n)	m.position(n) для всех целых чисел n < m.size().

size_type size()const;

Эффекты: возвращает число sub_match элементов, сохраненных в *это; то есть количество отмеченных подвыражений в обычном выражении, которое было сопоставлено плюс один.

size_type max_size()const;

Эффекты: возвращает максимальное количество sub_match элементов, которые могут быть сохранены в *это.

bool empty()const;

Последствия: Размер возврата() == 0.

difference_type length(int sub = 0)const;
difference_type length(const char_type* sub)const;
template <class charT>
difference_type length(const charT* sub)const;
template <class charT, class Traits, class A>
difference_type length(const std::basic_string<charT, Traits, A>&)const;

Требуется : чтобы объект результатов матча был инициализирован в результате успешного вызова regex_search или regex_match или был возвращен из regex_iterator, и чтобы лежащие в его основе итераторы впоследствии не были признаны недействительными. Поднимет std::logic_error, если объект результатов матча не был инициализирован.

Эффекты: Возвращает длину подвыражения sub, то есть: (*this)[sub].длина().

Перегрузки, которые принимают строку, относятся к названному подвыражению n. В том случае, если такого подвыражения нет, то возвращается ноль.

Шаблонные перегрузки этой функции позволяют строке и/или типу символа отличаться от типа символа базовой последовательности и/или регулярного выражения: в этом случае символы будут расширены до основного типа символа исходного регулярного выражения. Ошибка компилятора произойдет, если аргумент пройдет более широкий тип символа, чем базовая последовательность. Эти перегрузки позволяют использовать в качестве аргумента обычную узкую строку символа C, даже если базовый тип символа соответствующего выражения может быть чем-то более экзотическим, таким как тип символа Unicode.

difference_type position(unsigned int sub = 0)const;
difference_type position(const char_type* sub)const;
template <class charT>
difference_type position(const charT* sub)const;
template <class charT, class Traits, class A>
difference_type position(const std::basic_string<charT, Traits, A>&)const;

Эффекты: возвращает исходное местоположение подвыражения sub или -1, если sub не совпадал. Обратите внимание, что если это представляет собой частичное совпадение, то позиция() вернет местоположение частичного совпадения, даже если (*это)[0].совпадение является ложным.

Перегрузки, которые принимают строку, относятся к названному подвыражению n. В том случае, если нет такого названного подвыражения, то возвращается -1.

string_type str(int sub = 0)const;
string_type str(const char_type* sub)const;
template <class Traits, class A>
string_type str(const std::basic_string<char_type, Traits, A>& sub)const;
template <class charT>
string_type str(const charT* sub)const;
template <class charT, class Traits, class A>
string_type str(const std::basic_string<charT, Traits, A>& sub)const;

Эффекты: Возвращает подвыражение sub в виде строки: string_type(*this)[sub]).

Перегрузки, которые принимают строку, возвращают строку, которая соответствовала названному подвыражению n. В том случае, если такой подэкспрессии нет, то возвращается пустая строка.

const_reference operator[](int n) const;
const_reference operator[](const char_type* n) const;
template <class Traits, class A>
const_reference operator[](const std::basic_string<char_type, Traits, A>& n) const;
template <class charT>
const_reference operator[](const charT* n) const;
template <class charT, class Traits, class A>
const_reference operator[](const std::basic_string<charT, Traits, A>& n) const;

Эффекты: Возвращает ссылку на объект sub_match, представляющий последовательность символов, которая соответствовала отмеченному субвыражению n Если n ==0, то возвращает ссылку на объект sub_match, представляющий последовательность символов, которая соответствовала всему регулярному выражению. Если n находится вне диапазона, или если n является непревзойденным суб-выражением, то возвращается объект sub_match, чей соответствующий элемент является ложным.

Перегрузки, которые принимают строку, возвращают ссылку на объект sub_match, представляющий последовательность символов, которая соответствовала названному субвыражению n. В случае, если нет такого названного подвыражения, то возвращается объект sub_match, соответствующий элемент которого является ложным.

const_reference prefix()const;

Эффекты: Возвращает ссылку на объект sub_match, представляющий последовательность символов от начала сопоставляемой строки до начала найденного матча.

const_reference suffix()const;

Эффекты: Возвращает ссылку на объект sub_match, представляющий последовательность символов от конца матча, найденного до конца строки, подходящей или искомой.

const_iterator begin()const;

Эффекты: возвращает стартовый итератор, который перечисляет все отмеченные подэкспрессионные совпадения, хранящиеся в *это.

const_iterator end()const;

Эффекты: возвращает завершающий итератор, который перечисляет все отмеченные подэкспрессионные совпадения, хранящиеся в *это.

template <class OutputIterator, class Formatter>
OutputIterator format(OutputIterator out,
                      Formatter fmt,
                      match_flag_type flags = format_default);

Требуется : Тип OutputIterator соответствует требованиям Output Iterator (C++ std 24.1.2).

Тип Formatter должен быть либо указателем на нулевую строку типа char_type (например, std::char_string<char_type) или быть унарным, двоичным или троичным функтором, который вычисляет строку замены из вызова функции: либо fmt для использования в качестве замещающего текста, либо char_type (*2>, flags, оба из которых пишут заменяющий текст на , а затем возвращают новую позицию OutputIterator). Обратите внимание, что если формататор является функтором, то он проходит по значению : пользователи, которые хотят передать функциональные объекты с внутренним состоянием, могут захотеть использовать Boost.Ref, чтобы обернуть объект так, чтобы он прошел по ссылке.


 Требуется : чтобы объект результатов матча был инициализирован в результате успешного вызова regex_search или regex_match или был возвращен из regex_iterator, и чтобы лежащие в его основе итераторы впоследствии не были признаны недействительными. Поднимет std::logic_error, если объект результатов матча не был инициализирован.
Effects: Если fmt является либо нулевой строкой, либо контейнером char_type, то копирует последовательность символов fmt.fmt.fmt.end())OutputIteratorout. Для каждого спецификатора формата или последовательности выхода в fmt замените эту последовательность либо символом(ами), который она представляет, либо последовательностью символов в *, к которому она относится. Битмаски, указанные в флагах, определяют, какие спецификаторы формата или последовательности выхода распознаются, по умолчанию это формат, используемый ECMA-262, спецификация языка ECMAScript, глава 15, часть 5.4.11 String.prototype.replace.

Если fmt является объектом функции, то в зависимости от количества аргументов, которые принимает объект функции, он либо:

Вызовите fmt(*this) и скопируйте строку, возвращенную в OutputIteratorout.
Позвоните fmt(*this, out).
Вызовите fmt(*this, out, flags).

Во всех случаях возвращается новое положение OutputIterator.
Смотрите руководство по синтаксису формата  для получения дополнительной информации .
Возврат: out.
template <class Formatter>
string_type format(Formatter fmt,
                   match_flag_type flags = format_default);

 Требуется  Тип char_type, или быть контейнером char_type (например, std::char_string>char_type) или быть унарным, двоичным или троичным функтором, который вычисляет строку замены из вызова функции: либо fmt (*3>out,  flags, а затем возвращает новую позицию OutputIterator).

 Требуется : чтобы объект результатов матча был инициализирован в результате успешного вызова regex_search или regex_match или был возвращен из regex_iterator, и чтобы лежащие в его основе итераторы впоследствии не были признаны недействительными. Поднимет std::logic_error, если объект результатов матча не был инициализирован.
Effects: Если fmt является либо нулевой строкой, либо контейнером char_type, то копии строки fmt: Для каждого спецификатора формата или последовательности выхода в fmt заменяют эту последовательность либо символом(ами), который она представляет, либо последовательностью символов в это, к которому она относится. Битмаски, указанные в флагах, определяют, какие спецификаторы формата или последовательности выхода распознаются, по умолчанию это формат, используемый ECMA-262, спецификация языка ECMAScript, глава 15, часть 5.4.11 String.prototype.replace.
Если fmt является объектом функции, то в зависимости от количества аргументов, которые принимает объект функции, он либо:

Вызовите fmt(*this) и верните результат.
Вызов fmt(*this,-----iterator), где  неуточненный---iteterator, используемый для копирования вывода в результат строки.

Вызов fmt(*this,----iterator, flags), где  неуточненный---iteterator используется для копирования вывода в результат строки.


Смотрите руководство по синтаксису формата  для получения дополнительной информации .
allocator_type get_allocator()const;

 Эффекты: возвращает копию Распределителя, которая была передана конструктору объекта.
void swap(match_results& that);

Последствия: Изменяет содержание двух последовательностей.
Постсостояние: *это содержит последовательность сопоставленных субвыражений, которые были в том, что содержит последовательность сопоставленных субвыражений, которые были в *это.
Комплексность: постоянное время.
typedef typename value_type::capture_sequence_type capture_sequence_type;

Определяет тип реализации, который удовлетворяет требованиям стандартной библиотечной последовательности (21.1.1, включая дополнительные операции Таблицы 68), значение_тип которой представляет собой sub_match<BidirectionalIterator>. Этот тип оказывается std::vector<sub_match<BidirectionalIterator> >, но на это не стоит полагаться.
const capture_sequence_type& captures(std::size_t i)const;

 Требуется : чтобы объект результатов матча был инициализирован в результате успешного вызова regex_search или regex_match или был возвращен из regex_iterator, и чтобы лежащие в его основе итераторы впоследствии не были признаны недействительными. Поднимет std::logic_error, если объект результатов матча не был инициализирован.
 Эффекты: возвращает последовательность, содержащую все захваты, полученные для подвыражения i.
Возврат: (*это)[i].Захваты();
Предпосылки: библиотека должна быть построена и использована с определением BOOST_REGEX_MATCH_EXTRA, и вы должны передать флаг match_extra функциям соответствия regex (regex_match, regex_iterator), чтобы эта функция участника была определена и вернулась полезная информация.
 Обоснование: Включение этой функции имеет несколько последствий:

sub_match занимает больше памяти, что приводит к тому, что сложные выражения заканчиваются из памяти или пространства стека быстрее во время сопоставления.
Алгоритмы сопоставления менее эффективны при обработке некоторых функций (например, независимых подвыражений), даже если match_extra не используется.
Алгоритмы сопоставления гораздо менее эффективны (то есть медленнее), когда используется match_extra. В основном это связано с дополнительными выделениями памяти, которые должны иметь место.

template <class BidirectionalIterator, class Allocator>
bool operator == (const match_results<BidirectionalIterator, Allocator>& m1,
                  const match_results<BidirectionalIterator, Allocator>& m2);

 Эффекты: Сравнение двух последовательностей для равенства.
template <class BidirectionalIterator, class Allocator>
bool operator != (const match_results<BidirectionalIterator, Allocator>& m1,
                  const match_results<BidirectionalIterator, Allocator>& m2);

 Эффекты: Сравнение двух последовательностей для неравенства.
template <class charT, class traits, class BidirectionalIterator, class Allocator>
basic_ostream<charT, traits>&
   operator << (basic_ostream<charT, traits>& os,
               const match_results<BidirectionalIterator, Allocator>& m);

 Эффекты: Записывает содержимое m в поток os, как если бы позвонив os << m(); Возвращает os.
template <class BidirectionalIterator, class Allocator>
void swap(match_results<BidirectionalIterator, Allocator>& m1,
         match_results<BidirectionalIterator, Allocator>& m2);

Последствия: Изменяет содержание двух последовательностей.

match_results

Boost , Boost.Regex 5.1.2 , Reference

Boost C++ Libraries

match_results

Synopsis

Description