std::basic_regex< _Ch_type, _Rx_traits > - A regular expression.

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

                                                    libstdc++     std::basic_regex<_Ch_type,_Rx_traits>(3cxx)

template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex()[inline],[noexcept]
       Constructs a basic regular expression that does not match any character sequence.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(const_Ch_type*__p,flag_type__f=ECMAScript)[inline],[explicit]
       Constructs a basic regular expression from the sequence [__p, __p + char_traits<_Ch_type>::length(__p))
       interpreted according to the flags in __f.

       Parameters__p A pointer to the start of a C-style null-terminated string containing a regular expression.
           __f Flags indicating the syntax rules and options.

       Exceptionsregex_error if __p is not a valid regular expression.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(const_Ch_type*__p,std::size_t__len,flag_type__f=ECMAScript)[inline]
       Constructs a basic regular expression from the sequence [p, p + len) interpreted according to the flags
       in f.

       Parameters__p A pointer to the start of a string containing a regular expression.
           __len The length of the string containing the regular expression.
           __f Flags indicating the syntax rules and options.

       Exceptionsregex_error if __p is not a valid regular expression.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(constbasic_regex<_Ch_type,_Rx_traits>&__rhs)[default]
       Copy-constructs a basic regular expression.

       Parameters__rhs A regex object.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(basic_regex<_Ch_type,_Rx_traits>&&__rhs)[default],[noexcept]
       Move-constructs a basic regular expression.

       Parameters__rhs A regex object.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>template<typename_Ch_traits,typename_Ch_alloc>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(conststd::basic_string<_Ch_type,_Ch_traits,_Ch_alloc>&__s,flag_type__f=ECMAScript)[inline],[explicit]
       Constructs a basic regular expression from the string s interpreted according to the flags in f.

       Parameters__s A string containing a regular expression.
           __f Flags indicating the syntax rules and options.

       Exceptionsregex_error if __s is not a valid regular expression.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>template<typename_FwdIter>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(_FwdIter__first,_FwdIter__last,flag_type__f=ECMAScript)[inline]
       Constructs a basic regular expression from the range [first, last) interpreted according to the flags in
       f.

       Parameters__first The start of a range containing a valid regular expression.
           __last The end of a range containing a valid regular expression.
           __f The format flags of the regular expression.

       Exceptionsregex_error if [__first, __last) is not a valid regular expression.

       References std::basic_regex<_Ch_type,_Rx_traits>::assign().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(initializer_list<_Ch_type>__l,flag_type__f=ECMAScript)[inline]
       Constructs a basic regular expression from an initializer list.

       Parameters__l The initializer list.
           __f The format flags of the regular expression.

       Exceptionsregex_error if __l is not a valid regular expression.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>std::basic_regex<_Ch_type,_Rx_traits>::~basic_regex()[inline]
       Destroys a basic regular expression.

template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>
       class std::basic_regex< _Ch_type, _Rx_traits >"A regular expression.

       Specializations of this class template represent regular expressions constructed from sequences of
       character type _Ch_type. Use the std::regex typedef for std::basic_regex<char>.

       A character sequence passed to the constructor will be parsed according to the chosen grammar, and used
       to create a state machine representing the regular expression. The regex object can then be passed to
       algorithms such as std::regex_match to match sequences of characters.

       The syntax_option_type flag passed to the constructor selects from one of the supported regular
       expression grammars. The default is ECMAScript and the others are basic, extended, awk, grep, and egrep,
       which are variations on POSIX regular expressions.

       Since
           C++11

template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>template<typename_InputIterator>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::assign(_InputIterator__first,_InputIterator__last,flag_type__flags=ECMAScript)[inline]
       Assigns a new regular expression to a regex object.

       Parameters__first The start of a range containing a valid regular expression.
           __last The end of a range containing a valid regular expression.
           __flags Syntax option flags.

       Exceptionsregex_error if p does not contain a valid regular expression pattern interpreted according to
           __flags. If regex_error is thrown, the object remains unchanged.

       References std::basic_regex<_Ch_type,_Rx_traits>::assign().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::assign(basic_regex<_Ch_type,_Rx_traits>&&__rhs)[inline],[noexcept]
       Move-assigns one regular expression to another.

       Parameters__rhs Another regular expression object.

       References std::move().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::assign(const_Ch_type*__p,flag_type__flags=ECMAScript)[inline]
       Assigns a new regular expression to a regex object from a C-style null-terminated string containing a
       regular expression pattern.

       Parameters__p A pointer to a C-style null-terminated string containing a regular expression pattern.
           __flags Syntax option flags.

       Exceptionsregex_error if __p does not contain a valid regular expression pattern interpreted according to
           __flags. If regex_error is thrown, *this remains unchanged.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::assign(const_Ch_type*__p,size_t__len,flag_type__flags=ECMAScript)[inline]
       Assigns a new regular expression to a regex object from a C-style string containing a regular expression
       pattern.

       Parameters__p A pointer to a C-style string containing a regular expression pattern.
           __len The length of the regular expression pattern string.
           __flags Syntax option flags.

       Exceptionsregex_error if p does not contain a valid regular expression pattern interpreted according to
           __flags. If regex_error is thrown, *this remains unchanged.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::assign(constbasic_regex<_Ch_type,_Rx_traits>&__rhs)[inline],[noexcept]
       Assigns one regular expression to another.

       Parameters__rhs Another regular expression object.

       Referenced by std::basic_regex<_Ch_type,_Rx_traits>::basic_regex(), std::basic_regex<_Ch_type,_Rx_traits>::assign(), std::basic_regex<_Ch_type,_Rx_traits>::operator=(), std::basic_regex<_Ch_type,_Rx_traits>::operator=(), and std::basic_regex<_Ch_type,_Rx_traits>::operator=().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>template<typename_Ch_traits,typename_Alloc>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::assign(constbasic_string<_Ch_type,_Ch_traits,_Alloc>&__s,flag_type__flags=ECMAScript)[inline]
       Assigns a new regular expression to a regex object from a string containing a regular expression pattern.

       Parameters__s A string containing a regular expression pattern.
           __flags Syntax option flags.

       Exceptionsregex_error if __s does not contain a valid regular expression pattern interpreted according to
           __flags. If regex_error is thrown, *this remains unchanged.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::assign(initializer_list<_Ch_type>__l,flag_type__flags=ECMAScript)[inline]
       Assigns a new regular expression to a regex object.

       Parameters__l An initializer list representing a regular expression.
           __flags Syntax option flags.

       Exceptionsregex_error if __l does not contain a valid regular expression pattern interpreted according to
           __flags. If regex_error is thrown, the object remains unchanged.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>flag_typestd::basic_regex<_Ch_type,_Rx_traits>::flags()const[inline],[noexcept]
       Gets the flags used to construct the regular expression or in the last call to assign().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>locale_typestd::basic_regex<_Ch_type,_Rx_traits>::getloc()const[inline],[noexcept]
       Gets the locale currently imbued in the regular expression object.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>locale_typestd::basic_regex<_Ch_type,_Rx_traits>::imbue(locale_type__loc)[inline]
       Imbues the regular expression object with the given locale.

       Parameters__loc A locale.

       References std::swap().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>unsignedintstd::basic_regex<_Ch_type,_Rx_traits>::mark_count()const[inline],[noexcept]
       Gets the number of marked subexpressions within the regular expression.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::operator=(basic_regex<_Ch_type,_Rx_traits>&&)[default]
       Move-assigns one regular expression to another.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::operator=(const_Ch_type*__p)[inline]
       Replaces a regular expression with a new one constructed from a C-style null-terminated string.

       Parameters__p A pointer to the start of a null-terminated C-style string containing a regular expression.

       References std::basic_regex<_Ch_type,_Rx_traits>::assign().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::operator=(constbasic_regex<_Ch_type,_Rx_traits>&)[default]
       Assigns one regular expression to another.

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>template<typename_Ch_traits,typename_Alloc>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::operator=(constbasic_string<_Ch_type,_Ch_traits,_Alloc>&__s)[inline]
       Replaces a regular expression with a new one constructed from a string.

       Parameters__s A pointer to a string containing a regular expression.

       References std::basic_regex<_Ch_type,_Rx_traits>::assign().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>basic_regex&std::basic_regex<_Ch_type,_Rx_traits>::operator=(initializer_list<_Ch_type>__l)[inline]
       Replaces a regular expression with a new one constructed from an initializer list.

       Parameters__l The initializer list.

       Exceptionsregex_error if __l is not a valid regular expression.

       References std::basic_regex<_Ch_type,_Rx_traits>::assign().

   template<typename_Ch_type,typename_Rx_traits=regex_traits<_Ch_type>>voidstd::basic_regex<_Ch_type,_Rx_traits>::swap(basic_regex<_Ch_type,_Rx_traits>&__rhs)[inline],[noexcept]
       Swaps the contents of two regular expression objects.

       Parameters__rhs Another regular expression object.

       References std::swap().

       std::basic_regex< _Ch_type, _Rx_traits > - A regular expression.

       #include <regex>

   PublicTypestypedefregex_constants::syntax_option_typeflag_typetypedef traits_type::locale_type locale_typetypedef traits_type::string_type string_typetypedef_Rx_traitstraits_typetypedef_Ch_typevalue_typePublicMemberFunctionsbasic_regex () noexcept
       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 (basic_regex &&__rhs) noexcept=default
           Move-constructs a basic regular expression.
       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.
       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.
       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.
       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 (basic_regex &&__rhs) noexcept
           Move-assigns one regular expression to another.
       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, size_t __len, flag_type __flags=ECMAScript)
           Assigns a new regular expression to a regex object from a C-style string containing a regular
           expression pattern.
       basic_regex & assign (const basic_regex &__rhs) noexcept
           Assigns one regular expression to another.
       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.
       basic_regex & assign (initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript)
           Assigns a new regular expression to a regex object.
       flag_typeflags () const noexcept
           Gets the flags used to construct the regular expression or in the last call to assign().
       locale_type getloc () const noexcept
           Gets the locale currently imbued in the regular expression object.
       locale_type imbue (locale_type __loc)
           Imbues the regular expression object with the given locale.
       unsigned int mark_count () const noexcept
           Gets the number of marked subexpressions within the regular expression.
       basic_regex & operator= (basic_regex &&)=default
           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= (const basic_regex &)=default
           Assigns one regular expression to another.
       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 & operator= (initializer_list< _Ch_type > __l)
           Replaces a regular expression with a new one constructed from an initializer list.
       voidswap (basic_regex &__rhs) noexcept
           Swaps the contents of two regular expression objects.

   StaticPublicAttributesConstants
       std [28.8.1](1)

           static constexpr flag_typeicasestatic constexpr flag_typenosubsstatic constexpr flag_typeoptimizestatic constexpr flag_typecollatestatic constexpr flag_typeECMAScriptstatic constexpr flag_typebasicstatic constexpr flag_typeextendedstatic constexpr flag_typeawkstatic constexpr flag_typegrepstatic constexpr flag_typeegrepstatic constexpr flag_typemultilineFriends
       template<typename _Bp , typename _Ap , typename_Cp , typename_Rp > bool __detail::__regex_algo_impl
           (_Bp, _Bp, match_results< _Bp, _Ap > &, const basic_regex< _Cp, _Rp > &,
           regex_constants::match_flag_type, __detail::_RegexExecutorPolicy, bool)
       template<typename , typename , typename , bool > class__detail::_ExecutorRelatedSymbols
       (Note that these are not member symbols.)
       template<typename_Ch_type , typename_Rx_traits > voidswap (basic_regex< _Ch_type, _Rx_traits > &__lhs,
           basic_regex< _Ch_type, _Rx_traits > &__rhs) noexcept
           Swaps the contents of two regular expression objects.