std::regex_token_iterator::regex_token_iterator

Parameters

rti

Another object of the same regex_token_iterator type (with the same template parameters).

first, last

Bidirectional iterators to the initial and final positions in the range of characters used as target sequence for the search. 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.
BidirectionalIterator is the first class template parameter, that shall be bidirectional iterator to characters.

rgx

A basic_regex object (the pattern) to match.
Note: the iterator does not keep a copy of this object (only a reference), therefore this should not be a temporary value.
regex_type is a member type, defined as an alias of the basic_regex type corresponding to the class template parameters.

submatch

The sub_match to be selected on each position of the iterator.
If this is 0, the entire match is selected.
If this is -1, the section of the sequence that is not matched is selected, using the match as separator.

submatches

Same as above, except that, if there are more that one int passed, the iterator will need to be advanced as many times to get to the next match, selecting on each instance the corresponding submatch (see regex_token_iterator::operator++).

flags

Flags used to control how rgx is matched.
One or more of these constants can be combined (using the bitwise OR operator, |) to form a valid bitmask value of type regex_constants::match_flag_type:

flag*	effects on match	notes
match_default	Default	Default matching behavior. This constant has a value of zero**.
match_not_bol	Not Beginning-Of-Line	The first character is not considered a beginning of line ("^" does not match).
match_not_eol	Not End-Of-Line	The last character is not considered an end of line ("$" does not match).
match_not_bow	Not Beginning-Of-Word	The escape sequence "\b" does not match as a beginning-of-word.
match_not_eow	Not End-Of-Word	The escape sequence "\b" does not match as an end-of-word.
match_any	Any match	Any match is acceptable if more than one match is possible.
match_not_null	Not null	Empty sequences do not match.
match_continuous	Continuous	The expression must match a sub-sequence that begins at the first character. Sub-sequences must begin at the first character to match.
match_prev_avail	Previous Available	One or more characters exist before the first one. (match_not_bol and match_not_bow are ignored)
format_default	Default	Same as match_default. This constant has a value of zero**.
format_sed	None	Ignored by this object. See regex_constants for more info.
format_no_copy
format_first_only

* These bitmask flag names are available under the std::regex_constants namespace (see regex_constants for more details).
** Constants with a value of zero are ignored if some other flag is set.
match_flag_type is a type available under the std::regex_constants namespace.

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
32
33
34
35
36

// regex_token_iterator example
#include <iostream>
#include <string>
#include <regex>

int main ()
{
  std::string s ("this subject has a submarine as a subsequence");
  std::regex e ("\\b(sub)([^ ]*)");   // matches words beginning by "sub"

  // default constructor = end-of-sequence:
  std::regex_token_iterator<std::string::iterator> rend;

  std::cout << "entire matches:"; 
  std::regex_token_iterator<std::string::iterator> a ( s.begin(), s.end(), e );
  while (a!=rend) std::cout << " [" << *a++ << "]";
  std::cout << std::endl;

  std::cout << "2nd submatches:";
  std::regex_token_iterator<std::string::iterator> b ( s.begin(), s.end(), e, 2 );
  while (b!=rend) std::cout << " [" << *b++ << "]";
  std::cout << std::endl;

  std::cout << "1st and 2nd submatches:";
  int submatches[] = { 1, 2 };
  std::regex_token_iterator<std::string::iterator> c ( s.begin(), s.end(), e, submatches );
  while (c!=rend) std::cout << " [" << *c++ << "]";
  std::cout << std::endl;

  std::cout << "matches as splitters:";
  std::regex_token_iterator<std::string::iterator> d ( s.begin(), s.end(), e, -1 );
  while (d!=rend) std::cout << " [" << *d++ << "]";
  std::cout << std::endl;

  return 0;
}

entire matches: [subject] [submarine] [subsequence]
2nd submatches: [ject] [marine] [sequence]
1st and 2nd submatches: [sub] [ject] [sub] [marine] [sub] [sequence]
matches as splitters: [this ] [ has a ] [ as a ]

See also

regex_search

Search sequence (function template )

regex_iterator

Regex iterator (class template )