focal (3) std::basic_regex.3cxx.gz

NAME

       std::basic_regex< _Ch_type, _Rx_traits >

SYNOPSIS

   Public Types
       typedef regex_constants::syntax_option_type flag_type
       typedef traits_type::locale_type locale_type
       typedef traits_type::string_type string_type
       typedef _Rx_traits traits_type
       typedef _Ch_type value_type

   Constants
       std [28.8.1](1)
       static constexpr flag_type icase
       static constexpr flag_type nosubs
       static constexpr flag_type optimize
       static constexpr flag_type collate
       static constexpr flag_type ECMAScript
       static constexpr flag_type basic
       static constexpr flag_type extended
       static constexpr flag_type awk
       static constexpr flag_type grep
       static constexpr flag_type egrep
       template<typename , typename , typename , bool > class __detail::_Executor
       template<typename _Bp , typename _Ap , typename _Cp , typename _Rp , __detail::_RegexExecutorPolicy ,
           bool > bool __detail::__regex_algo_impl (_Bp, _Bp, match_results< _Bp, _Ap > &, const basic_regex<
           _Cp, _Rp > &, regex_constants::match_flag_type)
       basic_regex ()
       basic_regex (const _Ch_type *__p, flag_type __f=ECMAScript)
           Constructs a basic regular expression from the sequence [__p, __p +
           char_traits<_Ch_type>::length(__p)) interpreted according to the flags in __f.
       basic_regex (const _Ch_type *__p, std::size_t __len, flag_type __f=ECMAScript)
           Constructs a basic regular expression from the sequence [p, p + len) interpreted according to the
           flags in f.
       basic_regex (const basic_regex &__rhs)=default
           Copy-constructs a basic regular expression.
       basic_regex (basic_regex &&__rhs) noexcept=default
           Move-constructs a basic regular expression.
       template<typename _Ch_traits , typename _Ch_alloc > basic_regex (const std::basic_string< _Ch_type,
           _Ch_traits, _Ch_alloc > &__s, flag_type __f=ECMAScript)
           Constructs a basic regular expression from the string s interpreted according to the flags in f.
       template<typename _FwdIter > basic_regex (_FwdIter __first, _FwdIter __last, flag_type __f=ECMAScript)
           Constructs a basic regular expression from the range [first, last) interpreted according to the flags
           in f.
       basic_regex (initializer_list< _Ch_type > __l, flag_type __f=ECMAScript)
           Constructs a basic regular expression from an initializer list.
       ~basic_regex ()
           Destroys a basic regular expression.
       basic_regex & operator= (const basic_regex &__rhs)
           Assigns one regular expression to another.
       basic_regex & operator= (basic_regex &&__rhs) noexcept
           Move-assigns one regular expression to another.
       basic_regex & operator= (const _Ch_type *__p)
           Replaces a regular expression with a new one constructed from a C-style null-terminated string.
       basic_regex & operator= (initializer_list< _Ch_type > __l)
           Replaces a regular expression with a new one constructed from an initializer list.
       template<typename _Ch_traits , typename _Alloc > basic_regex & operator= (const basic_string< _Ch_type,
           _Ch_traits, _Alloc > &__s)
           Replaces a regular expression with a new one constructed from a string.
       basic_regex & assign (const basic_regex &__rhs)
           the real assignment operator.
       basic_regex & assign (basic_regex &&__rhs) noexcept
           The move-assignment operator.
       basic_regex & assign (const _Ch_type *__p, flag_type __flags=ECMAScript)
           Assigns a new regular expression to a regex object from a C-style null-terminated string containing a
           regular expression pattern.
       basic_regex & assign (const _Ch_type *__p, std::size_t __len, flag_type __flags)
           Assigns a new regular expression to a regex object from a C-style string containing a regular
           expression pattern.
       template<typename _Ch_traits , typename _Alloc > basic_regex & assign (const basic_string< _Ch_type,
           _Ch_traits, _Alloc > &__s, flag_type __flags=ECMAScript)
           Assigns a new regular expression to a regex object from a string containing a regular expression
           pattern.
       template<typename _InputIterator > basic_regex & assign (_InputIterator __first, _InputIterator __last,
           flag_type __flags=ECMAScript)
           Assigns a new regular expression to a regex object.
       basic_regex & assign (initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript)
           Assigns a new regular expression to a regex object.
       unsigned int mark_count () const
           Gets the number of marked subexpressions within the regular expression.
       flag_type flags () const
           Gets the flags used to construct the regular expression or in the last call to assign().
       locale_type imbue (locale_type __loc)
           Imbues the regular expression object with the given locale.
       locale_type getloc () const
           Gets the locale currently imbued in the regular expression object.
       void swap (basic_regex &__rhs)
           Swaps the contents of two regular expression objects.

Detailed Description

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
       class std::basic_regex< _Ch_type, _Rx_traits >" Objects of specializations of this class represent
       regular expressions constructed from sequences of character type _Ch_type.

       Storage for the regular expression is allocated and deallocated as necessary by the member functions of
       this class.

       Definition at line 36 of file regex.h.

Author

       Generated automatically by Doxygen for libstdc++ from the source code.