home | help 
std::basic_...:basic_regex(3)  C++ Standard Libary std::basic_...:basic_regex(3)

NAME
     std::basic_regex::basic_regex - std::basic_regex::basic_regex

Synopsis
	basic_regex();							     (1)
     (since C++11)
	explicit basic_regex( const CharT* s,
			      flag_type f  =				     (2)
     (since C++11)
	std::regex_constants::ECMAScript );
	basic_regex(  const  CharT* s, std::size_t count,		     (3)
     (since C++11)
		     flag_type f = std::regex_constants::ECMAScript );
	basic_regex( const basic_regex& other  );			     (4)
     (since C++11)
	basic_regex(  basic_regex&&  other ) noexcept;			     (5)
     (since C++11)
	template< class ST, class SA >

	explicit basic_regex( const std::basic_string<CharT,ST,SA>&  str,    (6)
     (since C++11)

			      flag_type f =
	std::regex_constants::ECMAScript );
	template< class ForwardIt >

	basic_regex(  ForwardIt  first, ForwardIt last, 		     (7)
     (since C++11)

		     flag_type f = std::regex_constants::ECMAScript );
	basic_regex( std::initializer_list<CharT>  init,		     (8)
     (since C++11)
		     flag_type f = std::regex_constants::ECMAScript );

	Constructs a new regular expression from a sequence of characters inter-
     preted
	according to the flags f.

	1)  Default  constructor.  Constructs  an empty regular expression which
     will match
	nothing.
	2) Constructs a regex from a null-terminated string s.
	3) Constructs a regex from a sequence of count characters, pointed to by
     s.
	4) Copy constructor. Constructs a regex by copying other.
	5) Move constructor. Constructs a regex with the contents of other using
     move
	semantics.
	6) Constructs a regex from a string str.
	7) Range constructor. Constructs the string with  the  contents  of  the
     range
	[first, last).
	8) Initializer list constructor. Constructs the string with the contents
     of the
	initializer list init.

Parameters
	s	    - pointer to a null-terminated string
	count	     -	length	of  a  character sequence used to initialize the
     regex
	first, last - range of a character sequence used to initialize the regex
	str	    - a basic_string used as a source  used  to  initialize  the
     regex
	other	    - another regex to use as source to initialize the regex
	init	    - initializer list used to initialize the regex
	f	     -	flags  used to guide the interpretation of the character
     sequence as a
		      regular expression

Type requirements
	-
	ForwardIt must meet the requirements of LegacyForwardIterator.

Exceptions
	1) May throw implementation-defined exceptions.
	2,3) std::regex_error if the supplied regular expression is not valid.
	4) May throw implementation-defined exceptions.
	6-8) std::regex_error if the supplied regular expression is not valid.

Example
     // Run this code

      #include <iomanip>
      #include <iostream>
      #include <regex>
      #include <string>

      void match_and_print(const std::string& text, const std::regex& pattern)
      {
	  std::sregex_iterator it(text.begin(), text.end(), pattern), it_end;
	  int count = 0;
	  for (; it != it_end; ++it)
	  {
	      const std::smatch& match = *it;
	      std::cout << ++count << ". " << std::quoted(match.str()) << '\n';
	  }
	  std::cout << (count ? "\n" : "no match found\n\n");
      }

      int main()
      {
	  const std::string text = "Hello, World! 12345";

	  // Matches one or more digits
	  std::string pattern_text = "\\d+";
	  std::cout << "digits (" << pattern_text << "):\n";
	  auto pattern = std::regex(pattern_text);
	  match_and_print(text, pattern);

	  // Matches one or more characters split by space
	  pattern_text = "[^\\s]+";
	  std::cout << "words (" << pattern_text << "):\n";
	  pattern = std::regex(pattern_text);
	  match_and_print(text, pattern);

	  // Matches one or more characters split by space
	  pattern_text = "[a-zA-Z]+";
	  std::cout << "words without symbols and digits (" <<	pattern_text  <<
     "):\n";
	  pattern = std::regex(pattern_text);
	  match_and_print(text, pattern);

	  // Matches one non digits, non alphabet
	  pattern_text = "[^0-9A-Za-z]";
	  std::cout << "symbol (" << pattern_text << "):\n";
	  pattern = std::regex(pattern_text);
	  match_and_print(text, pattern);

	  // Matches one or more lowercase
	  pattern_text = "[a-z]+";
	  std::cout << "lowercase (" << pattern_text << "):\n";
	  pattern = std::regex(pattern_text);
	  match_and_print(text, pattern);

	  // Matches one or more lowercase with std::regex::icase flag
	  pattern_text = "[a-z]+";
	  std::cout  <<  "lowercase  with ignore case flag (" << pattern_text <<
     "):\n";
	  pattern = std::regex(pattern_text, std::regex::icase);
	  match_and_print(text, pattern);

	  // Matches basic POSIX regular expression
	  pattern_text = "[[:digit:]]+";
	  std::cout << "basic POSIX regex (" << pattern_text << "):\n";
	  pattern = std::regex(pattern_text, std::regex::basic);
	  match_and_print(text, pattern);

	  // Matches extended POSIX regular expression
	  pattern_text = "[[:digit:]]+";
	  std::cout << "extended POSIX regex (" << pattern_text << "):\n";
	  pattern = std::regex(pattern_text, std::regex::extended);
	  match_and_print(text, pattern);
      }

Output:
      digits (\d+):
      1. "12345"

      words ([^\s]+):
      1. "Hello,"
      2. "World!"
      3. "12345"

      words without symbols and digits ([a-zA-Z]+):
      1. "Hello"
      2. "World"

      symbol ([^0-9A-Za-z]):
      1. ","
      2. " "
      3. "!"
      4. " "

      lowercase ([a-z]+):
      1. "ello"
      2. "orld"

      lowercase with ignore case flag ([a-z]+):
      1. "Hello"
      2. "World"

      basic POSIX regex ([[:digit:]]+):
      no match found

      extended POSIX regex ([[:digit:]]+):
      1. "12345"

http://cppreference.com 	   2024.06.10	   std::basic_...:basic_regex(3)
home | help