Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

sub_match

Boost , Boost.Regex 5.1.2 , Reference

Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext 
#include <boost/regex.hpp>

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

Объекты типа<sub_match>могут быть получены только путем подписки объекта типа.<match_results>.

Объекты типа<sub_match>можно сравнить с объектами типа<std::basic_string>, или<constcharT*>, или<const charT>.

Объекты типа<sub_match>могут быть добавлены к объектам типа<std::basic_string>или<constcharT*>или<const charT>для получения нового<std::basic_string>объекта.

Когда обозначенное подвыражение обозначается объектом типа<sub_match>участвовал в матче регулярного выражения, затем член, соответствующий, оцениваетистинно, а членысначалаивторойобозначают диапазон символов [первый, второй], которые сформировали этот матч. В противном случаеявляетсяложным, и членыпервогоивторогосодержат неопределенные значения.

Когда обозначенное подвыражение, обозначаемое объектом типа<sub_match>, повторялось, то объект<sub_match>представляет собой совпадение, полученное последнимповтором. Полный набор всех захватов, полученных для всех повторов, может быть доступен через функцию захвата (примечание: это имеет серьезные последствия для производительности, вы должны явно включить эту функцию).

Если объект типа<sub_match>представляет подвыражение 0 — то есть весь матч — то член, совпадающий, всегдаистинный, если толькочастичное совпадениене было получено в результате передачи флага<match_partial>алгоритму регулярного выражения, и в этом случае член, совпадающий, являетсяложным, а членысначалаивторойпредставляют диапазон символов, которые сформировали частичное совпадение.

namespace boost{
template <class BidirectionalIterator>
class sub_match;
typedef sub_match<const char*>                    csub_match;
typedef sub_match<const wchar_t*>                 wcsub_match;
typedef sub_match<std::string::const_iterator>    ssub_match;
typedef sub_match<std::wstring::const_iterator>   wssub_match;
template <class BidirectionalIterator>
class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator>
{
public:
   typedef typename iterator_traits<BidirectionalIterator>::value_type       value_type;
   typedef typename iterator_traits<BidirectionalIterator>::difference_type  difference_type;
   typedef          BidirectionalIterator                                    iterator;
   bool matched;
   difference_type length()const;
   operator basic_string<value_type>()const;
   basic_string<value_type> str()const;
   int compare(const sub_match& s)const;
   int compare(const basic_string<value_type>& s)const;
   int compare(const value_type* s)const;
#ifdef BOOST_REGEX_MATCH_EXTRA
   typedef implementation-private capture_sequence_type;
   const capture_sequence_type& captures()const;
#endif
};
//
// comparisons to another sub_match:
//
template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);
//
// comparisons to a basic_string:
//
template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);
//
// comparisons to a pointer to a character array:
//
template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
//
// comparisons to a single character:
//
template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
// 
// addition operators: 
//
template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s,
               const sub_match<BidirectionalIterator>& m);
template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const sub_match<BidirectionalIterator>& m,
               const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s,
               const sub_match<BidirectionalIterator>& m);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const * s);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s,
               const sub_match<BidirectionalIterator>& m);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const& s);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m1,
               const sub_match<BidirectionalIterator>& m2);
//
// stream inserter:
//
template <class charT, class traits, class BidirectionalIterator>
basic_ostream<charT, traits>&
   operator << (basic_ostream<charT, traits>& os,
               const sub_match<BidirectionalIterator>& m);
} // namespace boost
Description
Members 
typedef typename std::iterator_traits<iterator>::value_type value_type;

Тип, на который указывают итераторы.

typedef typename std::iterator_traits<iterator>::difference_type difference_type;

Тип, который представляет собой разницу между двумя итераторами.

typedef BidirectionalIterator iterator;

Тип итератора.

iterator first

Итератор, обозначающий позицию начала матча.

iterator second

Итератор, обозначающий позицию конца матча.

bool matched

Булево значение, обозначающее, участвовало ли это подвыражение в матче.

static difference_type length();

Эффекты: Возвращает длину этого сопоставленного подвыражения, или 0, если это подвыражение не было сопоставлено:<matched?distance(first,second):0)>.

operator basic_string<value_type>()const;

Эффекты: преобразует<*this>в строку: возвращает<(matched?basic_string<value_type>(first,second):basic_string<value_type>())>.

basic_string<value_type> str()const;

Эффекты: В этом случае он возвращает строку<*this>:<(matched ?basic_string<value_type>(first,second):basic_string<value_type>())>.

int compare(const sub_match& s)const;

Эффекты: выполняет лексическое сравнение сs: возвращается<str().compare(s.str())>.

int compare(const basic_string<value_type>& s)const;

Эффекты: сравнивает<*this>со строкойs: возвращается<str().compare(s)>.

int compare(const value_type* s)const;

Эффекты: сравнивает<*this>с нулевой струнойs: возвращается<str().compare(s)>.

typedef implementation-private capture_sequence_type;

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

const capture_sequence_type& captures()const;

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

Предпосылки: библиотека должна быть построена и использована с определением BOOST_REGEX_MATCH_EXTRA, и вы должны передать флаг<match_extra>функциям соответствия регексу<regex_match>,<regex_search>,<regex_iterator>или<regex_token_iterator>, чтобы определить эту функцию члена и вернуть полезную информацию.

Обоснование: Включение этой функции имеет несколько последствий:

  • sub_match занимает больше памяти, что приводит к тому, что сложные выражения заканчиваются из памяти или пространства стека быстрее во время сопоставления.
  • Алгоритмы сопоставления менее эффективны при обработке некоторых функций (например, независимых подвыражений), даже если match_extra не используется.
  • Алгоритмы сопоставления гораздо менее эффективны (то есть медленнее), когда используется match_extra. В основном это связано с дополнительными выделениями памяти, которые должны иметь место.
sub_match non-member operators 
template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs.compare(rhs) ==0>.

template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs.compare(rhs) !=0>.

template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs.compare(rhs) <0>.

template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs.compare(rhs) <=0>.

template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs.compare(rhs) >=0>.

template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs.compare(rhs) >0>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                                          traits,
                                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs ==rhs.str()>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                                          traits,
                                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs !=rhs.str()>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                         traits,
                                         Allocator>& lhs,
                 const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs <rhs.str()>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                                         traits,
                                                         Allocator>& lhs,
                 const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs >rhs.str()>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs >=rhs.str()>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs <=rhs.str()>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Эффекты: возвраты<lhs.str() ==rhs>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Эффекты: возврат<lhs.str() !=rhs>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);

Эффекты: возвраты<lhs.str() <rhs>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
                 const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                         traits,
                                         Allocator>& rhs);

Эффекты: возврат<lhs.str() >rhs>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Эффекты: возврат<lhs.str() >=rhs>.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Эффекты: возврат<lhs.str() <=rhs>.

template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs ==rhs.str()>.

template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs !=rhs.str()>.

template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs <rhs.str()>.

template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs >rhs.str()>.

template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs >=rhs.str()>.

template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs <=rhs.str()>.

template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Эффекты: возвраты<lhs.str() ==rhs>.

template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Эффекты: возврат<lhs.str() !=rhs>.

template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Эффекты: возвраты<lhs.str() <rhs>.

template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Эффекты: возврат<lhs.str() >rhs>.

template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Эффекты: возврат<lhs.str() >=rhs>.

template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Эффекты: возврат<lhs.str() <=rhs>.

template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs ==rhs.str()>.

template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs !=rhs.str()>.

template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs <rhs.str()>.

template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs >rhs.str()>.

template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возврат<lhs >=rhs.str()>.

template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Эффекты: возвраты<lhs <=rhs.str()>.

template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Эффекты: возвраты<lhs.str() ==rhs>.

template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Эффекты: возврат<lhs.str() !=rhs>.

template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Эффекты: возвраты<lhs.str() <rhs>.

template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Эффекты: возврат<lhs.str() >rhs>.

template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Эффекты: возврат<lhs.str() >=rhs>.

template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Эффекты: возврат<lhs.str() <=rhs>.

Операторы сложения для<sub_match>позволяют добавлять<sub_match>к любому типу, к которому можно добавить<std::string>и получить в результате новую строку.

template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s,
               const sub_match<BidirectionalIterator>& m);

Эффекты: возвраты<s +m.str()>.

template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const sub_match<BidirectionalIterator>& m,
               const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s);

Эффекты: возвраты<m.str() +s>.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s,
               const sub_match<BidirectionalIterator>& m);

Эффекты: возвраты<s +m.str()>.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const * s);

Эффекты: возвраты<m.str() +s>.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s,
               const sub_match<BidirectionalIterator>& m);

Эффекты: возвраты<s +m.str()>.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const& s);

Эффекты: возвраты<m.str() +s>.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m1,
               const sub_match<BidirectionalIterator>& m2);

Эффекты: возвраты<m1.str() +m2.str()>.

Stream inserter 
template <class charT, class traits, class BidirectionalIterator>
basic_ostream<charT, traits>&
   operator << (basic_ostream<charT, traits>& os
               const sub_match<BidirectionalIterator>& m);

Эффекты: возврат<(os<<m.str())>.

Copyright © 1998-2013 John Maddock

Распространяется под лицензией Boost Software License, версия 1.0. (См. сопроводительный файл LICENSE_1_0.txt или копию на) http://www.boost.org/LICENSE_1_0.txt
PrevUpHomeNext

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




Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.


:: Главная :: Reference ::

реклама
©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 19:33:53/0.011944055557251/0