From Jason Turner

[re.syn]

C++14 → C++17 25.7 KB 263 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp7ks84rvy/{from.md → to.md} +115 -144
tmp/tmp7ks84rvy/{from.md → to.md} RENAMED
@@ -2,42 +2,43 @@
2
 
3
  ``` cpp
4
  #include <initializer_list>
5
 
6
  namespace std {
7
-
8
- // [re.const], regex constants:
9
  namespace regex_constants {
10
- enum error_type;
11
- } // namespace regex_constants
 
 
12
 
13
- // [re.badexp], class regex_error:
14
  class regex_error;
15
 
16
- // [re.traits], class template regex_traits:
17
  template <class charT> struct regex_traits;
18
 
19
- // [re.regex], class template basic_regex:
20
  template <class charT, class traits = regex_traits<charT>> class basic_regex;
21
 
22
- typedef basic_regex<char> regex;
23
- typedef basic_regex<wchar_t> wregex;
24
 
25
- // [re.regex.swap], basic_regex swap:
26
  template <class charT, class traits>
27
  void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2);
28
 
29
- // [re.submatch], class template sub_match:
30
  template <class BidirectionalIterator>
31
  class sub_match;
32
 
33
- typedef sub_match<const char*> csub_match;
34
- typedef sub_match<const wchar_t*> wcsub_match;
35
- typedef sub_match<string::const_iterator> ssub_match;
36
- typedef sub_match<wstring::const_iterator> wssub_match;
37
 
38
- // [re.submatch.op], sub_match non-member operators:
39
  template <class BiIter>
40
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
41
  template <class BiIter>
42
  bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
43
  template <class BiIter>
@@ -47,337 +48,307 @@ namespace std {
47
  template <class BiIter>
48
  bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
49
  template <class BiIter>
50
  bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
51
 
52
-
53
  template <class BiIter, class ST, class SA>
54
  bool operator==(
55
- const basic_string<
56
- typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
57
  const sub_match<BiIter>& rhs);
58
  template <class BiIter, class ST, class SA>
59
  bool operator!=(
60
- const basic_string<
61
- typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
62
  const sub_match<BiIter>& rhs);
63
  template <class BiIter, class ST, class SA>
64
  bool operator<(
65
- const basic_string<
66
- typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
67
  const sub_match<BiIter>& rhs);
68
  template <class BiIter, class ST, class SA>
69
  bool operator>(
70
- const basic_string<
71
- typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
72
  const sub_match<BiIter>& rhs);
73
  template <class BiIter, class ST, class SA>
74
  bool operator>=(
75
- const basic_string<
76
- typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
77
  const sub_match<BiIter>& rhs);
78
  template <class BiIter, class ST, class SA>
79
  bool operator<=(
80
- const basic_string<
81
- typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
82
  const sub_match<BiIter>& rhs);
83
 
84
  template <class BiIter, class ST, class SA>
85
  bool operator==(
86
  const sub_match<BiIter>& lhs,
87
- const basic_string<
88
- typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
89
  template <class BiIter, class ST, class SA>
90
  bool operator!=(
91
  const sub_match<BiIter>& lhs,
92
- const basic_string<
93
- typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
94
  template <class BiIter, class ST, class SA>
95
  bool operator<(
96
  const sub_match<BiIter>& lhs,
97
- const basic_string<
98
- typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
99
  template <class BiIter, class ST, class SA>
100
  bool operator>(
101
  const sub_match<BiIter>& lhs,
102
- const basic_string<
103
- typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
104
  template <class BiIter, class ST, class SA>
105
  bool operator>=(
106
  const sub_match<BiIter>& lhs,
107
- const basic_string<
108
- typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
109
  template <class BiIter, class ST, class SA>
110
  bool operator<=(
111
  const sub_match<BiIter>& lhs,
112
- const basic_string<
113
- typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
114
 
115
  template <class BiIter>
116
- bool operator==(typename iterator_traits<BiIter>::value_type const* lhs,
117
  const sub_match<BiIter>& rhs);
118
  template <class BiIter>
119
- bool operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
120
  const sub_match<BiIter>& rhs);
121
  template <class BiIter>
122
- bool operator<(typename iterator_traits<BiIter>::value_type const* lhs,
123
  const sub_match<BiIter>& rhs);
124
  template <class BiIter>
125
- bool operator>(typename iterator_traits<BiIter>::value_type const* lhs,
126
  const sub_match<BiIter>& rhs);
127
  template <class BiIter>
128
- bool operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
129
  const sub_match<BiIter>& rhs);
130
  template <class BiIter>
131
- bool operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
132
  const sub_match<BiIter>& rhs);
133
 
134
  template <class BiIter>
135
  bool operator==(const sub_match<BiIter>& lhs,
136
- typename iterator_traits<BiIter>::value_type const* rhs);
137
  template <class BiIter>
138
  bool operator!=(const sub_match<BiIter>& lhs,
139
- typename iterator_traits<BiIter>::value_type const* rhs);
140
  template <class BiIter>
141
  bool operator<(const sub_match<BiIter>& lhs,
142
- typename iterator_traits<BiIter>::value_type const* rhs);
143
  template <class BiIter>
144
  bool operator>(const sub_match<BiIter>& lhs,
145
- typename iterator_traits<BiIter>::value_type const* rhs);
146
  template <class BiIter>
147
  bool operator>=(const sub_match<BiIter>& lhs,
148
- typename iterator_traits<BiIter>::value_type const* rhs);
149
  template <class BiIter>
150
  bool operator<=(const sub_match<BiIter>& lhs,
151
- typename iterator_traits<BiIter>::value_type const* rhs);
152
 
153
  template <class BiIter>
154
- bool operator==(typename iterator_traits<BiIter>::value_type const& lhs,
155
  const sub_match<BiIter>& rhs);
156
  template <class BiIter>
157
- bool operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
158
  const sub_match<BiIter>& rhs);
159
  template <class BiIter>
160
- bool operator<(typename iterator_traits<BiIter>::value_type const& lhs,
161
  const sub_match<BiIter>& rhs);
162
  template <class BiIter>
163
- bool operator>(typename iterator_traits<BiIter>::value_type const& lhs,
164
  const sub_match<BiIter>& rhs);
165
  template <class BiIter>
166
- bool operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
167
  const sub_match<BiIter>& rhs);
168
  template <class BiIter>
169
- bool operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
170
  const sub_match<BiIter>& rhs);
171
 
172
  template <class BiIter>
173
  bool operator==(const sub_match<BiIter>& lhs,
174
- typename iterator_traits<BiIter>::value_type const& rhs);
175
  template <class BiIter>
176
  bool operator!=(const sub_match<BiIter>& lhs,
177
- typename iterator_traits<BiIter>::value_type const& rhs);
178
  template <class BiIter>
179
  bool operator<(const sub_match<BiIter>& lhs,
180
- typename iterator_traits<BiIter>::value_type const& rhs);
181
  template <class BiIter>
182
  bool operator>(const sub_match<BiIter>& lhs,
183
- typename iterator_traits<BiIter>::value_type const& rhs);
184
  template <class BiIter>
185
  bool operator>=(const sub_match<BiIter>& lhs,
186
- typename iterator_traits<BiIter>::value_type const& rhs);
187
  template <class BiIter>
188
  bool operator<=(const sub_match<BiIter>& lhs,
189
- typename iterator_traits<BiIter>::value_type const& rhs);
190
 
191
  template <class charT, class ST, class BiIter>
192
  basic_ostream<charT, ST>&
193
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
194
 
195
- // [re.results], class template match_results:
196
  template <class BidirectionalIterator,
197
  class Allocator = allocator<sub_match<BidirectionalIterator>>>
198
  class match_results;
199
 
200
- typedef match_results<const char*> cmatch;
201
- typedef match_results<const wchar_t*> wcmatch;
202
- typedef match_results<string::const_iterator> smatch;
203
- typedef match_results<wstring::const_iterator> wsmatch;
204
 
205
  // match_results comparisons
206
  template <class BidirectionalIterator, class Allocator>
207
  bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
208
  const match_results<BidirectionalIterator, Allocator>& m2);
209
  template <class BidirectionalIterator, class Allocator>
210
  bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
211
  const match_results<BidirectionalIterator, Allocator>& m2);
212
 
213
- // [re.results.swap], match_results swap:
214
  template <class BidirectionalIterator, class Allocator>
215
  void swap(match_results<BidirectionalIterator, Allocator>& m1,
216
  match_results<BidirectionalIterator, Allocator>& m2);
217
 
218
- // [re.alg.match], function template regex_match:
219
- template <class BidirectionalIterator, class Allocator,
220
- class charT, class traits>
221
  bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
222
  match_results<BidirectionalIterator, Allocator>& m,
223
  const basic_regex<charT, traits>& e,
224
- regex_constants::match_flag_type flags =
225
- regex_constants::match_default);
226
  template <class BidirectionalIterator, class charT, class traits>
227
  bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
228
  const basic_regex<charT, traits>& e,
229
- regex_constants::match_flag_type flags =
230
- regex_constants::match_default);
231
  template <class charT, class Allocator, class traits>
232
  bool regex_match(const charT* str, match_results<const charT*, Allocator>& m,
233
  const basic_regex<charT, traits>& e,
234
- regex_constants::match_flag_type flags =
235
- regex_constants::match_default);
236
  template <class ST, class SA, class Allocator, class charT, class traits>
237
  bool regex_match(const basic_string<charT, ST, SA>& s,
238
- match_results<
239
- typename basic_string<charT, ST, SA>::const_iterator,
240
  Allocator>& m,
241
  const basic_regex<charT, traits>& e,
242
- regex_constants::match_flag_type flags =
243
- regex_constants::match_default);
244
  template <class ST, class SA, class Allocator, class charT, class traits>
245
  bool regex_match(const basic_string<charT, ST, SA>&&,
246
- match_results<
247
- typename basic_string<charT, ST, SA>::const_iterator,
248
  Allocator>&,
249
  const basic_regex<charT, traits>&,
250
- regex_constants::match_flag_type =
251
- regex_constants::match_default) = delete;
252
  template <class charT, class traits>
253
  bool regex_match(const charT* str,
254
  const basic_regex<charT, traits>& e,
255
- regex_constants::match_flag_type flags =
256
- regex_constants::match_default);
257
  template <class ST, class SA, class charT, class traits>
258
  bool regex_match(const basic_string<charT, ST, SA>& s,
259
  const basic_regex<charT, traits>& e,
260
- regex_constants::match_flag_type flags =
261
- regex_constants::match_default);
262
 
263
- // [re.alg.search], function template regex_search:
264
- template <class BidirectionalIterator, class Allocator,
265
- class charT, class traits>
266
  bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
267
  match_results<BidirectionalIterator, Allocator>& m,
268
  const basic_regex<charT, traits>& e,
269
- regex_constants::match_flag_type flags =
270
- regex_constants::match_default);
271
  template <class BidirectionalIterator, class charT, class traits>
272
  bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
273
  const basic_regex<charT, traits>& e,
274
- regex_constants::match_flag_type flags =
275
- regex_constants::match_default);
276
  template <class charT, class Allocator, class traits>
277
  bool regex_search(const charT* str,
278
  match_results<const charT*, Allocator>& m,
279
  const basic_regex<charT, traits>& e,
280
- regex_constants::match_flag_type flags =
281
- regex_constants::match_default);
282
  template <class charT, class traits>
283
  bool regex_search(const charT* str,
284
  const basic_regex<charT, traits>& e,
285
- regex_constants::match_flag_type flags =
286
- regex_constants::match_default);
287
  template <class ST, class SA, class charT, class traits>
288
  bool regex_search(const basic_string<charT, ST, SA>& s,
289
  const basic_regex<charT, traits>& e,
290
- regex_constants::match_flag_type flags =
291
- regex_constants::match_default);
292
  template <class ST, class SA, class Allocator, class charT, class traits>
293
  bool regex_search(const basic_string<charT, ST, SA>& s,
294
- match_results<
295
- typename basic_string<charT, ST, SA>::const_iterator,
296
  Allocator>& m,
297
  const basic_regex<charT, traits>& e,
298
- regex_constants::match_flag_type flags =
299
- regex_constants::match_default);
300
  template <class ST, class SA, class Allocator, class charT, class traits>
301
  bool regex_search(const basic_string<charT, ST, SA>&&,
302
- match_results<
303
- typename basic_string<charT, ST, SA>::const_iterator,
304
  Allocator>&,
305
  const basic_regex<charT, traits>&,
306
- regex_constants::match_flag_type =
307
- regex_constants::match_default) = delete;
308
 
309
- // [re.alg.replace], function template regex_replace:
310
  template <class OutputIterator, class BidirectionalIterator,
311
  class traits, class charT, class ST, class SA>
312
  OutputIterator
313
  regex_replace(OutputIterator out,
314
  BidirectionalIterator first, BidirectionalIterator last,
315
  const basic_regex<charT, traits>& e,
316
  const basic_string<charT, ST, SA>& fmt,
317
- regex_constants::match_flag_type flags =
318
- regex_constants::match_default);
319
- template <class OutputIterator, class BidirectionalIterator,
320
- class traits, class charT>
321
  OutputIterator
322
  regex_replace(OutputIterator out,
323
  BidirectionalIterator first, BidirectionalIterator last,
324
  const basic_regex<charT, traits>& e,
325
  const charT* fmt,
326
- regex_constants::match_flag_type flags =
327
- regex_constants::match_default);
328
- template <class traits, class charT, class ST, class SA,
329
- class FST, class FSA>
330
  basic_string<charT, ST, SA>
331
  regex_replace(const basic_string<charT, ST, SA>& s,
332
  const basic_regex<charT, traits>& e,
333
  const basic_string<charT, FST, FSA>& fmt,
334
- regex_constants::match_flag_type flags =
335
- regex_constants::match_default);
336
  template <class traits, class charT, class ST, class SA>
337
  basic_string<charT, ST, SA>
338
  regex_replace(const basic_string<charT, ST, SA>& s,
339
  const basic_regex<charT, traits>& e,
340
  const charT* fmt,
341
- regex_constants::match_flag_type flags =
342
- regex_constants::match_default);
343
  template <class traits, class charT, class ST, class SA>
344
  basic_string<charT>
345
  regex_replace(const charT* s,
346
  const basic_regex<charT, traits>& e,
347
  const basic_string<charT, ST, SA>& fmt,
348
- regex_constants::match_flag_type flags =
349
- regex_constants::match_default);
350
  template <class traits, class charT>
351
  basic_string<charT>
352
  regex_replace(const charT* s,
353
  const basic_regex<charT, traits>& e,
354
  const charT* fmt,
355
- regex_constants::match_flag_type flags =
356
- regex_constants::match_default);
357
 
358
- // [re.regiter], class template regex_iterator:
359
  template <class BidirectionalIterator,
360
- class charT = typename iterator_traits<
361
- BidirectionalIterator>::value_type,
362
  class traits = regex_traits<charT>>
363
  class regex_iterator;
364
 
365
- typedef regex_iterator<const char*> cregex_iterator;
366
- typedef regex_iterator<const wchar_t*> wcregex_iterator;
367
- typedef regex_iterator<string::const_iterator> sregex_iterator;
368
- typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
369
 
370
- // [re.tokiter], class template regex_token_iterator:
371
  template <class BidirectionalIterator,
372
- class charT = typename iterator_traits<
373
- BidirectionalIterator>::value_type,
374
  class traits = regex_traits<charT>>
375
  class regex_token_iterator;
376
 
377
- typedef regex_token_iterator<const char*> cregex_token_iterator;
378
- typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
379
- typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
380
- typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 
 
 
 
 
 
 
 
 
 
 
381
  }
382
  ```
383
 
 
2
 
3
  ``` cpp
4
  #include <initializer_list>
5
 
6
  namespace std {
7
+ // [re.const], regex constants
 
8
  namespace regex_constants {
9
+ using syntax_option_type = T1;
10
+ using match_flag_type = T2;
11
+ using error_type = T3;
12
+ }
13
 
14
+ // [re.badexp], class regex_error
15
  class regex_error;
16
 
17
+ // [re.traits], class template regex_traits
18
  template <class charT> struct regex_traits;
19
 
20
+ // [re.regex], class template basic_regex
21
  template <class charT, class traits = regex_traits<charT>> class basic_regex;
22
 
23
+ using regex = basic_regex<char>;
24
+ using wregex = basic_regex<wchar_t>;
25
 
26
+ // [re.regex.swap], basic_regex swap
27
  template <class charT, class traits>
28
  void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2);
29
 
30
+ // [re.submatch], class template sub_match
31
  template <class BidirectionalIterator>
32
  class sub_match;
33
 
34
+ using csub_match = sub_match<const char*>;
35
+ using wcsub_match = sub_match<const wchar_t*>;
36
+ using ssub_match = sub_match<string::const_iterator>;
37
+ using wssub_match = sub_match<wstring::const_iterator>;
38
 
39
+ // [re.submatch.op], sub_match non-member operators
40
  template <class BiIter>
41
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
42
  template <class BiIter>
43
  bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
44
  template <class BiIter>
 
48
  template <class BiIter>
49
  bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
50
  template <class BiIter>
51
  bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
52
 
 
53
  template <class BiIter, class ST, class SA>
54
  bool operator==(
55
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
 
56
  const sub_match<BiIter>& rhs);
57
  template <class BiIter, class ST, class SA>
58
  bool operator!=(
59
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
 
60
  const sub_match<BiIter>& rhs);
61
  template <class BiIter, class ST, class SA>
62
  bool operator<(
63
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
 
64
  const sub_match<BiIter>& rhs);
65
  template <class BiIter, class ST, class SA>
66
  bool operator>(
67
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
 
68
  const sub_match<BiIter>& rhs);
69
  template <class BiIter, class ST, class SA>
70
  bool operator>=(
71
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
 
72
  const sub_match<BiIter>& rhs);
73
  template <class BiIter, class ST, class SA>
74
  bool operator<=(
75
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
 
76
  const sub_match<BiIter>& rhs);
77
 
78
  template <class BiIter, class ST, class SA>
79
  bool operator==(
80
  const sub_match<BiIter>& lhs,
81
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
82
  template <class BiIter, class ST, class SA>
83
  bool operator!=(
84
  const sub_match<BiIter>& lhs,
85
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
86
  template <class BiIter, class ST, class SA>
87
  bool operator<(
88
  const sub_match<BiIter>& lhs,
89
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
90
  template <class BiIter, class ST, class SA>
91
  bool operator>(
92
  const sub_match<BiIter>& lhs,
93
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
94
  template <class BiIter, class ST, class SA>
95
  bool operator>=(
96
  const sub_match<BiIter>& lhs,
97
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
98
  template <class BiIter, class ST, class SA>
99
  bool operator<=(
100
  const sub_match<BiIter>& lhs,
101
+ const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
102
 
103
  template <class BiIter>
104
+ bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
105
  const sub_match<BiIter>& rhs);
106
  template <class BiIter>
107
+ bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
108
  const sub_match<BiIter>& rhs);
109
  template <class BiIter>
110
+ bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
111
  const sub_match<BiIter>& rhs);
112
  template <class BiIter>
113
+ bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
114
  const sub_match<BiIter>& rhs);
115
  template <class BiIter>
116
+ bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
117
  const sub_match<BiIter>& rhs);
118
  template <class BiIter>
119
+ bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
120
  const sub_match<BiIter>& rhs);
121
 
122
  template <class BiIter>
123
  bool operator==(const sub_match<BiIter>& lhs,
124
+ const typename iterator_traits<BiIter>::value_type* rhs);
125
  template <class BiIter>
126
  bool operator!=(const sub_match<BiIter>& lhs,
127
+ const typename iterator_traits<BiIter>::value_type* rhs);
128
  template <class BiIter>
129
  bool operator<(const sub_match<BiIter>& lhs,
130
+ const typename iterator_traits<BiIter>::value_type* rhs);
131
  template <class BiIter>
132
  bool operator>(const sub_match<BiIter>& lhs,
133
+ const typename iterator_traits<BiIter>::value_type* rhs);
134
  template <class BiIter>
135
  bool operator>=(const sub_match<BiIter>& lhs,
136
+ const typename iterator_traits<BiIter>::value_type* rhs);
137
  template <class BiIter>
138
  bool operator<=(const sub_match<BiIter>& lhs,
139
+ const typename iterator_traits<BiIter>::value_type* rhs);
140
 
141
  template <class BiIter>
142
+ bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
143
  const sub_match<BiIter>& rhs);
144
  template <class BiIter>
145
+ bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
146
  const sub_match<BiIter>& rhs);
147
  template <class BiIter>
148
+ bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
149
  const sub_match<BiIter>& rhs);
150
  template <class BiIter>
151
+ bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
152
  const sub_match<BiIter>& rhs);
153
  template <class BiIter>
154
+ bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
155
  const sub_match<BiIter>& rhs);
156
  template <class BiIter>
157
+ bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
158
  const sub_match<BiIter>& rhs);
159
 
160
  template <class BiIter>
161
  bool operator==(const sub_match<BiIter>& lhs,
162
+ const typename iterator_traits<BiIter>::value_type& rhs);
163
  template <class BiIter>
164
  bool operator!=(const sub_match<BiIter>& lhs,
165
+ const typename iterator_traits<BiIter>::value_type& rhs);
166
  template <class BiIter>
167
  bool operator<(const sub_match<BiIter>& lhs,
168
+ const typename iterator_traits<BiIter>::value_type& rhs);
169
  template <class BiIter>
170
  bool operator>(const sub_match<BiIter>& lhs,
171
+ const typename iterator_traits<BiIter>::value_type& rhs);
172
  template <class BiIter>
173
  bool operator>=(const sub_match<BiIter>& lhs,
174
+ const typename iterator_traits<BiIter>::value_type& rhs);
175
  template <class BiIter>
176
  bool operator<=(const sub_match<BiIter>& lhs,
177
+ const typename iterator_traits<BiIter>::value_type& rhs);
178
 
179
  template <class charT, class ST, class BiIter>
180
  basic_ostream<charT, ST>&
181
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
182
 
183
+ // [re.results], class template match_results
184
  template <class BidirectionalIterator,
185
  class Allocator = allocator<sub_match<BidirectionalIterator>>>
186
  class match_results;
187
 
188
+ using cmatch = match_results<const char*>;
189
+ using wcmatch = match_results<const wchar_t*>;
190
+ using smatch = match_results<string::const_iterator>;
191
+ using wsmatch = match_results<wstring::const_iterator>;
192
 
193
  // match_results comparisons
194
  template <class BidirectionalIterator, class Allocator>
195
  bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
196
  const match_results<BidirectionalIterator, Allocator>& m2);
197
  template <class BidirectionalIterator, class Allocator>
198
  bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
199
  const match_results<BidirectionalIterator, Allocator>& m2);
200
 
201
+ // [re.results.swap], match_results swap
202
  template <class BidirectionalIterator, class Allocator>
203
  void swap(match_results<BidirectionalIterator, Allocator>& m1,
204
  match_results<BidirectionalIterator, Allocator>& m2);
205
 
206
+ // [re.alg.match], function template regex_match
207
+ template <class BidirectionalIterator, class Allocator, class charT, class traits>
 
208
  bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
209
  match_results<BidirectionalIterator, Allocator>& m,
210
  const basic_regex<charT, traits>& e,
211
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
212
  template <class BidirectionalIterator, class charT, class traits>
213
  bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
214
  const basic_regex<charT, traits>& e,
215
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
216
  template <class charT, class Allocator, class traits>
217
  bool regex_match(const charT* str, match_results<const charT*, Allocator>& m,
218
  const basic_regex<charT, traits>& e,
219
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
220
  template <class ST, class SA, class Allocator, class charT, class traits>
221
  bool regex_match(const basic_string<charT, ST, SA>& s,
222
+ match_results<typename basic_string<charT, ST, SA>::const_iterator,
 
223
  Allocator>& m,
224
  const basic_regex<charT, traits>& e,
225
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
226
  template <class ST, class SA, class Allocator, class charT, class traits>
227
  bool regex_match(const basic_string<charT, ST, SA>&&,
228
+ match_results<typename basic_string<charT, ST, SA>::const_iterator,
 
229
  Allocator>&,
230
  const basic_regex<charT, traits>&,
231
+ regex_constants::match_flag_type = regex_constants::match_default) = delete;
 
232
  template <class charT, class traits>
233
  bool regex_match(const charT* str,
234
  const basic_regex<charT, traits>& e,
235
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
236
  template <class ST, class SA, class charT, class traits>
237
  bool regex_match(const basic_string<charT, ST, SA>& s,
238
  const basic_regex<charT, traits>& e,
239
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
240
 
241
+ // [re.alg.search], function template regex_search
242
+ template <class BidirectionalIterator, class Allocator, class charT, class traits>
 
243
  bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
244
  match_results<BidirectionalIterator, Allocator>& m,
245
  const basic_regex<charT, traits>& e,
246
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
247
  template <class BidirectionalIterator, class charT, class traits>
248
  bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
249
  const basic_regex<charT, traits>& e,
250
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
251
  template <class charT, class Allocator, class traits>
252
  bool regex_search(const charT* str,
253
  match_results<const charT*, Allocator>& m,
254
  const basic_regex<charT, traits>& e,
255
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
256
  template <class charT, class traits>
257
  bool regex_search(const charT* str,
258
  const basic_regex<charT, traits>& e,
259
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
260
  template <class ST, class SA, class charT, class traits>
261
  bool regex_search(const basic_string<charT, ST, SA>& s,
262
  const basic_regex<charT, traits>& e,
263
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
264
  template <class ST, class SA, class Allocator, class charT, class traits>
265
  bool regex_search(const basic_string<charT, ST, SA>& s,
266
+ match_results<typename basic_string<charT, ST, SA>::const_iterator,
 
267
  Allocator>& m,
268
  const basic_regex<charT, traits>& e,
269
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
270
  template <class ST, class SA, class Allocator, class charT, class traits>
271
  bool regex_search(const basic_string<charT, ST, SA>&&,
272
+ match_results<typename basic_string<charT, ST, SA>::const_iterator,
 
273
  Allocator>&,
274
  const basic_regex<charT, traits>&,
275
+ regex_constants::match_flag_type
276
+ = regex_constants::match_default) = delete;
277
 
278
+ // [re.alg.replace], function template regex_replace
279
  template <class OutputIterator, class BidirectionalIterator,
280
  class traits, class charT, class ST, class SA>
281
  OutputIterator
282
  regex_replace(OutputIterator out,
283
  BidirectionalIterator first, BidirectionalIterator last,
284
  const basic_regex<charT, traits>& e,
285
  const basic_string<charT, ST, SA>& fmt,
286
+ regex_constants::match_flag_type flags = regex_constants::match_default);
287
+ template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
 
 
288
  OutputIterator
289
  regex_replace(OutputIterator out,
290
  BidirectionalIterator first, BidirectionalIterator last,
291
  const basic_regex<charT, traits>& e,
292
  const charT* fmt,
293
+ regex_constants::match_flag_type flags = regex_constants::match_default);
294
+ template <class traits, class charT, class ST, class SA, class FST, class FSA>
 
 
295
  basic_string<charT, ST, SA>
296
  regex_replace(const basic_string<charT, ST, SA>& s,
297
  const basic_regex<charT, traits>& e,
298
  const basic_string<charT, FST, FSA>& fmt,
299
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
300
  template <class traits, class charT, class ST, class SA>
301
  basic_string<charT, ST, SA>
302
  regex_replace(const basic_string<charT, ST, SA>& s,
303
  const basic_regex<charT, traits>& e,
304
  const charT* fmt,
305
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
306
  template <class traits, class charT, class ST, class SA>
307
  basic_string<charT>
308
  regex_replace(const charT* s,
309
  const basic_regex<charT, traits>& e,
310
  const basic_string<charT, ST, SA>& fmt,
311
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
312
  template <class traits, class charT>
313
  basic_string<charT>
314
  regex_replace(const charT* s,
315
  const basic_regex<charT, traits>& e,
316
  const charT* fmt,
317
+ regex_constants::match_flag_type flags = regex_constants::match_default);
 
318
 
319
+ // [re.regiter], class template regex_iterator
320
  template <class BidirectionalIterator,
321
+ class charT = typename iterator_traits<BidirectionalIterator>::value_type,
 
322
  class traits = regex_traits<charT>>
323
  class regex_iterator;
324
 
325
+ using cregex_iterator = regex_iterator<const char*>;
326
+ using wcregex_iterator = regex_iterator<const wchar_t*>;
327
+ using sregex_iterator = regex_iterator<string::const_iterator>;
328
+ using wsregex_iterator = regex_iterator<wstring::const_iterator>;
329
 
330
+ // [re.tokiter], class template regex_token_iterator
331
  template <class BidirectionalIterator,
332
+ class charT = typename iterator_traits<BidirectionalIterator>::value_type,
 
333
  class traits = regex_traits<charT>>
334
  class regex_token_iterator;
335
 
336
+ using cregex_token_iterator = regex_token_iterator<const char*>;
337
+ using wcregex_token_iterator = regex_token_iterator<const wchar_t*>;
338
+ using sregex_token_iterator = regex_token_iterator<string::const_iterator>;
339
+ using wsregex_token_iterator = regex_token_iterator<wstring::const_iterator>;
340
+
341
+ namespace pmr {
342
+ template <class BidirectionalIterator>
343
+ using match_results =
344
+ std::match_results<BidirectionalIterator,
345
+ polymorphic_allocator<sub_match<BidirectionalIterator>>>;
346
+
347
+ using cmatch = match_results<const char*>;
348
+ using wcmatch = match_results<const wchar_t*>;
349
+ using smatch = match_results<string::const_iterator>;
350
+ using wsmatch = match_results<wstring::const_iterator>;
351
+ }
352
  }
353
  ```
354