Provided by: libstdc++6-4.6-doc_4.6.3-1ubuntu5_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=regex_constants::ECMAScript)
       basic_regex (const _Ch_type *__p, std::size_t __len, flag_type __f)
       basic_regex (const basic_regex &__rhs)
       basic_regex (const basic_regex &&__rhs) noexcept
       template<typename _Ch_traits , typename _Ch_alloc > basic_regex (const std::basic_string<
           _Ch_type, _Ch_traits, _Ch_alloc > &__s, flag_type __f=regex_constants::ECMAScript)
       template<typename _InputIterator > basic_regex (_InputIterator __first, _InputIterator
           __last, flag_type __f=regex_constants::ECMAScript)
       basic_regex (initializer_list< _Ch_type > __l, flag_type __f=regex_constants::ECMAScript)
       ~basic_regex ()
       const __regex::_AutomatonPtr & _M_get_automaton () const
       basic_regex & assign (const basic_regex &__rhs)
       basic_regex & assign (basic_regex &&__rhs) noexcept
       basic_regex & assign (const _Ch_type *__p, flag_type __flags=regex_constants::ECMAScript)
       basic_regex & assign (const _Ch_type *__p, std::size_t __len, flag_type __flags)
       template<typename _Ch_typeraits , typename _Allocator > basic_regex & assign (const
           basic_string< _Ch_type, _Ch_typeraits, _Allocator > &__s, flag_type
           __f=regex_constants::ECMAScript)
       template<typename _InputIterator > basic_regex & assign (_InputIterator __first,
           _InputIterator __last, flag_type __flags=regex_constants::ECMAScript)
       basic_regex & assign (initializer_list< _Ch_type > __l, flag_type
           __f=regex_constants::ECMAScript)
       flag_type flags () const
       locale_type getloc () const
       locale_type imbue (locale_type __loc)
       unsigned int mark_count () const
       basic_regex & operator= (const basic_regex &__rhs)
       basic_regex & operator= (basic_regex &&__rhs) noexcept
       basic_regex & operator= (const _Ch_type *__p)
       template<typename _Ch_typeraits , typename _Allocator > basic_regex & operator= (const
           basic_string< _Ch_type, _Ch_typeraits, _Allocator > &__s)
       void swap (basic_regex &__rhs)

   Static Public Attributes
       Constants
       std [28.8.1](1)

           static constexpr
               regex_constants::syntax_option_type icase"
           static constexpr
               regex_constants::syntax_option_type nosubs"
           static constexpr
               regex_constants::syntax_option_type optimize"
           static constexpr
               regex_constants::syntax_option_type collate"
           static constexpr
               regex_constants::syntax_option_type ECMAScript"
           static constexpr
               regex_constants::syntax_option_type basic"
           static constexpr
               regex_constants::syntax_option_type extended"
           static constexpr
               regex_constants::syntax_option_type awk"
           static constexpr
               regex_constants::syntax_option_type grep"
           static constexpr
               regex_constants::syntax_option_type egrep"

   Protected Attributes
       __regex::_AutomatonPtr _M_automaton
       flag_type _M_flags
       _Rx_traits _M_traits

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 341 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 383 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 =
       regex_constants::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 401 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)
       [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 419 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)
       [inline]
       Copy-constructs a basic regular expression. Parameters:
           rhs A regex object.

       Definition at line 429 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)
       [inline]
       Move-constructs a basic regular expression. Parameters:
           rhs A regex object.

       Definition at line 439 of file regex.h.

   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 =
       regex_constants::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 455 of file regex.h.

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> template<typename
       _InputIterator > std::basic_regex< _Ch_type, _Rx_traits >::basic_regex
       (_InputIterator__first, _InputIterator__last, flag_type__f = regex_constants::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 477 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 =
       regex_constants::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 491 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 501 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 547 of file regex.h.

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

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

   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]
       The move-assignment operator. Parameters:
           rhs Another regular expression object.

       Definition at line 560 of file regex.h.

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

   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 =
       regex_constants::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 581 of file regex.h.

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

       Referenced by 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 (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 599 of file regex.h.

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

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

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> template<typename
       _Ch_typeraits , typename _Allocator > basic_regex& std::basic_regex< _Ch_type, _Rx_traits
       >::assign (const basic_string< _Ch_type, _Ch_typeraits, _Allocator > &__s, flag_type__f =
       regex_constants::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 p does not contain a valid regular expression pattern interpreted
           according to flags. If regex_error is thrown, *this remains unchanged.

       Definition at line 615 of file regex.h.

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

   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 =
       regex_constants::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 638 of file regex.h.

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

       Referenced by 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 (initializer_list< _Ch_type >__l,
       flag_type__f = regex_constants::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 653 of file regex.h.

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

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

   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 671 of file regex.h.

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

   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 689 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 681 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 663 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 508 of file regex.h.

       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= (basic_regex< _Ch_type, _Rx_traits >
       &&__rhs) [inline]
       Move-assigns one regular expression to another.

       Definition at line 515 of file regex.h.

       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= (const _Ch_type *__p) [inline]
       Replaces a regular expression with a new one constructed from a C-style null-terminated
       string. Parameters:
           A pointer to the start of a null-terminated C-style string containing a regular
           expression.

       Definition at line 526 of file regex.h.

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

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>> template<typename
       _Ch_typeraits , typename _Allocator > basic_regex& std::basic_regex< _Ch_type, _Rx_traits
       >::operator= (const basic_string< _Ch_type, _Ch_typeraits, _Allocator > &__s) [inline]
       Replaces a regular expression with a new one constructed from a string. Parameters:
           A pointer to a string containing a regular expression.

       Definition at line 537 of file regex.h.

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

   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 699 of file regex.h.

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

Author

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

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