std::basic_regex::assign

Parameters

rgx

Another basic_regex object of the same type.

str

A string with the pattern to use as regular expression.
charT is the first class template paramameter (the character type).

flags

Flags used to interpret the regular expression.
One or more of these constants can be combined (using the bitwise OR operator, |) to form a valid bitmask value of type flag_type:

flag*	effects on syntax	Notes
icase	Case insensitive	Regular expressions match without regard to case.
nosubs	No sub-expressions	The match_results structure will not contain sub-expression matches.
optimize	Optimize matching	Matching efficiency is preferred over efficiency constructing regex objects.
collate	Locale sensitiveness	Character ranges, like "[a-b]", are affected by locale.
ECMAScript	ECMAScript grammar	The regular expression follows one of these grammars. One (and only one) of these six grammar flags needs to be set for the bitmask to have a valid value. By default, ECMAScript is selected.
basic	Basic POSIX grammar
extended	Extended POSIX grammar
awk	Awk POSIX grammar
grep	Grep POSIX grammar
egrep	Egrep POSIX grammar

* These bitmask flag names are member constants of basic_regex. They are also availabe as global constants under the std::regex_constants namespace (see regex_constants for more details).
flag_type is a member type, defined as an alias of the bitmask type regex_constants::syntax_option_type.

len

Length of string str, with str being an array of characters, not necessarily null-terminated.
size_t is an unsigned integral type.

first, last

Forward iterators to the initial and final positions in a range of characters. The range used is [first,last), which includes all the characters between first and last, including the character pointed by first but not the character pointed by last.
The function template type can be any type of forward iterator to characters.

il

An initializer_list of characters. These objects are automatically constructed from initializer list declarators.

Return value

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// basic_regex::assign
// note: using regex, a standard alias of basic_regex<char>
#include <iostream>
#include <string>
#include <regex>

int main ()
{
  std::string pattern ("six");
  std::regex first;
  std::regex second (pattern);


  first.assign (second);
  second.assign ("[0-9A-F]+", std::regex::ECMAScript);
  second.assign ({'^','a'}, std::regex::ECMAScript | std::regex::icase );

  using namespace std::regex_constants;                // introducing constants 
  second.assign (pattern, ECMAScript | icase );

  std::string subject = "Sixty six";
  std::string replacement = "seven";

  std::cout << "first: " << std::regex_replace (subject, first, replacement);
  std::cout << std::endl;

  std::cout << "second: " << std::regex_replace (subject, second, replacement);
  std::cout << std::endl;

  return 0;
}

first: Sixty seven
second: seventy seven

See also

basic_regex::basic_regex

Construct regex (public member function)

basic_regex::operator=

Assign regular expression (public member function)