std::basic_regex man page on RedHat

Man page or keyword search:  
man Server   29550 pages
apropos Keyword Search (all sections)
Output format
RedHat logo
[printable version]

std::basic_regex<; _Ch_type, _Rx_trastd::basic_regex< _Ch_type, _Rx_traits >(3)

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)
       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=ECMAScript)
       template<typename _InputIterator > basic_regex (_InputIterator __first,
	   _InputIterator __last, flag_type __f=ECMAScript)
       basic_regex (initializer_list< _Ch_type > __l, flag_type
	   __f=ECMAScript)
       ~basic_regex ()
       const __detail::_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=ECMAScript)
       basic_regex & assign (const _Ch_type *__p, std::size_t __len, flag_type
	   __flags)
       template<typename _Ch_typeraits , typename _Alloc > basic_regex &
	   assign (const basic_string< _Ch_type, _Ch_typeraits, _Alloc > &__s,
	   flag_type __flags=ECMAScript)
       template<typename _InputIterator > basic_regex & assign (_InputIterator
	   __first, _InputIterator __last, flag_type __flags=ECMAScript)
       basic_regex & assign (initializer_list< _Ch_type > __l, flag_type
	   __flags=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 _Alloc > basic_regex &
	   operator= (const basic_string< _Ch_type, _Ch_typeraits, _Alloc >
	   &__s)
       void swap (basic_regex &__rhs)

   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

   Protected Attributes
       __detail::_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 335 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 367 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 385 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 403 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 413 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],  [noexcept]
       Move-constructs a basic regular expression.

       Parameters:
	   __rhs A regex object.

       Definition at line 423 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 = 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 439 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 = 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 461 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 475 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 485 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 531 of file regex.h.

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

       Referenced by std::basic_regex< _Ch_type, _Rx_traits >::assign(), and
       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],	[noexcept]
       The move-assignment operator.

       Parameters:
	   __rhs Another regular expression object.

       Definition at line 544 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 = 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 565 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 >::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 582 of file regex.h.

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

   template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
       template<typename _Ch_typeraits , typename _Alloc > basic_regex&
       std::basic_regex< _Ch_type, _Rx_traits >::assign (const basic_string<
       _Ch_type, _Ch_typeraits, _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 598 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 = 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 621 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 >::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 637 of file regex.h.

       References 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 654 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 672 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 664 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 646 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 492 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],	[noexcept]
       Move-assigns one regular expression to another.

       Definition at line 499 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:
	   __p A pointer to the start of a null-terminated C-style string
	   containing a regular expression.

       Definition at line 510 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 _Alloc > basic_regex&
       std::basic_regex< _Ch_type, _Rx_traits >::operator= (const
       basic_string< _Ch_type, _Ch_typeraits, _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 521 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 682 of file regex.h.

       References std::swap().

       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++			Wedstd::basic_regex< _Ch_type, _Rx_traits >(3)
[top]

List of man pages available for RedHat

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net