|
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