libstdc++
charconv
1// Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-
2
3// Copyright (C) 2017-2021 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file include/charconv
26 * This is a Standard C++ Library header.
27 */
28
29#ifndef _GLIBCXX_CHARCONV
30#define _GLIBCXX_CHARCONV 1
31
32#pragma GCC system_header
33
34// As an extension we support <charconv> in C++14, but this header should not
35// be included by any other library headers in C++14 mode. This ensures that
36// the names defined in this header are not added to namespace std unless a
37// user explicitly includes <charconv> in C++14 code.
38#if __cplusplus >= 201402L
39
40#include <type_traits>
41#include <bit> // for __bit_width
42#include <cctype> // for isdigit
43#include <bits/charconv.h> // for __to_chars_len, __to_chars_10_impl
44#include <bits/error_constants.h> // for std::errc
45#include <ext/numeric_traits.h>
46
47#if _GLIBCXX_HAVE_USELOCALE
48# define __cpp_lib_to_chars 201611L
49#endif
50
51namespace std _GLIBCXX_VISIBILITY(default)
52{
53_GLIBCXX_BEGIN_NAMESPACE_VERSION
54
55 /// Result type of std::to_chars
57 {
58 char* ptr;
59 errc ec;
60
61#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
62 friend bool
63 operator==(const to_chars_result&, const to_chars_result&) = default;
64#endif
65 };
66
67 /// Result type of std::from_chars
69 {
70 const char* ptr;
71 errc ec;
72
73#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
74 friend bool
75 operator==(const from_chars_result&, const from_chars_result&) = default;
76#endif
77 };
78
79namespace __detail
80{
81 template<typename _Tp>
82 using __integer_to_chars_result_type
84 __is_unsigned_integer<_Tp>,
87
88 // Pick an unsigned type of suitable size. This is used to reduce the
89 // number of specializations of __to_chars_len, __to_chars etc. that
90 // get instantiated. For example, to_chars<char> and to_chars<short>
91 // and to_chars<unsigned> will all use the same code, and so will
92 // to_chars<long> when sizeof(int) == sizeof(long).
93 template<typename _Tp>
94 struct __to_chars_unsigned_type : __make_unsigned_selector_base
95 {
96 using _UInts = _List<unsigned int, unsigned long, unsigned long long
97#if _GLIBCXX_USE_INT128
98 , unsigned __int128
99#endif
100 >;
101 using type = typename __select<sizeof(_Tp), _UInts>::__type;
102 };
103
104 template<typename _Tp>
105 using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;
106
107 // Generic implementation for arbitrary bases.
108 // Defined in <bits/charconv.h>.
109 template<typename _Tp>
110 constexpr unsigned
111 __to_chars_len(_Tp __value, int __base /* = 10 */) noexcept;
112
113 template<typename _Tp>
114 constexpr unsigned
115 __to_chars_len_2(_Tp __value) noexcept
116 { return std::__bit_width(__value); }
117
118 // Generic implementation for arbitrary bases.
119 template<typename _Tp>
120 to_chars_result
121 __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
122 {
123 static_assert(is_integral<_Tp>::value, "implementation bug");
124 static_assert(is_unsigned<_Tp>::value, "implementation bug");
125
126 to_chars_result __res;
127
128 const unsigned __len = __to_chars_len(__val, __base);
129
130 if (__builtin_expect((__last - __first) < __len, 0))
131 {
132 __res.ptr = __last;
133 __res.ec = errc::value_too_large;
134 return __res;
135 }
136
137 unsigned __pos = __len - 1;
138
139 static constexpr char __digits[] = {
140 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
141 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
142 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
143 'u', 'v', 'w', 'x', 'y', 'z'
144 };
145
146 while (__val >= (unsigned)__base)
147 {
148 auto const __quo = __val / __base;
149 auto const __rem = __val % __base;
150 __first[__pos--] = __digits[__rem];
151 __val = __quo;
152 }
153 *__first = __digits[__val];
154
155 __res.ptr = __first + __len;
156 __res.ec = {};
157 return __res;
158 }
159
160 template<typename _Tp>
161 __integer_to_chars_result_type<_Tp>
162 __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
163 {
164 static_assert(is_integral<_Tp>::value, "implementation bug");
165 static_assert(is_unsigned<_Tp>::value, "implementation bug");
166
167 to_chars_result __res;
168
169 const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;
170
171 if (__builtin_expect((__last - __first) < __len, 0))
172 {
173 __res.ptr = __last;
174 __res.ec = errc::value_too_large;
175 return __res;
176 }
177
178 static constexpr char __digits[] = {
179 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
180 'a', 'b', 'c', 'd', 'e', 'f'
181 };
182 unsigned __pos = __len - 1;
183 while (__val >= 0x100)
184 {
185 auto __num = __val & 0xF;
186 __val >>= 4;
187 __first[__pos] = __digits[__num];
188 __num = __val & 0xF;
189 __val >>= 4;
190 __first[__pos - 1] = __digits[__num];
191 __pos -= 2;
192 }
193 if (__val >= 0x10)
194 {
195 const auto __num = __val & 0xF;
196 __val >>= 4;
197 __first[1] = __digits[__num];
198 __first[0] = __digits[__val];
199 }
200 else
201 __first[0] = __digits[__val];
202 __res.ptr = __first + __len;
203 __res.ec = {};
204 return __res;
205 }
206
207 template<typename _Tp>
208 inline __integer_to_chars_result_type<_Tp>
209 __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
210 {
211 static_assert(is_integral<_Tp>::value, "implementation bug");
212 static_assert(is_unsigned<_Tp>::value, "implementation bug");
213
214 to_chars_result __res;
215
216 const unsigned __len = __to_chars_len(__val, 10);
217
218 if (__builtin_expect((__last - __first) < __len, 0))
219 {
220 __res.ptr = __last;
221 __res.ec = errc::value_too_large;
222 return __res;
223 }
224
225 __detail::__to_chars_10_impl(__first, __len, __val);
226 __res.ptr = __first + __len;
227 __res.ec = {};
228 return __res;
229 }
230
231 template<typename _Tp>
232 __integer_to_chars_result_type<_Tp>
233 __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
234 {
235 static_assert(is_integral<_Tp>::value, "implementation bug");
236 static_assert(is_unsigned<_Tp>::value, "implementation bug");
237
238 to_chars_result __res;
239 unsigned __len;
240
241 if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
242 {
243 __len = __val > 077777u ? 6u
244 : __val > 07777u ? 5u
245 : __val > 0777u ? 4u
246 : __val > 077u ? 3u
247 : __val > 07u ? 2u
248 : 1u;
249 }
250 else
251 __len = (__to_chars_len_2(__val) + 2) / 3;
252
253 if (__builtin_expect((__last - __first) < __len, 0))
254 {
255 __res.ptr = __last;
256 __res.ec = errc::value_too_large;
257 return __res;
258 }
259
260 unsigned __pos = __len - 1;
261 while (__val >= 0100)
262 {
263 auto __num = __val & 7;
264 __val >>= 3;
265 __first[__pos] = '0' + __num;
266 __num = __val & 7;
267 __val >>= 3;
268 __first[__pos - 1] = '0' + __num;
269 __pos -= 2;
270 }
271 if (__val >= 010)
272 {
273 auto const __num = __val & 7;
274 __val >>= 3;
275 __first[1] = '0' + __num;
276 __first[0] = '0' + __val;
277 }
278 else
279 __first[0] = '0' + __val;
280 __res.ptr = __first + __len;
281 __res.ec = {};
282 return __res;
283 }
284
285 template<typename _Tp>
286 __integer_to_chars_result_type<_Tp>
287 __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
288 {
289 static_assert(is_integral<_Tp>::value, "implementation bug");
290 static_assert(is_unsigned<_Tp>::value, "implementation bug");
291
292 to_chars_result __res;
293
294 const unsigned __len = __to_chars_len_2(__val);
295
296 if (__builtin_expect((__last - __first) < __len, 0))
297 {
298 __res.ptr = __last;
299 __res.ec = errc::value_too_large;
300 return __res;
301 }
302
303 unsigned __pos = __len - 1;
304
305 while (__pos)
306 {
307 __first[__pos--] = '0' + (__val & 1);
308 __val >>= 1;
309 }
310 // First digit is always '1' because __to_chars_len_2 skips
311 // leading zero bits and std::to_chars handles zero values
312 // directly.
313 __first[0] = '1';
314
315 __res.ptr = __first + __len;
316 __res.ec = {};
317 return __res;
318 }
319
320} // namespace __detail
321
322 template<typename _Tp>
323 __detail::__integer_to_chars_result_type<_Tp>
324 __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
325 {
326 __glibcxx_assert(2 <= __base && __base <= 36);
327
328 using _Up = __detail::__unsigned_least_t<_Tp>;
329 _Up __unsigned_val = __value;
330
331 if (__first == __last) [[__unlikely__]]
332 return { __last, errc::value_too_large };
333
334 if (__value == 0)
335 {
336 *__first = '0';
337 return { __first + 1, errc{} };
338 }
339 else if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
340 if (__value < 0)
341 {
342 *__first++ = '-';
343 __unsigned_val = _Up(~__value) + _Up(1);
344 }
345
346 switch (__base)
347 {
348 case 16:
349 return __detail::__to_chars_16(__first, __last, __unsigned_val);
350 case 10:
351 return __detail::__to_chars_10(__first, __last, __unsigned_val);
352 case 8:
353 return __detail::__to_chars_8(__first, __last, __unsigned_val);
354 case 2:
355 return __detail::__to_chars_2(__first, __last, __unsigned_val);
356 default:
357 return __detail::__to_chars(__first, __last, __unsigned_val, __base);
358 }
359 }
360
361#define _GLIBCXX_TO_CHARS(T) \
362 inline to_chars_result \
363 to_chars(char* __first, char* __last, T __value, int __base = 10) \
364 { return std::__to_chars_i<T>(__first, __last, __value, __base); }
365_GLIBCXX_TO_CHARS(char)
366_GLIBCXX_TO_CHARS(signed char)
367_GLIBCXX_TO_CHARS(unsigned char)
368_GLIBCXX_TO_CHARS(signed short)
369_GLIBCXX_TO_CHARS(unsigned short)
370_GLIBCXX_TO_CHARS(signed int)
371_GLIBCXX_TO_CHARS(unsigned int)
372_GLIBCXX_TO_CHARS(signed long)
373_GLIBCXX_TO_CHARS(unsigned long)
374_GLIBCXX_TO_CHARS(signed long long)
375_GLIBCXX_TO_CHARS(unsigned long long)
376#if defined(__GLIBCXX_TYPE_INT_N_0)
377_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
378_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
379#endif
380#if defined(__GLIBCXX_TYPE_INT_N_1)
381_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
382_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
383#endif
384#if defined(__GLIBCXX_TYPE_INT_N_2)
385_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
386_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
387#endif
388#if defined(__GLIBCXX_TYPE_INT_N_3)
389_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
390_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
391#endif
392#undef _GLIBCXX_TO_CHARS
393
394 // _GLIBCXX_RESOLVE_LIB_DEFECTS
395 // 3266. to_chars(bool) should be deleted
396 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
397
398namespace __detail
399{
400 template<typename _Tp>
401 bool
402 __raise_and_add(_Tp& __val, int __base, unsigned char __c)
403 {
404 if (__builtin_mul_overflow(__val, __base, &__val)
405 || __builtin_add_overflow(__val, __c, &__val))
406 return false;
407 return true;
408 }
409
410 /// std::from_chars implementation for integers in base 2.
411 template<typename _Tp>
412 bool
413 __from_chars_binary(const char*& __first, const char* __last, _Tp& __val)
414 {
415 static_assert(is_integral<_Tp>::value, "implementation bug");
416 static_assert(is_unsigned<_Tp>::value, "implementation bug");
417
418 const ptrdiff_t __len = __last - __first;
419 ptrdiff_t __i = 0;
420 while (__i < __len && __first[__i] == '0')
421 ++__i;
422 const ptrdiff_t __leading_zeroes = __i;
423
424 while (__i < __len)
425 {
426 const unsigned char __c = (unsigned)__first[__i] - '0';
427 if (__c < 2)
428 __val = (__val << 1) | __c;
429 else
430 break;
431 __i++;
432 }
433 __first += __i;
434 return (__i - __leading_zeroes) <= __gnu_cxx::__int_traits<_Tp>::__digits;
435 }
436
437 /// std::from_chars implementation for integers in bases 3 to 10.
438 template<typename _Tp>
439 bool
440 __from_chars_digit(const char*& __first, const char* __last, _Tp& __val,
441 int __base)
442 {
443 static_assert(is_integral<_Tp>::value, "implementation bug");
444 static_assert(is_unsigned<_Tp>::value, "implementation bug");
445
446 auto __matches = [__base](char __c) {
447 return '0' <= __c && __c <= ('0' + (__base - 1));
448 };
449
450 while (__first != __last)
451 {
452 const char __c = *__first;
453 if (__matches(__c))
454 {
455 if (!__raise_and_add(__val, __base, __c - '0'))
456 {
457 while (++__first != __last && __matches(*__first))
458 ;
459 return false;
460 }
461 __first++;
462 }
463 else
464 return true;
465 }
466 return true;
467 }
468
469 constexpr unsigned char
470 __from_chars_alpha_to_num(char __c)
471 {
472 switch (__c)
473 {
474 case 'a':
475 case 'A':
476 return 10;
477 case 'b':
478 case 'B':
479 return 11;
480 case 'c':
481 case 'C':
482 return 12;
483 case 'd':
484 case 'D':
485 return 13;
486 case 'e':
487 case 'E':
488 return 14;
489 case 'f':
490 case 'F':
491 return 15;
492 case 'g':
493 case 'G':
494 return 16;
495 case 'h':
496 case 'H':
497 return 17;
498 case 'i':
499 case 'I':
500 return 18;
501 case 'j':
502 case 'J':
503 return 19;
504 case 'k':
505 case 'K':
506 return 20;
507 case 'l':
508 case 'L':
509 return 21;
510 case 'm':
511 case 'M':
512 return 22;
513 case 'n':
514 case 'N':
515 return 23;
516 case 'o':
517 case 'O':
518 return 24;
519 case 'p':
520 case 'P':
521 return 25;
522 case 'q':
523 case 'Q':
524 return 26;
525 case 'r':
526 case 'R':
527 return 27;
528 case 's':
529 case 'S':
530 return 28;
531 case 't':
532 case 'T':
533 return 29;
534 case 'u':
535 case 'U':
536 return 30;
537 case 'v':
538 case 'V':
539 return 31;
540 case 'w':
541 case 'W':
542 return 32;
543 case 'x':
544 case 'X':
545 return 33;
546 case 'y':
547 case 'Y':
548 return 34;
549 case 'z':
550 case 'Z':
551 return 35;
552 }
554 }
555
556 /// std::from_chars implementation for integers in bases 11 to 26.
557 template<typename _Tp>
558 bool
559 __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
560 int __base)
561 {
562 bool __valid = true;
563 while (__first != __last)
564 {
565 unsigned char __c = *__first;
566 if (std::isdigit(__c))
567 __c -= '0';
568 else
569 {
570 __c = __from_chars_alpha_to_num(__c);
571 if (__c >= __base)
572 break;
573 }
574
575 if (__builtin_expect(__valid, 1))
576 __valid = __raise_and_add(__val, __base, __c);
577 __first++;
578 }
579 return __valid;
580 }
581
582 template<typename _Tp>
583 using __integer_from_chars_result_type
585 __is_unsigned_integer<_Tp>,
588
589} // namespace __detail
590
591 /// std::from_chars for integral types.
592 template<typename _Tp>
593 __detail::__integer_from_chars_result_type<_Tp>
594 from_chars(const char* __first, const char* __last, _Tp& __value,
595 int __base = 10)
596 {
597 __glibcxx_assert(2 <= __base && __base <= 36);
598
599 from_chars_result __res{__first, {}};
600
601 int __sign = 1;
602 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
603 if (__first != __last && *__first == '-')
604 {
605 __sign = -1;
606 ++__first;
607 }
608
609 using _Up = __detail::__unsigned_least_t<_Tp>;
610 _Up __val = 0;
611
612 const auto __start = __first;
613 bool __valid;
614 if (__base == 2)
615 __valid = __detail::__from_chars_binary(__first, __last, __val);
616 else if (__base <= 10)
617 __valid = __detail::__from_chars_digit(__first, __last, __val, __base);
618 else
619 __valid = __detail::__from_chars_alnum(__first, __last, __val, __base);
620
621 if (__builtin_expect(__first == __start, 0))
622 __res.ec = errc::invalid_argument;
623 else
624 {
625 __res.ptr = __first;
626 if (!__valid)
627 __res.ec = errc::result_out_of_range;
628 else
629 {
630 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
631 {
632 _Tp __tmp;
633 if (__builtin_mul_overflow(__val, __sign, &__tmp))
634 __res.ec = errc::result_out_of_range;
635 else
636 __value = __tmp;
637 }
638 else
639 {
640 if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Up>::__max
642 {
644 __res.ec = errc::result_out_of_range;
645 else
646 __value = __val;
647 }
648 else
649 __value = __val;
650 }
651 }
652 }
653 return __res;
654 }
655
656 /// floating-point format for primitive numerical conversion
657 enum class chars_format
658 {
659 scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
660 };
661
662 constexpr chars_format
663 operator|(chars_format __lhs, chars_format __rhs) noexcept
664 { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
665
666 constexpr chars_format
667 operator&(chars_format __lhs, chars_format __rhs) noexcept
668 { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
669
670 constexpr chars_format
671 operator^(chars_format __lhs, chars_format __rhs) noexcept
672 { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
673
674 constexpr chars_format
675 operator~(chars_format __fmt) noexcept
676 { return (chars_format)~(unsigned)__fmt; }
677
678 constexpr chars_format&
679 operator|=(chars_format& __lhs, chars_format __rhs) noexcept
680 { return __lhs = __lhs | __rhs; }
681
682 constexpr chars_format&
683 operator&=(chars_format& __lhs, chars_format __rhs) noexcept
684 { return __lhs = __lhs & __rhs; }
685
686 constexpr chars_format&
687 operator^=(chars_format& __lhs, chars_format __rhs) noexcept
688 { return __lhs = __lhs ^ __rhs; }
689
690#if _GLIBCXX_HAVE_USELOCALE
691 from_chars_result
692 from_chars(const char* __first, const char* __last, float& __value,
693 chars_format __fmt = chars_format::general) noexcept;
694
695 from_chars_result
696 from_chars(const char* __first, const char* __last, double& __value,
697 chars_format __fmt = chars_format::general) noexcept;
698
699 from_chars_result
700 from_chars(const char* __first, const char* __last, long double& __value,
701 chars_format __fmt = chars_format::general) noexcept;
702#endif
703
704#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
705 && __SIZE_WIDTH__ >= 32
706 // Floating-point std::to_chars
707
708 // Overloads for float.
709 to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
710 to_chars_result to_chars(char* __first, char* __last, float __value,
711 chars_format __fmt) noexcept;
712 to_chars_result to_chars(char* __first, char* __last, float __value,
713 chars_format __fmt, int __precision) noexcept;
714
715 // Overloads for double.
716 to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
717 to_chars_result to_chars(char* __first, char* __last, double __value,
718 chars_format __fmt) noexcept;
719 to_chars_result to_chars(char* __first, char* __last, double __value,
720 chars_format __fmt, int __precision) noexcept;
721
722 // Overloads for long double.
723 to_chars_result to_chars(char* __first, char* __last, long double __value)
724 noexcept;
725 to_chars_result to_chars(char* __first, char* __last, long double __value,
726 chars_format __fmt) noexcept;
727 to_chars_result to_chars(char* __first, char* __last, long double __value,
728 chars_format __fmt, int __precision) noexcept;
729#endif
730
731_GLIBCXX_END_NAMESPACE_VERSION
732} // namespace std
733#endif // C++14
734#endif // _GLIBCXX_CHARCONV
typename enable_if< _Cond, _Tp >::type enable_if_t
Alias template for enable_if.
ISO C++ entities toplevel namespace is std.
ios_base & scientific(ios_base &__base)
Calls base.setf(ios_base::scientific, ios_base::floatfield).
Definition: ios_base.h:1079
ios_base & hex(ios_base &__base)
Calls base.setf(ios_base::hex, ios_base::basefield).
Definition: ios_base.h:1054
chars_format
floating-point format for primitive numerical conversion
Definition: charconv:658
bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition: std/bitset:1435
bool isdigit(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::digit, __c).
__detail::__integer_from_chars_result_type< _Tp > from_chars(const char *__first, const char *__last, _Tp &__value, int __base=10)
std::from_chars for integral types.
Definition: charconv:594
ios_base & fixed(ios_base &__base)
Calls base.setf(ios_base::fixed, ios_base::floatfield).
Definition: ios_base.h:1071
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition: std/bitset:1444
bitset< _Nb > operator^(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition: std/bitset:1453
bool __from_chars_alnum(const char *&__first, const char *__last, _Tp &__val, int __base)
std::from_chars implementation for integers in bases 11 to 26.
Definition: charconv:559
bool __from_chars_binary(const char *&__first, const char *__last, _Tp &__val)
std::from_chars implementation for integers in base 2.
Definition: charconv:413
bool __from_chars_digit(const char *&__first, const char *__last, _Tp &__val, int __base)
std::from_chars implementation for integers in bases 3 to 10.
Definition: charconv:440
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
constexpr _Iterator __base(_Iterator __it)
Result type of std::to_chars.
Definition: charconv:57
Result type of std::from_chars.
Definition: charconv:69