std::basic_regex man page on Scientific

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

std::basic_regex(3)					   std::basic_regex(3)

NAME
       std::basic_regex -

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

   Public Member Functions
       basic_regex & assign (initializer_list< _Ch_type > __l, flag_type
	   __f=regex_constants::ECMAScript)
       template<typename _InputIterator > basic_regex & assign (_InputIterator
	   __first, _InputIterator __last, flag_type
	   __flags=regex_constants::ECMAScript)
       template<typename _Ch_typeraits , typename _Allocator > basic_regex &
	   assign (const basic_string< _Ch_type, _Ch_typeraits, _Allocator >
	   &__s, flag_type __f=regex_constants::ECMAScript)
       basic_regex & assign (const _Ch_type *__p, std::size_t __len, flag_type
	   __flags)
       basic_regex & assign (const _Ch_type *__p, flag_type
	   __flags=regex_constants::ECMAScript)
       basic_regex & assign (const basic_regex &__that)
       basic_regex (initializer_list< _Ch_type > __l, flag_type
	   __f=regex_constants::ECMAScript)
       template<typename _InputIterator > basic_regex (_InputIterator __first,
	   _InputIterator __last, flag_type __f=regex_constants::ECMAScript)
       template<typename _Ch_traits , typename _Ch_alloc > basic_regex (const
	   basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, flag_type
	   __f=regex_constants::ECMAScript)
       basic_regex (const basic_regex &__rhs)
       basic_regex (const _Ch_type *__p, std::size_t __len, flag_type __f)
       basic_regex (const _Ch_type *__p, flag_type
	   __f=regex_constants::ECMAScript)
       basic_regex ()
       flag_type flags () const
       locale_type getloc () const
       locale_type imbue (locale_type __loc)
       unsigned int mark_count () const
       template<typename _Ch_typeraits , typename _Allocator > basic_regex &
	   operator= (const basic_string< _Ch_type, _Ch_typeraits, _Allocator
	   > &__s)
       basic_regex & operator= (const _Ch_type *__p)
       basic_regex & operator= (const basic_regex &__rhs)
       void swap (basic_regex &__rhs)
       ~basic_regex ()

   Static Public Attributes
       Constants
	tr1 [7.8.1] std [28.8.1]

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

   Protected Attributes
       flag_type _M_flags
       unsigned int _M_mark_count
       string_type _M_pattern
       _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 709 of file tr1_impl/regex.

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 750 of file tr1_impl/regex.

   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 766 of file tr1_impl/regex.

   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 782 of file tr1_impl/regex.

   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 791 of file tr1_impl/regex.

   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 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 807 of file tr1_impl/regex.

   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 826 of file tr1_impl/regex.

   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 840 of file tr1_impl/regex.

   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 849 of file tr1_impl/regex.

Member Function Documentation
   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 982 of file tr1_impl/regex.

       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 _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 966 of file tr1_impl/regex.

       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 943 of file tr1_impl/regex.

       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, 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 927 of file tr1_impl/regex.

       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, 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 909 of file tr1_impl/regex.

       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
       basic_regex< _Ch_type, _Rx_traits > & __that) [inline]
       the real assignment operator. Parameters:
	   that Another regular expression object.

       Definition at line 888 of file tr1_impl/regex.

       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>>
       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 1001 of file tr1_impl/regex.

       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 1019 of file tr1_impl/regex.

   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 1011 of file tr1_impl/regex.

   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 993 of file tr1_impl/regex.

   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 878 of file tr1_impl/regex.

       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>>
       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 867 of file tr1_impl/regex.

       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>>
       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 856 of file tr1_impl/regex.

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

   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 1029 of file tr1_impl/regex.

       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++			  22 Nov 2013		   std::basic_regex(3)
[top]

List of man pages available for Scientific

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