|
82 | 82 | namespace std {
|
83 | 83 | class logic_error : public exception {
|
84 | 84 | public:
|
85 |
| - explicit logic_error(const string& what_arg); |
86 |
| - explicit logic_error(const char* what_arg); |
| 85 | + constexpr explicit logic_error(const string& what_arg); |
| 86 | + constexpr explicit logic_error(const char* what_arg); |
87 | 87 | };
|
88 | 88 | }
|
89 | 89 | \end{codeblock}
|
|
98 | 98 |
|
99 | 99 | \indexlibraryctor{logic_error}%
|
100 | 100 | \begin{itemdecl}
|
101 |
| -logic_error(const string& what_arg); |
| 101 | +constexpr logic_error(const string& what_arg); |
102 | 102 | \end{itemdecl}
|
103 | 103 |
|
104 | 104 | \begin{itemdescr}
|
|
109 | 109 |
|
110 | 110 | \indexlibraryctor{logic_error}%
|
111 | 111 | \begin{itemdecl}
|
112 |
| -logic_error(const char* what_arg); |
| 112 | +constexpr logic_error(const char* what_arg); |
113 | 113 | \end{itemdecl}
|
114 | 114 |
|
115 | 115 | \begin{itemdescr}
|
|
125 | 125 | namespace std {
|
126 | 126 | class domain_error : public logic_error {
|
127 | 127 | public:
|
128 |
| - explicit domain_error(const string& what_arg); |
129 |
| - explicit domain_error(const char* what_arg); |
| 128 | + constexpr explicit domain_error(const string& what_arg); |
| 129 | + constexpr explicit domain_error(const char* what_arg); |
130 | 130 | };
|
131 | 131 | }
|
132 | 132 | \end{codeblock}
|
|
139 | 139 |
|
140 | 140 | \indexlibraryctor{domain_error}%
|
141 | 141 | \begin{itemdecl}
|
142 |
| -domain_error(const string& what_arg); |
| 142 | +constexpr domain_error(const string& what_arg); |
143 | 143 | \end{itemdecl}
|
144 | 144 |
|
145 | 145 | \begin{itemdescr}
|
|
150 | 150 |
|
151 | 151 | \indexlibraryctor{domain_error}%
|
152 | 152 | \begin{itemdecl}
|
153 |
| -domain_error(const char* what_arg); |
| 153 | +constexpr domain_error(const char* what_arg); |
154 | 154 | \end{itemdecl}
|
155 | 155 |
|
156 | 156 | \begin{itemdescr}
|
|
166 | 166 | namespace std {
|
167 | 167 | class invalid_argument : public logic_error {
|
168 | 168 | public:
|
169 |
| - explicit invalid_argument(const string& what_arg); |
170 |
| - explicit invalid_argument(const char* what_arg); |
| 169 | + constexpr explicit invalid_argument(const string& what_arg); |
| 170 | + constexpr explicit invalid_argument(const char* what_arg); |
171 | 171 | };
|
172 | 172 | }
|
173 | 173 | \end{codeblock}
|
|
179 | 179 |
|
180 | 180 | \indexlibraryctor{invalid_argument}%
|
181 | 181 | \begin{itemdecl}
|
182 |
| -invalid_argument(const string& what_arg); |
| 182 | +constexpr invalid_argument(const string& what_arg); |
183 | 183 | \end{itemdecl}
|
184 | 184 |
|
185 | 185 | \begin{itemdescr}
|
|
190 | 190 |
|
191 | 191 | \indexlibraryctor{invalid_argument}%
|
192 | 192 | \begin{itemdecl}
|
193 |
| -invalid_argument(const char* what_arg); |
| 193 | +constexpr invalid_argument(const char* what_arg); |
194 | 194 | \end{itemdecl}
|
195 | 195 |
|
196 | 196 | \begin{itemdescr}
|
|
206 | 206 | namespace std {
|
207 | 207 | class length_error : public logic_error {
|
208 | 208 | public:
|
209 |
| - explicit length_error(const string& what_arg); |
210 |
| - explicit length_error(const char* what_arg); |
| 209 | + constexpr explicit length_error(const string& what_arg); |
| 210 | + constexpr explicit length_error(const char* what_arg); |
211 | 211 | };
|
212 | 212 | }
|
213 | 213 | \end{codeblock}
|
|
221 | 221 |
|
222 | 222 | \indexlibraryctor{length_error}%
|
223 | 223 | \begin{itemdecl}
|
224 |
| -length_error(const string& what_arg); |
| 224 | +constexpr length_error(const string& what_arg); |
225 | 225 | \end{itemdecl}
|
226 | 226 |
|
227 | 227 | \begin{itemdescr}
|
|
232 | 232 |
|
233 | 233 | \indexlibraryctor{length_error}%
|
234 | 234 | \begin{itemdecl}
|
235 |
| -length_error(const char* what_arg); |
| 235 | +constexpr length_error(const char* what_arg); |
236 | 236 | \end{itemdecl}
|
237 | 237 |
|
238 | 238 | \begin{itemdescr}
|
|
248 | 248 | namespace std {
|
249 | 249 | class out_of_range : public logic_error {
|
250 | 250 | public:
|
251 |
| - explicit out_of_range(const string& what_arg); |
252 |
| - explicit out_of_range(const char* what_arg); |
| 251 | + constexpr explicit out_of_range(const string& what_arg); |
| 252 | + constexpr explicit out_of_range(const char* what_arg); |
253 | 253 | };
|
254 | 254 | }
|
255 | 255 | \end{codeblock}
|
|
263 | 263 |
|
264 | 264 | \indexlibraryctor{out_of_range}%
|
265 | 265 | \begin{itemdecl}
|
266 |
| -out_of_range(const string& what_arg); |
| 266 | +constexpr out_of_range(const string& what_arg); |
267 | 267 | \end{itemdecl}
|
268 | 268 |
|
269 | 269 | \begin{itemdescr}
|
|
274 | 274 |
|
275 | 275 | \indexlibraryctor{out_of_range}%
|
276 | 276 | \begin{itemdecl}
|
277 |
| -out_of_range(const char* what_arg); |
| 277 | +constexpr out_of_range(const char* what_arg); |
278 | 278 | \end{itemdecl}
|
279 | 279 |
|
280 | 280 | \begin{itemdescr}
|
|
290 | 290 | namespace std {
|
291 | 291 | class runtime_error : public exception {
|
292 | 292 | public:
|
293 |
| - explicit runtime_error(const string& what_arg); |
294 |
| - explicit runtime_error(const char* what_arg); |
| 293 | + constexpr explicit runtime_error(const string& what_arg); |
| 294 | + constexpr explicit runtime_error(const char* what_arg); |
295 | 295 | };
|
296 | 296 | }
|
297 | 297 | \end{codeblock}
|
|
304 | 304 |
|
305 | 305 | \indexlibraryctor{runtime_error}%
|
306 | 306 | \begin{itemdecl}
|
307 |
| -runtime_error(const string& what_arg); |
| 307 | +constexpr runtime_error(const string& what_arg); |
308 | 308 | \end{itemdecl}
|
309 | 309 |
|
310 | 310 | \begin{itemdescr}
|
|
315 | 315 |
|
316 | 316 | \indexlibraryctor{runtime_error}%
|
317 | 317 | \begin{itemdecl}
|
318 |
| -runtime_error(const char* what_arg); |
| 318 | +constexpr runtime_error(const char* what_arg); |
319 | 319 | \end{itemdecl}
|
320 | 320 |
|
321 | 321 | \begin{itemdescr}
|
|
331 | 331 | namespace std {
|
332 | 332 | class range_error : public runtime_error {
|
333 | 333 | public:
|
334 |
| - explicit range_error(const string& what_arg); |
335 |
| - explicit range_error(const char* what_arg); |
| 334 | + constexpr explicit range_error(const string& what_arg); |
| 335 | + constexpr explicit range_error(const char* what_arg); |
336 | 336 | };
|
337 | 337 | }
|
338 | 338 | \end{codeblock}
|
|
345 | 345 |
|
346 | 346 | \indexlibraryctor{range_error}%
|
347 | 347 | \begin{itemdecl}
|
348 |
| -range_error(const string& what_arg); |
| 348 | +constexpr range_error(const string& what_arg); |
349 | 349 | \end{itemdecl}
|
350 | 350 |
|
351 | 351 | \begin{itemdescr}
|
|
356 | 356 |
|
357 | 357 | \indexlibraryctor{range_error}%
|
358 | 358 | \begin{itemdecl}
|
359 |
| -range_error(const char* what_arg); |
| 359 | +constexpr range_error(const char* what_arg); |
360 | 360 | \end{itemdecl}
|
361 | 361 |
|
362 | 362 | \begin{itemdescr}
|
|
372 | 372 | namespace std {
|
373 | 373 | class overflow_error : public runtime_error {
|
374 | 374 | public:
|
375 |
| - explicit overflow_error(const string& what_arg); |
376 |
| - explicit overflow_error(const char* what_arg); |
| 375 | + constexpr explicit overflow_error(const string& what_arg); |
| 376 | + constexpr explicit overflow_error(const char* what_arg); |
377 | 377 | };
|
378 | 378 | }
|
379 | 379 | \end{codeblock}
|
|
385 | 385 |
|
386 | 386 | \indexlibraryctor{overflow_error}%
|
387 | 387 | \begin{itemdecl}
|
388 |
| -overflow_error(const string& what_arg); |
| 388 | +constexpr overflow_error(const string& what_arg); |
389 | 389 | \end{itemdecl}
|
390 | 390 |
|
391 | 391 | \begin{itemdescr}
|
|
396 | 396 |
|
397 | 397 | \indexlibraryctor{overflow_error}%
|
398 | 398 | \begin{itemdecl}
|
399 |
| -overflow_error(const char* what_arg); |
| 399 | +constexpr overflow_error(const char* what_arg); |
400 | 400 | \end{itemdecl}
|
401 | 401 |
|
402 | 402 | \begin{itemdescr}
|
|
412 | 412 | namespace std {
|
413 | 413 | class underflow_error : public runtime_error {
|
414 | 414 | public:
|
415 |
| - explicit underflow_error(const string& what_arg); |
416 |
| - explicit underflow_error(const char* what_arg); |
| 415 | + constexpr explicit underflow_error(const string& what_arg); |
| 416 | + constexpr explicit underflow_error(const char* what_arg); |
417 | 417 | };
|
418 | 418 | }
|
419 | 419 | \end{codeblock}
|
|
425 | 425 |
|
426 | 426 | \indexlibraryctor{underflow_error}%
|
427 | 427 | \begin{itemdecl}
|
428 |
| -underflow_error(const string& what_arg); |
| 428 | +constexpr underflow_error(const string& what_arg); |
429 | 429 | \end{itemdecl}
|
430 | 430 |
|
431 | 431 | \begin{itemdescr}
|
|
436 | 436 |
|
437 | 437 | \indexlibraryctor{underflow_error}%
|
438 | 438 | \begin{itemdecl}
|
439 |
| -underflow_error(const char* what_arg); |
| 439 | +constexpr underflow_error(const char* what_arg); |
440 | 440 | \end{itemdecl}
|
441 | 441 |
|
442 | 442 | \begin{itemdescr}
|
|
0 commit comments