From Jason Turner

[re.regiter]

C++17 → C++20 3.2 KB 29 lines
Current Draft | LaTeX Source
Archived: C++17 | C++20
Markdown: C++17 | C++20
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpn4rbf0fn/{from.md → to.md} +7 -14
tmp/tmpn4rbf0fn/{from.md → to.md} RENAMED
@@ -43,11 +43,10 @@ namespace std {
43
  const regex_type&&,
44
  regex_constants::match_flag_type = regex_constants::match_default) = delete;
45
  regex_iterator(const regex_iterator&);
46
  regex_iterator& operator=(const regex_iterator&);
47
  bool operator==(const regex_iterator&) const;
48
- bool operator!=(const regex_iterator&) const;
49
  const value_type& operator*() const;
50
  const value_type* operator->() const;
51
  regex_iterator& operator++();
52
  regex_iterator operator++(int);
53
 
@@ -67,11 +66,11 @@ iterator holds a *zero-length match* if `match[0].matched == true` and
67
 
68
  [*Note 1*: For example, this can occur when the part of the regular
69
  expression that matched consists only of an assertion (such as `'^'`,
70
  `'$'`, `'\b'`, `'\B'`). — *end note*]
71
 
72
- #### `regex_iterator` constructors <a id="re.regiter.cnstr">[[re.regiter.cnstr]]</a>
73
 
74
  ``` cpp
75
  regex_iterator();
76
  ```
77
 
@@ -82,15 +81,15 @@ regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
82
  const regex_type& re,
83
  regex_constants::match_flag_type m = regex_constants::match_default);
84
  ```
85
 
86
  *Effects:* Initializes `begin` and `end` to `a` and `b`, respectively,
87
- sets `pregex` to `&re`, sets `flags` to `m`, then calls
88
  `regex_search(begin, end, match, *pregex, flags)`. If this call returns
89
  `false` the constructor sets `*this` to the end-of-sequence iterator.
90
 
91
- #### `regex_iterator` comparisons <a id="re.regiter.comp">[[re.regiter.comp]]</a>
92
 
93
  ``` cpp
94
  bool operator==(const regex_iterator& right) const;
95
  ```
96
 
@@ -103,17 +102,11 @@ iterators or if the following conditions all hold:
103
  - `flags == right.flags`, and
104
  - `match[0] == right.match[0]`;
105
 
106
  otherwise `false`.
107
 
108
- ``` cpp
109
- bool operator!=(const regex_iterator& right) const;
110
- ```
111
-
112
- *Returns:* `!(*this == right)`.
113
-
114
- #### `regex_iterator` indirection <a id="re.regiter.deref">[[re.regiter.deref]]</a>
115
 
116
  ``` cpp
117
  const value_type& operator*() const;
118
  ```
119
 
@@ -121,13 +114,13 @@ const value_type& operator*() const;
121
 
122
  ``` cpp
123
  const value_type* operator->() const;
124
  ```
125
 
126
- *Returns:* `&match`.
127
 
128
- #### `regex_iterator` increment <a id="re.regiter.incr">[[re.regiter.incr]]</a>
129
 
130
  ``` cpp
131
  regex_iterator& operator++();
132
  ```
133
 
@@ -169,11 +162,11 @@ offset from the sequence passed in the call to
169
  `regex_search`. — *end note*]
170
 
171
  It is unspecified how the implementation makes these adjustments.
172
 
173
  [*Note 2*: This means that a compiler may call an
174
- implementation-specific search function, in which case a user-defined
175
  specialization of `regex_search` will not be called. — *end note*]
176
 
177
  ``` cpp
178
  regex_iterator operator++(int);
179
  ```
 
43
  const regex_type&&,
44
  regex_constants::match_flag_type = regex_constants::match_default) = delete;
45
  regex_iterator(const regex_iterator&);
46
  regex_iterator& operator=(const regex_iterator&);
47
  bool operator==(const regex_iterator&) const;
 
48
  const value_type& operator*() const;
49
  const value_type* operator->() const;
50
  regex_iterator& operator++();
51
  regex_iterator operator++(int);
52
 
 
66
 
67
  [*Note 1*: For example, this can occur when the part of the regular
68
  expression that matched consists only of an assertion (such as `'^'`,
69
  `'$'`, `'\b'`, `'\B'`). — *end note*]
70
 
71
+ #### Constructors <a id="re.regiter.cnstr">[[re.regiter.cnstr]]</a>
72
 
73
  ``` cpp
74
  regex_iterator();
75
  ```
76
 
 
81
  const regex_type& re,
82
  regex_constants::match_flag_type m = regex_constants::match_default);
83
  ```
84
 
85
  *Effects:* Initializes `begin` and `end` to `a` and `b`, respectively,
86
+ sets `pregex` to `addressof(re)`, sets `flags` to `m`, then calls
87
  `regex_search(begin, end, match, *pregex, flags)`. If this call returns
88
  `false` the constructor sets `*this` to the end-of-sequence iterator.
89
 
90
+ #### Comparisons <a id="re.regiter.comp">[[re.regiter.comp]]</a>
91
 
92
  ``` cpp
93
  bool operator==(const regex_iterator& right) const;
94
  ```
95
 
 
102
  - `flags == right.flags`, and
103
  - `match[0] == right.match[0]`;
104
 
105
  otherwise `false`.
106
 
107
+ #### Indirection <a id="re.regiter.deref">[[re.regiter.deref]]</a>
 
 
 
 
 
 
108
 
109
  ``` cpp
110
  const value_type& operator*() const;
111
  ```
112
 
 
114
 
115
  ``` cpp
116
  const value_type* operator->() const;
117
  ```
118
 
119
+ *Returns:* `addressof(match)`.
120
 
121
+ #### Increment <a id="re.regiter.incr">[[re.regiter.incr]]</a>
122
 
123
  ``` cpp
124
  regex_iterator& operator++();
125
  ```
126
 
 
162
  `regex_search`. — *end note*]
163
 
164
  It is unspecified how the implementation makes these adjustments.
165
 
166
  [*Note 2*: This means that a compiler may call an
167
+ implementation-specific search function, in which case a program-defined
168
  specialization of `regex_search` will not be called. — *end note*]
169
 
170
  ``` cpp
171
  regex_iterator operator++(int);
172
  ```