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

basic_regex

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
Synopsis 
#include <boost/regex.hpp>

Класс шаблонов<basic_regex>инкапсулирует регулярный анализ и компиляцию выражений. Класс принимает два шаблонных параметра:

  • <charT>: определяет тип символа, т.е. либо<char>, либо<wchar_t>; см.Концепт чарта.
  • <traits>: определяет поведение типа символа, например, какие имена классов символов распознаются. Предусмотрен класс признаков по умолчанию:<regex_traits<charT>>. См. такжеКонцепт черт.

Для удобства использования есть два типадов, которые определяют два стандартных<basic_regex>экземпляра, если вы не хотите использовать пользовательские классы признаков или нестандартные типы символов (например, см.поддержка Unicode), вам не нужно использовать ничего, кроме этих:

namespace boost{
template <class charT, class traits = regex_traits<charT>  >
class basic_regex;
typedef basic_regex<char>      regex;
typedef basic_regex<wchar_t>   wregex;
}

Определение<basic_regex>следует: оно очень близко основано на классе<basic_string>и удовлетворяет требованиям к постоянному контейнеру<charT>.

namespace boost{
template <class  charT, class traits = regex_traits<charT> >
class basic_regex {
   public:
   // types:
   typedef          charT                                value_type;
   typedef          implementation-specific              const_iterator;
   typedef          const_iterator                       iterator;
   typedef          charT&                               reference;
   typedef          const charT&                         const_reference;
   typedef          std::ptrdiff_t                       difference_type;
   typedef          std::size_t                          size_type;
   typedef          regex_constants:: syntax_option_type  flag_type;
   typedef typename traits::locale_type                  locale_type;
   // constants:
   // main option selection:
   static const regex_constants:: syntax_option_type normal
                                                = regex_constants::normal;
   static const regex_constants:: syntax_option_type ECMAScript
                                                = normal;
   static const regex_constants:: syntax_option_type JavaScript
                                                = normal;
   static const regex_constants:: syntax_option_type JScript
                                                = normal;
   static const regex_constants:: syntax_option_type basic
                                                = regex_constants::basic;
   static const regex_constants:: syntax_option_type extended
                                                = regex_constants::extended;
   static const regex_constants:: syntax_option_type awk
                                                = regex_constants::awk;
   static const regex_constants:: syntax_option_type grep
                                                = regex_constants::grep;
   static const regex_constants:: syntax_option_type egrep
                                                = regex_constants::egrep;
   static const regex_constants:: syntax_option_type sed
                                                = basic = regex_constants::sed;
   static const regex_constants:: syntax_option_type perl
                                                = regex_constants::perl;
   static const regex_constants:: syntax_option_type literal
                                                = regex_constants::literal;
   // modifiers specific to perl expressions:
   static const regex_constants:: syntax_option_type no_mod_m
                                                = regex_constants::no_mod_m;
   static const regex_constants:: syntax_option_type no_mod_s
                                                = regex_constants::no_mod_s;
   static const regex_constants:: syntax_option_type mod_s
                                                = regex_constants::mod_s;
   static const regex_constants:: syntax_option_type mod_x
                                                = regex_constants::mod_x;
   // modifiers specific to POSIX basic expressions:
   static const regex_constants:: syntax_option_type bk_plus_qm
                                                = regex_constants::bk_plus_qm;
   static const regex_constants:: syntax_option_type bk_vbar
                                                = regex_constants::bk_vbar
   static const regex_constants:: syntax_option_type no_char_classes
                                                = regex_constants::no_char_classes
   static const regex_constants:: syntax_option_type no_intervals
                                                = regex_constants::no_intervals
   // common modifiers:
   static const regex_constants:: syntax_option_type nosubs
                                                = regex_constants::nosubs;
   static const regex_constants:: syntax_option_type optimize
                                                = regex_constants::optimize;
   static const regex_constants:: syntax_option_type collate
                                                = regex_constants::collate;
   static const regex_constants:: syntax_option_type newline_alt
                                                = regex_constants::newline_alt;
   static const regex_constants:: syntax_option_type no_except
                                                = regex_constants::newline_alt;
   // construct/copy/destroy:
   explicit basic_regex ();
   explicit basic_regex(const  charT* p, flag_type f = regex_constants::normal);
   basic_regex(const charT* p1, const  charT* p2,
               flag_type f = regex_constants::normal);
   basic_regex(const charT* p, size_type len, flag_type  f);
   basic_regex(const basic_regex&);
   template <class ST, class SA>
   explicit basic_regex(const basic_string<charT, ST,  SA>& p,
                        flag_type f = regex_constants::normal);
   template <class InputIterator>
   basic_regex(InputIterator first,  InputIterator last,
               flag_type f = regex_constants::normal);
   ~basic_regex();
   basic_regex& operator=(const basic_regex&);
   basic_regex& operator= (const charT* ptr);
   template <class ST, class SA>
   basic_regex& operator= (const basic_string<charT, ST, SA>& p);
   // iterators: 
   std::pair<const_iterator, const_iterator> subexpression(size_type n) const;
   const_iterator begin() const;
   const_iterator end() const;
   // capacity: 
   size_type size() const;
   size_type max_size() const;
   bool empty() const;
   size_type mark_count()const;
   //
   // modifiers: 
   basic_regex& assign(const basic_regex& that);
   basic_regex& assign(const charT* ptr,
                       flag_type f = regex_constants::normal);
   basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);
   template <class string_traits, class A>
   basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                       flag_type f = regex_constants::normal);
   template <class InputIterator>
   basic_regex& assign(InputIterator first, InputIterator last,
                       flag_type f = regex_constants::normal);
   // const operations:
   flag_type flags() const;
   int status()const;
   basic_string<charT> str() const;
   int compare(basic_regex&) const;
   // locale:
   locale_type imbue(locale_type loc);
   locale_type getloc() const;
   // swap
   void swap(basic_regex&) throw();
};
template <class charT, class traits>
bool operator == (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);
template <class charT, class traits>
bool operator != (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);
template <class charT, class traits>
bool operator < (const basic_regex<charT, traits>& lhs,
               const basic_regex<charT, traits>& rhs);
template <class charT, class traits>
bool operator <= (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);
template <class charT, class traits>
bool operator >= (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);
template <class charT, class traits>
bool operator > (const basic_regex<charT, traits>& lhs,
               const basic_regex<charT, traits>& rhs);
template <class charT, class io_traits, class re_traits>
basic_ostream<charT, io_traits>&
   operator << (basic_ostream<charT, io_traits>& os,
               const basic_regex<charT, re_traits>& e);
template <class charT, class traits>
void swap(basic_regex<charT, traits>& e1,
         basic_regex<charT, traits>& e2);
typedef basic_regex<char> regex;
typedef basic_regex<wchar_t> wregex;
} // namespace boost
Description

Класс<basic_regex>имеет следующих общественных членов:

// main option selection:
static const regex_constants:: syntax_option_type normal
                                          = regex_constants::normal;
static const regex_constants:: syntax_option_type ECMAScript
                                          = normal;
static const regex_constants:: syntax_option_type JavaScript
                                          = normal;
static const regex_constants:: syntax_option_type JScript
                                          = normal;
static const regex_constants:: syntax_option_type basic
                                          = regex_constants::basic;
static const regex_constants:: syntax_option_type extended
                                          = regex_constants::extended;
static const regex_constants:: syntax_option_type awk
                                          = regex_constants::awk;
static const regex_constants:: syntax_option_type grep
                                          = regex_constants::grep;
static const regex_constants:: syntax_option_type egrep
                                          = regex_constants::egrep;
static const regex_constants:: syntax_option_type sed
                                          = regex_constants::sed;
static const regex_constants:: syntax_option_type perl
                                          = regex_constants::perl;
static const regex_constants:: syntax_option_type literal
                                          = regex_constants::literal;
// modifiers specific to perl expressions:
static const regex_constants:: syntax_option_type no_mod_m
                                          = regex_constants::no_mod_m;
static const regex_constants:: syntax_option_type no_mod_s
                                          = regex_constants::no_mod_s;
static const regex_constants:: syntax_option_type mod_s
                                          = regex_constants::mod_s;
static const regex_constants:: syntax_option_type mod_x
                                          = regex_constants::mod_x;
// modifiers specific to POSIX basic expressions:
static const regex_constants:: syntax_option_type bk_plus_qm
                                          = regex_constants::bk_plus_qm;
static const regex_constants:: syntax_option_type bk_vbar
                                          = regex_constants::bk_vbar
static const regex_constants:: syntax_option_type no_char_classes
                                          = regex_constants::no_char_classes
static const regex_constants:: syntax_option_type no_intervals
                                          = regex_constants::no_intervals
// common modifiers:
static const regex_constants:: syntax_option_type nosubs
                                          = regex_constants::nosubs;
static const regex_constants:: syntax_option_type optimize
                                          = regex_constants::optimize;
static const regex_constants:: syntax_option_type collate
                                          = regex_constants::collate;
static const regex_constants:: syntax_option_type newline_alt
                                          = regex_constants::newline_alt;

Смысл этих вариантов задокументирован в разделе<syntax_option_type>.

Статические константы представлены как синонимы констант, объявленных в пространстве имен<boost::regex_constants>; для каждой константы типа<syntax_option_type>, объявленной в пространстве имен<boost::regex_constants>, затем константа с тем же именем, типом и значением объявляется в рамках basic_regex.

basic_regex();

Эффекты: Построение объекта класса<basic_regex>.

Table 1. basic_regex default construction postconditions

Элемент

ценность

<empty()>

<true>

<size()>

<0>

<str()>

<basic_string<charT>()>

 

basic_regex(const charT* p, flag_type f = regex_constants::normal);

Требуется:pне должен быть нулевым указателем.

Бросает:<bad_expression>, еслиpне является действительным регулярным выражением, если только флаг<no_except>не установлен вf.

Эффекты: Конструирует объект класса<basic_regex>; внутренняя конечная машина объекта построена из регулярного выражения, содержащегося в нулевой строкеp, и интерпретируется в соответствии сфлагами опций, указанными вf.

Table 2. Postconditions for basic_regex construction

Элемент

ценность

<empty()>

<false>

<size()>

<char_traits<charT>::length(p)>

<str()>

<basic_string<charT>(p)>

<flags()>

f

<mark_count()>

Число обозначенных подвыражений внутри выражения.

 

basic_regex(const charT* p1, const charT* p2,
            flag_type f = regex_constants::normal);

Требуется:p1иp2не являются нулевыми указателями<p1<p2>.

Бросает: bad_expression, если [p1,p2) не является действительным регулярным выражением, если только флаг<no_except>не установлен вf.

Эффекты: Конструирует объект класса<basic_regex>; внутренняя конечная машина объекта построена из регулярного выражения, содержащегося в последовательности символов [p1,p2), и интерпретируется в соответствии сфлагами вариантов, указанными вf.

Table 3. Postconditions for basic_regex construction

Элемент

ценность

<empty()>

<false>

<size()>

<std::distance(p1,p2)>

<str()>

<basic_string<charT>(p1,p2)>

<flags()>

f

<mark_count()>

Число обозначенных подвыражений внутри выражения.

 

basic_regex(const charT* p, size_type len, flag_type f);

Требует:pне должен быть нулевым указателем<len< max_size()>.

Бросает:<bad_expression>, еслиpне является действительным регулярным выражением, если только флаг<no_except>не установлен вf.

Эффекты: Конструирует объект класса<basic_regex>; внутренняя конечная машина объекта построена из регулярного выражения, содержащегося в последовательности символов [p, p+len], и интерпретируется в соответствии с флагами вариантов, указанными вf.

Table 4. Postconditions for basic_regex construction

Элемент

ценность

<empty()>

<false>

<size()>

len

<str()>

<basic_string<charT>(p, len)>

<flags()>

f

<mark_count()>

Число обозначенных подвыражений внутри выражения.

 

basic_regex(const basic_regex& e);

Эффекты: Построение объекта класса<basic_regex>в виде копии объектаe.

template <class ST, class SA>
basic_regex(const basic_string<charT, ST, SA>& s,
            flag_type f = regex_constants::normal);

Бросает:<bad_expression>, еслиsне является действительным регулярным выражением, если только флаг<no_except>не установлен вf.

Эффекты: Конструирует объект класса<basic_regex>; внутренняя конечная машина объекта построена из регулярного выражения, содержащегося в строкеs, и интерпретируется в соответствии сфлагами вариантов, указанными вf.

Table 5. Postconditions for basic_regex construction

Элемент

ценность

<empty()>

<false>

<size()>

<s.size()>

<str()>

s

<flags()>

f

<mark_count()>

Число обозначенных подвыражений внутри выражения.

 

template <class ForwardIterator>
basic_regex(ForwardIterator first, ForwardIterator last,
            flag_type f = regex_constants::normal);

Бросает:<bad_expression>, если последовательность [первая, последняя] не является действительным регулярным выражением, если только флаг<no_except>не установлен вf.

Эффекты: Конструирует объект класса<basic_regex>; внутренняя машина конечного состояния объекта построена из регулярного выражения, содержащегося в последовательности символов [первый, последний], и интерпретируется в соответствии сфлагами опций, указанными вf.

Table 6. Postconditions for basic_regex construction

Элемент

ценность

<empty()>

<false>

<size()>

<distance(first,last)>

<str()>

<basic_string<charT>(first,last)>

<flags()>

f

<mark_count()>

Число обозначенных подвыражений внутри выражения.

 

basic_regex& operator=(const basic_regex& e);

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

basic_regex& operator=(const charT* ptr);

Требуется:pне должен быть нулевым указателем.

Эффекты: Возвращает результат<assign(ptr)>.

template <class ST, class SA>
basic_regex& operator=(const basic_string<charT, ST, SA>& p);

Эффекты: Возвращает результат<assign(p)>.

std::pair<const_iterator, const_iterator> subexpression(size_type n) const;

Эффекты: Возвращает пару итераторов, обозначающих местоположение отмеченной подэкспрессииnв исходной строке регулярного выражения. Возвращенные итераторы относятся к<begin()>и<end()>.

Требуется: Выражение должно быть составлено с помощью набора<syntax_option_type>save_subexpression_location.Аргументnдолжен находиться в пределах<0<=n <mark_count()>.

const_iterator begin() const;

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

const_iterator end() const;

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

size_type size() const;

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

size_type max_size() const;

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

bool empty() const;

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

size_type mark_count() const;

Эффекты: Возвращает количество отмеченных подвыражений в пределах обычного выражения.

basic_regex& assign(const basic_regex& that);

Эффекты: Возвращение<assign(that.str(),that.flags())>.

basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);

Эффекты: Возвращение<assign(string_type(ptr),f)>.

basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);

Эффекты: Возвращение<assign(string_type(ptr,len),f)>.

template <class string_traits, class A>
basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                  flag_type f = regex_constants::normal);

Бросает:<bad_expression>, еслиsне является действительным регулярным выражением, если только флаг<no_except>не установлен вf.

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

Эффекты: Назначает регулярное выражение, содержащееся в строкеs, интерпретируемое в соответствии сфлагами опций, указанными вf.

Table 7. Postconditions for basic_regex::assign

Элемент

ценность

<empty()>

<false>

<size()>

<s.size()>

<str()>

s

<flags()>

f

<mark_count()>

Число обозначенных подвыражений внутри выражения.

 

template <class InputIterator>
basic_regex& assign(InputIterator first, InputIterator last,
                    flag_type f = regex_constants::normal);

Требуется: Тип<InputIterator>соответствует требованиямИтератора ввода (24.1.1).

Эффекты: Возвращение<assign(string_type(first,last),f)>.

flag_type flags() const;

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

int status() const;

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

basic_string<charT> str() const;

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

int compare(basic_regex& e)const;

Эффекты: Если<flags()==e.flags()>возвращается<str().compare(e.str())>, то в противном случае возвращается<flags() -e.flags()>.

locale_type imbue(locale_type l);

Эффекты: Возвращает результат<traits_inst.imbue(l)>, где<traits_inst>является (по умолчанию инициализированным) экземпляром параметра шаблона<traits>, хранящегося внутри объекта. Призывы к<imbue>недействительны в отношении любого из содержащихся в настоящее время регулярных выражений.

Посткондиционер:<empty()==true>.

locale_type getloc() const;

Эффекты: Возвращает результат<traits_inst.getloc()>, где<traits_inst>является (по умолчанию инициализированным) экземпляром признаков параметров шаблона, хранящихся внутри объекта.

void swap(basic_regex& e) throw();

Эффекты: Измените содержание двух регулярных выражений.

Постусловие:<*this>содержит регулярное выражение, которое было вe,eсодержит регулярное выражение, которое было в<*this>.

Сложность: Постоянное время.

[Note] Note

Сравнения между<basic_regex>объектами предоставляются на экспериментальной основе: обратите внимание, что они не присутствуют вТехническом отчете о расширениях библиотеки C++, поэтому используйте с осторожностью, если вы пишете код, который может потребоваться портировать на другие реализации<basic_regex>.

template <class charT, class traits>
bool operator == (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

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

template <class charT, class traits>
bool operator != (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

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

template <class charT, class traits>
bool operator < (const basic_regex<charT, traits>& lhs,
               const basic_regex<charT, traits>& rhs);

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

template <class charT, class traits>
bool operator <= (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

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

template <class charT, class traits>
bool operator >= (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

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

template <class charT, class traits>
bool operator > (const basic_regex<charT, traits>& lhs,
               const basic_regex<charT, traits>& rhs);

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

[Note] Note

Базовый вставщик потока_regex предоставляется на экспериментальной основе и выводит текстовое представление выражения в поток.

template <class charT, class io_traits, class re_traits>
basic_ostream<charT, io_traits>&
   operator << (basic_ostream<charT, io_traits>& os
               const basic_regex<charT, re_traits>& e);

Эффекты: Возвращение<(os<<e.str())>.

template <class charT, class traits>
void swap(basic_regex<charT, traits>& lhs,
         basic_regex<charT, traits>& rhs);

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

Copyright © 1998-2013 John Maddock

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

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




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


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

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

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