28 Text processing library [text] (original) (raw)

28.6 Regular expressions library [re]

28.6.11 Regular expression iterators [re.iter]

28.6.11.1 Class template regex_iterator [re.regiter]

28.6.11.1.1 General [re.regiter.general]

28.6.11.1.2 Constructors [re.regiter.cnstr]

28.6.11.1.3 Comparisons [re.regiter.comp]

28.6.11.1.4 Indirection [re.regiter.deref]

28.6.11.1.5 Increment [re.regiter.incr]

28.6.11.1.1 General [re.regiter.general]

The class template regex_iterator is an iterator adaptor.

It represents a new view of an existing iterator sequence, by enumerating all the occurrences of a regular expression within that sequence.

A regex_iterator uses regex_search to find successive regular expression matches within the sequence from which it was constructed.

After the iterator is constructed, and every time operator++ is used, the iterator finds and stores a value ofmatch_results<BidirectionalIterator>.

If the end of the sequence is reached (regex_search returns false), the iterator becomes equal to the end-of-sequence iterator value.

The default constructor constructs an end-of-sequence iterator object, which is the only legitimate iterator to be used for the end condition.

The result of operator* on an end-of-sequence iterator is not defined.

For any other iterator value aconst match_results<BidirectionalIterator>& is returned.

The result ofoperator-> on an end-of-sequence iterator is not defined.

For any other iterator value a const match_results<BidirectionalIterator>* is returned.

It is impossible to store things into regex_iterators.

Two end-of-sequence iterators are always equal.

An end-of-sequence iterator is not equal to a non-end-of-sequence iterator.

Two non-end-of-sequence iterators are equal when they are constructed from the same arguments.

namespace std { template<class BidirectionalIterator,class charT = typename iterator_traits<BidirectionalIterator>::value_type,class traits = regex_traits<charT>> class regex_iterator { public: using regex_type = basic_regex<charT, traits>;using iterator_category = forward_iterator_tag;using iterator_concept = input_iterator_tag;using value_type = match_results<BidirectionalIterator>;using difference_type = ptrdiff_t;using pointer = const value_type*;using reference = const value_type&; regex_iterator(); regex_iterator(BidirectionalIterator a, BidirectionalIterator b,const regex_type& re, regex_constants::match_flag_type m = regex_constants::match_default); regex_iterator(BidirectionalIterator, BidirectionalIterator,const regex_type&&, regex_constants::match_flag_type = regex_constants::match_default) = delete; regex_iterator(const regex_iterator&); regex_iterator& operator=(const regex_iterator&);bool operator==(const regex_iterator&) const;bool operator==(default_sentinel_t) const { return *this == regex_iterator(); } const value_type& operator*() const;const value_type* operator->() const; regex_iterator& operator++(); regex_iterator operator++(int);private: BidirectionalIterator begin; BidirectionalIterator end; const regex_type* pregex; regex_constants::match_flag_type flags; match_results<BidirectionalIterator> match; };}

An object of type regex_iterator that is not an end-of-sequence iterator holds a zero-length match if match[0].matched == true andmatch[0].first == match[0].second.

[Note 1:

For example, this can occur when the part of the regular expression that matched consists only of an assertion (such as '^', '$','\b', '\B').

— _end note_]

28.6.11.1.2 Constructors [re.regiter.cnstr]

Effects: Constructs an end-of-sequence iterator.

regex_iterator(BidirectionalIterator a, BidirectionalIterator b,const regex_type& re, regex_constants::match_flag_type m = regex_constants::match_default);

Effects: Initializes begin and end toa and b, respectively, setspregex to addressof(re), sets flags tom, then calls regex_search(begin, end, match, *pregex, flags).

If this call returns false the constructor sets *this to the end-of-sequence iterator.

28.6.11.1.3 Comparisons [re.regiter.comp]

bool operator==(const regex_iterator& right) const;

Returns: true if *this and right are both end-of-sequence iterators or if the following conditions all hold:

otherwise false.

28.6.11.1.4 Indirection [re.regiter.deref]

const value_type& operator*() const;

const value_type* operator->() const;

Returns: addressof(match).

28.6.11.1.5 Increment [re.regiter.incr]

regex_iterator& operator++();

Effects: Constructs a local variable start of type BidirectionalIterator and initializes it with the value of match[0].second.

If the iterator holds a zero-length match and start == end the operator sets *this to the end-of-sequence iterator and returns *this.

Otherwise, if the iterator holds a zero-length match, the operator calls:regex_search(start, end, match, *pregex, flags | regex_constants::match_not_null | regex_constants::match_continuous)

If the call returns true the operator returns *this.

Otherwise the operator increments start and continues as if the most recent match was not a zero-length match.

If the most recent match was not a zero-length match, the operator setsflags to flags | regex_constants​::​match_prev_avail and calls regex_search(start, end, match, *pregex, flags).

If the call returnsfalse the iterator sets *this to the end-of-sequence iterator.

The iterator then returns *this.

In all cases in which the call to regex_search returns true,match.prefix().first shall be equal to the previous value ofmatch[0].second, and for each index i in the half-open range [0, match.size()) for which match[i].matched is true,match.position(i)shall return distance(begin, match[i].​first).

[Note 1:

This means that match.position(i) gives the offset from the beginning of the target sequence, which is often not the same as the offset from the sequence passed in the call to regex_search.

— _end note_]

It is unspecified how the implementation makes these adjustments.

[Note 2:

This means that an implementation can call an implementation-specific search function, in which case a program-defined specialization of regex_search will not be called.

— _end note_]

regex_iterator operator++(int);

Effects: As if by:regex_iterator tmp = *this;++(*this);return tmp;