Provided by: libstdc++-8-doc_8.3.0-23ubuntu2_all bug

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

   Public Member Functions
       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 & 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.
       flag_type flags () const
           Gets the flags used to construct the regular expression or in the last call to
           assign().
       locale_type getloc () const
           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
           Gets the number of marked subexpressions within the 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.
       void swap (basic_regex &__rhs)
           Swaps the contents of two regular expression objects.

   Static Public Attributes
       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

   Friends
       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)
       template<typename , typename , typename , bool > class __detail::_Executor

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.

Constructor & Destructor Documentation

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

       Definition at line 422 of file regex.h.

   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.

       Exceptions:
           regex_error if __p is not a valid regular expression.

       Definition at line 438 of file regex.h.

   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.

       Exceptions:
           regex_error if __p is not a valid regular expression.

       Definition at line 454 of file regex.h.

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> std::basic_regex<
       _Ch_type, _Rx_traits >::basic_regex (const basic_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
       (const std::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.

       Exceptions:
           regex_error if __s is not a valid regular expression.

       Definition at line 484 of file regex.h.

   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.

       Exceptions:
           regex_error if [__first, __last) is not a valid regular expression.

       Definition at line 504 of file regex.h.

   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.

       Exceptions:
           regex_error if __l is not a valid regular expression.

       Definition at line 517 of file regex.h.

   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.

       Definition at line 524 of file regex.h.

Member Function Documentation

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> basic_regex&
       std::basic_regex< _Ch_type, _Rx_traits >::assign (const basic_regex< _Ch_type, _Rx_traits
       > & __rhs) [inline]
       the real assignment operator.

       Parameters:
           __rhs Another regular expression object.

       Definition at line 582 of file regex.h.

   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]
       The move-assignment operator.

       Parameters:
           __rhs Another regular expression object.

       Definition at line 595 of file regex.h.

   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.

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

       Definition at line 616 of file regex.h.

   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, std::size_t __len,
       flag_type __flags) [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.

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

       Definition at line 633 of file regex.h.

   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 (const basic_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.

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

       Definition at line 649 of file regex.h.

       References std::basic_string< _CharT, _Traits, _Alloc >::data(), and std::basic_string<
       _CharT, _Traits, _Alloc >::size().

   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.

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

       Definition at line 671 of file regex.h.

   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.

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

       Definition at line 687 of file regex.h.

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

       Definition at line 708 of file regex.h.

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> locale_type
       std::basic_regex< _Ch_type, _Rx_traits >::getloc () const [inline]
       Gets the locale currently imbued in the regular expression object.

       Definition at line 730 of file regex.h.

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> locale_type
       std::basic_regex< _Ch_type, _Rx_traits >::imbue (locale_type __loc) [inline]
       Imbues the regular expression object with the given locale.

       Parameters:
           __loc A locale.

       Definition at line 718 of file regex.h.

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> unsigned int
       std::basic_regex< _Ch_type, _Rx_traits >::mark_count () const [inline]
       Gets the number of marked subexpressions within the regular expression.

       Definition at line 696 of file regex.h.

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> basic_regex&
       std::basic_regex< _Ch_type, _Rx_traits >::operator= (const basic_regex< _Ch_type,
       _Rx_traits > & __rhs) [inline]
       Assigns one regular expression to another.

       Definition at line 531 of file regex.h.

   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 >
       && __rhs) [inline],  [noexcept]
       Move-assigns one regular expression to another.

       Definition at line 538 of file regex.h.

   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.

       Definition at line 549 of file regex.h.

   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.

       Exceptions:
           regex_error if __l is not a valid regular expression.

       Definition at line 561 of file regex.h.

   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= (const basic_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.

       Definition at line 572 of file regex.h.

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> void
       std::basic_regex< _Ch_type, _Rx_traits >::swap (basic_regex< _Ch_type, _Rx_traits > &
       __rhs) [inline]
       Swaps the contents of two regular expression objects.

       Parameters:
           __rhs Another regular expression object.

       Definition at line 740 of file regex.h.

       Referenced by std::swap().

Author

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

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