libstdc++
utility.h
Go to the documentation of this file.
1// Utilities used throughout the library -*- C++ -*-
2
3// Copyright (C) 2004-2026 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/bits/utility.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{utility}
28 *
29 * This file contains the parts of `<utility>` needed by other headers,
30 * so they don't need to include the whole of `<utility>`.
31 */
32
33#ifndef _GLIBCXX_UTILITY_H
34#define _GLIBCXX_UTILITY_H 1
35
36#ifdef _GLIBCXX_SYSHDR
37#pragma GCC system_header
38#endif
39
40#if __cplusplus >= 201103L
41
42#include <type_traits>
43#include <bits/move.h>
44
45namespace std _GLIBCXX_VISIBILITY(default)
46{
47_GLIBCXX_BEGIN_NAMESPACE_VERSION
48
49 /// Finds the size of a given tuple type.
50 template<typename _Tp>
51 struct tuple_size;
52
53 // _GLIBCXX_RESOLVE_LIB_DEFECTS
54 // 2313. tuple_size should always derive from integral_constant<size_t, N>
55 // 2770. tuple_size<const T> specialization is not SFINAE compatible
56
57 template<typename _Tp,
58 typename _Up = typename remove_cv<_Tp>::type,
59 typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
60 size_t = tuple_size<_Tp>::value>
61 using __enable_if_has_tuple_size = _Tp;
62
63 template<typename _Tp>
64 struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
65 : public tuple_size<_Tp> { };
66
67 template<typename _Tp>
68 struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
69 : public tuple_size<_Tp> { };
70
71 template<typename _Tp>
72 struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
73 : public tuple_size<_Tp> { };
74
75#if __cplusplus >= 201703L
76 template<typename _Tp>
77 inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
78#endif
79
80 /// Gives the type of the ith element of a given tuple type.
81 template<size_t __i, typename _Tp>
82 struct tuple_element;
83
84 // Duplicate of C++14's tuple_element_t for internal use in C++11 mode
85 template<size_t __i, typename _Tp>
86 using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
87
88 template<size_t __i, typename _Tp>
89 struct tuple_element<__i, const _Tp>
90 {
91 using type = const __tuple_element_t<__i, _Tp>;
92 };
93
94 template<size_t __i, typename _Tp>
95 struct tuple_element<__i, volatile _Tp>
96 {
97 using type = volatile __tuple_element_t<__i, _Tp>;
98 };
99
100 template<size_t __i, typename _Tp>
101 struct tuple_element<__i, const volatile _Tp>
102 {
103 using type = const volatile __tuple_element_t<__i, _Tp>;
104 };
105
106#if __cplusplus >= 201402L
107
108 // Return the index of _Tp in _Types, if it occurs exactly once.
109 // Otherwise, return sizeof...(_Types).
110 template<typename _Tp, typename... _Types>
111 constexpr size_t
112 __find_uniq_type_in_pack()
113 {
114 constexpr size_t __sz = sizeof...(_Types);
115 constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... };
116 size_t __n = __sz;
117 for (size_t __i = 0; __i < __sz; ++__i)
118 {
119 if (__found[__i])
120 {
121 if (__n < __sz) // more than one _Tp found
122 return __sz;
123 __n = __i;
124 }
125 }
126 return __n;
127 }
128#endif // C++14
129
130// The standard says this macro and alias template should be in <tuple> but we
131// define them here, to be available in <array>, <utility> and <ranges> too.
132// _GLIBCXX_RESOLVE_LIB_DEFECTS
133// 3378. tuple_size_v/tuple_element_t should be available when
134// tuple_size/tuple_element are
135#ifdef __glibcxx_tuple_element_t // C++ >= 14
136 template<size_t __i, typename _Tp>
137 using tuple_element_t = typename tuple_element<__i, _Tp>::type;
138#endif
139
140#ifdef __glibcxx_constant_wrapper // C++ >= 26
141 template<typename _Tp>
142 struct _CwFixedValue
143 {
144 using __type = _Tp;
145
146 constexpr
147 _CwFixedValue(__type __v) noexcept
148 : _M_data(__v) { }
149
150 __type _M_data;
151 };
152
153 template<typename _Tp, size_t _Extent>
154 struct _CwFixedValue<_Tp[_Extent]>
155 {
156 using __type = _Tp[_Extent];
157
158 constexpr
159 _CwFixedValue(_Tp (&__arr)[_Extent]) noexcept
160 : _CwFixedValue(__arr, typename _Build_index_tuple<_Extent>::__type())
161 { }
162
163 template<size_t... _Indices>
164 constexpr
165 _CwFixedValue(_Tp (&__arr)[_Extent], _Index_tuple<_Indices...>) noexcept
166 : _M_data{__arr[_Indices]...}
167 { }
168
169 _Tp _M_data[_Extent];
170 };
171
172 template<typename _Tp, size_t _Extent>
173 _CwFixedValue(_Tp (&)[_Extent]) -> _CwFixedValue<_Tp[_Extent]>;
174
175 template<_CwFixedValue _Xv,
176 typename = typename decltype(_CwFixedValue(_Xv))::__type>
177 struct constant_wrapper;
178
179 template<typename _Tp>
180 concept _ConstExprParam = requires
181 {
182 typename constant_wrapper<_Tp::value>;
183 };
184
185 struct _CwOperators
186 {
187 template<_ConstExprParam _Tp>
188 friend constexpr auto
189 operator+(_Tp) noexcept -> constant_wrapper<(+_Tp::value)>
190 { return {}; }
191
192 template<_ConstExprParam _Tp>
193 friend constexpr auto
194 operator-(_Tp) noexcept -> constant_wrapper<(-_Tp::value)>
195 { return {}; }
196
197 template<_ConstExprParam _Tp>
198 friend constexpr auto
199 operator~(_Tp) noexcept -> constant_wrapper<(~_Tp::value)>
200 { return {}; }
201
202 template<_ConstExprParam _Tp>
203 friend constexpr auto
204 operator!(_Tp) noexcept -> constant_wrapper<(!_Tp::value)>
205 { return {}; }
206
207 template<_ConstExprParam _Tp>
208 friend constexpr auto
209 operator&(_Tp) noexcept -> constant_wrapper<(&_Tp::value)>
210 { return {}; }
211
212 template<_ConstExprParam _Tp>
213 friend constexpr auto
214 operator*(_Tp) noexcept -> constant_wrapper<(*_Tp::value)>
215 { return {}; }
216
217 template<_ConstExprParam _Left, _ConstExprParam _Right>
218 friend constexpr auto
219 operator+(_Left, _Right) noexcept
220 -> constant_wrapper<(_Left::value + _Right::value)>
221 { return {}; }
222
223 template<_ConstExprParam _Left, _ConstExprParam _Right>
224 friend constexpr auto
225 operator-(_Left, _Right) noexcept
226 -> constant_wrapper<(_Left::value - _Right::value)>
227 { return {}; }
228
229 template<_ConstExprParam _Left, _ConstExprParam _Right>
230 friend constexpr auto
231 operator*(_Left, _Right) noexcept
232 -> constant_wrapper<(_Left::value * _Right::value)>
233 { return {}; }
234
235 template<_ConstExprParam _Left, _ConstExprParam _Right>
236 friend constexpr auto
237 operator/(_Left, _Right) noexcept
238 -> constant_wrapper<(_Left::value / _Right::value)>
239 { return {}; }
240
241 template<_ConstExprParam _Left, _ConstExprParam _Right>
242 friend constexpr auto
243 operator%(_Left, _Right) noexcept
244 -> constant_wrapper<(_Left::value % _Right::value)>
245 { return {}; }
246
247 template<_ConstExprParam _Left, _ConstExprParam _Right>
248 friend constexpr auto
249 operator<<(_Left, _Right) noexcept
250 -> constant_wrapper<(_Left::value << _Right::value)>
251 { return {}; }
252
253 template<_ConstExprParam _Left, _ConstExprParam _Right>
254 friend constexpr auto
255 operator>>(_Left, _Right) noexcept
256 -> constant_wrapper<(_Left::value >> _Right::value)>
257 { return {}; }
258
259 template<_ConstExprParam _Left, _ConstExprParam _Right>
260 friend constexpr auto
261 operator&(_Left, _Right) noexcept
262 -> constant_wrapper<(_Left::value & _Right::value)>
263 { return {}; }
264
265 template<_ConstExprParam _Left, _ConstExprParam _Right>
266 friend constexpr auto
267 operator|(_Left, _Right) noexcept
268 -> constant_wrapper<(_Left::value | _Right::value)>
269 { return {}; }
270
271 template<_ConstExprParam _Left, _ConstExprParam _Right>
272 friend constexpr auto
273 operator^(_Left, _Right) noexcept
274 -> constant_wrapper<(_Left::value ^ _Right::value)>
275 { return {}; }
276
277 template<_ConstExprParam _Left, _ConstExprParam _Right>
278 requires (!is_constructible_v<bool, decltype(_Left::value)>
279 || !is_constructible_v<bool, decltype(_Right::value)>)
280 friend constexpr auto
281 operator&&(_Left, _Right) noexcept
282 -> constant_wrapper<(_Left::value && _Right::value)>
283 { return {}; }
284
285 template<_ConstExprParam _Left, _ConstExprParam _Right>
286 requires (!is_constructible_v<bool, decltype(_Left::value)>
287 || !is_constructible_v<bool, decltype(_Right::value)>)
288 friend constexpr auto
289 operator||(_Left, _Right) noexcept
290 -> constant_wrapper<(_Left::value || _Right::value)>
291 { return {}; }
292
293 template<_ConstExprParam _Left, _ConstExprParam _Right>
294 friend constexpr auto
295 operator<=>(_Left, _Right) noexcept
296 -> constant_wrapper<(_Left::value <=> _Right::value)>
297 { return {}; }
298
299 template<_ConstExprParam _Left, _ConstExprParam _Right>
300 friend constexpr auto
301 operator<(_Left, _Right) noexcept
302 -> constant_wrapper<(_Left::value < _Right::value)>
303 { return {}; }
304
305 template<_ConstExprParam _Left, _ConstExprParam _Right>
306 friend constexpr auto
307 operator<=(_Left, _Right) noexcept
308 -> constant_wrapper<(_Left::value <= _Right::value)>
309 { return {}; }
310
311 template<_ConstExprParam _Left, _ConstExprParam _Right>
312 friend constexpr auto
313 operator==(_Left, _Right) noexcept
314 -> constant_wrapper<(_Left::value == _Right::value)>
315 { return {}; }
316
317 template<_ConstExprParam _Left, _ConstExprParam _Right>
318 friend constexpr auto
319 operator!=(_Left, _Right) noexcept
320 -> constant_wrapper<(_Left::value != _Right::value)>
321 { return {}; }
322
323 template<_ConstExprParam _Left, _ConstExprParam _Right>
324 friend constexpr auto
325 operator>(_Left, _Right) noexcept
326 -> constant_wrapper<(_Left::value > _Right::value)>
327 { return {}; }
328
329 template<_ConstExprParam _Left, _ConstExprParam _Right>
330 friend constexpr auto
331 operator>=(_Left, _Right) noexcept
332 -> constant_wrapper<(_Left::value >= _Right::value)>
333 { return {}; }
334
335 template<_ConstExprParam _Left, _ConstExprParam _Right>
336 friend constexpr auto
337 operator,(_Left, _Right) noexcept = delete;
338
339 template<_ConstExprParam _Left, _ConstExprParam _Right>
340 friend constexpr auto
341 operator->*(_Left, _Right) noexcept
342 -> constant_wrapper<_Left::value->*(_Right::value)>
343 { return {}; }
344
345 template<_ConstExprParam _Tp, _ConstExprParam... _Args>
346 constexpr auto
347 operator()(this _Tp, _Args...) noexcept
348 requires
349 requires(_Args...) { constant_wrapper<_Tp::value(_Args::value...)>(); }
350 { return constant_wrapper<_Tp::value(_Args::value...)>{}; }
351
352 template<_ConstExprParam _Tp, _ConstExprParam... _Args>
353 constexpr auto
354 operator[](this _Tp, _Args...) noexcept
355 -> constant_wrapper<(_Tp::value[_Args::value...])>
356 { return {}; }
357
358 template<_ConstExprParam _Tp>
359 constexpr auto
360 operator++(this _Tp) noexcept
361 -> constant_wrapper<(++_Tp::value)>
362 { return {}; }
363
364 template<_ConstExprParam _Tp>
365 constexpr auto
366 operator++(this _Tp, int) noexcept
367 -> constant_wrapper<(_Tp::value++)>
368 { return {}; }
369
370 template<_ConstExprParam _Tp>
371 constexpr auto
372 operator--(this _Tp) noexcept
373 -> constant_wrapper<(--_Tp::value)>
374 { return {}; }
375
376 template<_ConstExprParam _Tp>
377 constexpr auto
378 operator--(this _Tp, int) noexcept
379 -> constant_wrapper<(_Tp::value--)>
380 { return {}; }
381
382 template<_ConstExprParam _Tp, _ConstExprParam _Right>
383 constexpr auto
384 operator+=(this _Tp, _Right) noexcept
385 -> constant_wrapper<(_Tp::value += _Right::value)>
386 { return {}; }
387
388 template<_ConstExprParam _Tp, _ConstExprParam _Right>
389 constexpr auto
390 operator-=(this _Tp, _Right) noexcept
391 -> constant_wrapper<(_Tp::value -= _Right::value)>
392 { return {}; }
393
394 template<_ConstExprParam _Tp, _ConstExprParam _Right>
395 constexpr auto
396 operator*=(this _Tp, _Right) noexcept
397 -> constant_wrapper<(_Tp::value *= _Right::value)>
398 { return {}; }
399
400 template<_ConstExprParam _Tp, _ConstExprParam _Right>
401 constexpr auto
402 operator/=(this _Tp, _Right) noexcept
403 -> constant_wrapper<(_Tp::value /= _Right::value)>
404 { return {}; }
405
406 template<_ConstExprParam _Tp, _ConstExprParam _Right>
407 constexpr auto
408 operator%=(this _Tp, _Right) noexcept
409 -> constant_wrapper<(_Tp::value %= _Right::value)>
410 { return {}; }
411
412 template<_ConstExprParam _Tp, _ConstExprParam _Right>
413 constexpr auto
414 operator&=(this _Tp, _Right) noexcept
415 -> constant_wrapper<(_Tp::value &= _Right::value)>
416 { return {}; }
417
418 template<_ConstExprParam _Tp, _ConstExprParam _Right>
419 constexpr auto
420 operator|=(this _Tp, _Right) noexcept
421 -> constant_wrapper<(_Tp::value |= _Right::value)>
422 { return {}; }
423
424 template<_ConstExprParam _Tp, _ConstExprParam _Right>
425 constexpr auto
426 operator^=(this _Tp, _Right) noexcept
427 -> constant_wrapper<(_Tp::value ^= _Right::value)>
428 { return {}; }
429
430 template<_ConstExprParam _Tp, _ConstExprParam _Right>
431 constexpr auto
432 operator<<=(this _Tp, _Right) noexcept
433 -> constant_wrapper<(_Tp::value <<= _Right::value)>
434 { return {}; }
435
436 template<_ConstExprParam _Tp, _ConstExprParam _Right>
437 constexpr auto
438 operator>>=(this _Tp, _Right) noexcept
439 -> constant_wrapper<(_Tp::value >>= _Right::value)>
440 { return {}; }
441 };
442
443 template<_CwFixedValue _Xv, typename>
444 struct constant_wrapper : _CwOperators
445 {
446 static constexpr const auto& value = _Xv._M_data;
447 using type = constant_wrapper;
448 using value_type = typename decltype(_Xv)::__type;
449
450 template<_ConstExprParam _Right>
451 constexpr auto
452 operator=(_Right) const noexcept
453 -> constant_wrapper<(value = _Right::value)>
454 { return {}; }
455
456 constexpr
457 operator decltype(value)() const noexcept
458 { return value; }
459 };
460
461 template<typename>
462 constexpr bool __is_constant_wrapper_v = false;
463
464 template<auto __cw, typename _Fn>
465 constexpr bool __is_constant_wrapper_v<constant_wrapper<__cw, _Fn>> = true;
466
467 template<_CwFixedValue _Tp>
468 constexpr auto cw = constant_wrapper<_Tp>{};
469#endif
470
471#ifdef __glibcxx_integer_sequence // C++ >= 14
472
473 /// Class template integer_sequence
474 template<typename _Tp, _Tp... _Idx>
475 struct integer_sequence
476 {
477#if __cplusplus >= 202002L
478 static_assert(is_integral_v<_Tp>);
479#endif
480 typedef _Tp value_type;
481 static constexpr size_t size() noexcept { return sizeof...(_Idx); }
482 };
483
484#if __glibcxx_integer_sequence >= 202511L // C++ >= 26
485 /** @brief Structured binding support for `integer_sequence`
486
487 * @since C++26
488 * @{
489 */
490 /// Structured binding support
491 template<typename _Tp, _Tp... _Idx>
492 struct tuple_size<integer_sequence<_Tp, _Idx...>>
493 : integral_constant<size_t, sizeof...(_Idx)> { };
494
495 template<size_t __i, class _Tp, _Tp... _Idx>
496 struct tuple_element<__i, integer_sequence<_Tp, _Idx...>>
497 {
498 static_assert(__i < sizeof...(_Idx));
499 using type = _Tp;
500 };
501
502 template<size_t __i, class _Tp, _Tp... _Idx>
503 struct tuple_element<__i, const integer_sequence<_Tp, _Idx...>>
504 {
505 static_assert(__i < sizeof...(_Idx));
506 using type = _Tp;
507 };
508
509 template<size_t __i, class _Tp, _Tp... _Idx>
510 [[nodiscard]]
511 constexpr _Tp
512 get(integer_sequence<_Tp, _Idx...>) noexcept
513 {
514 static_assert(__i < sizeof...(_Idx));
515 return _Idx...[__i];
516 }
517 /// @}
518#endif // __glibcxx_integer_sequence >= 202511L
519
520 /// Alias template make_integer_sequence
521 template<typename _Tp, _Tp _Num>
522 using make_integer_sequence
523#if __has_builtin(__make_integer_seq)
524 = __make_integer_seq<integer_sequence, _Tp, _Num>;
525#else
526 = integer_sequence<_Tp, __integer_pack(_Num)...>;
527#endif
528
529 /// Alias template index_sequence
530 template<size_t... _Idx>
531 using index_sequence = integer_sequence<size_t, _Idx...>;
532
533 /// Alias template make_index_sequence
534 template<size_t _Num>
535 using make_index_sequence = make_integer_sequence<size_t, _Num>;
536
537 /// Alias template index_sequence_for
538 template<typename... _Types>
539 using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
540#endif // __glibcxx_integer_sequence
541
542#if __cpp_structured_bindings >= 202411L
543#if __has_builtin(__integer_pack)
544 template <auto _Num, typename _Tp = decltype(_Num)>
545 inline constexpr _Tp
546 _IotaArray[_Num] = {__integer_pack(_Tp(_Num))...};
547#elif defined __glibcxx_integer_sequence
548 template <auto _Num, typename _Tp = decltype(_Num), typename = make_integer_sequence<_Tp, _Num>>
549 inline constexpr _Tp
550 _IotaArray[_Num];
551
552 template <auto _Num, typename _Tp, _Tp... _Is>
553 inline constexpr _Tp
554 _IotaArray<_Num, _Tp, integer_sequence<_Tp, _Is...>>[_Num] = {_Is...};
555#endif // __integer_pack
556#endif // __cpp_structured_bindings >= 202411L
557
558#if __cplusplus >= 201703L
559
560 struct in_place_t {
561 explicit in_place_t() = default;
562 };
563
564 inline constexpr in_place_t in_place{};
565
566 template<typename _Tp> struct in_place_type_t
567 {
568 explicit in_place_type_t() = default;
569 };
570
571 template<typename _Tp>
572 inline constexpr in_place_type_t<_Tp> in_place_type{};
573
574 template<size_t _Idx> struct in_place_index_t
575 {
576 explicit in_place_index_t() = default;
577 };
578
579 template<size_t _Idx>
580 inline constexpr in_place_index_t<_Idx> in_place_index{};
581
582 template<typename>
583 inline constexpr bool __is_in_place_type_v = false;
584
585 template<typename _Tp>
586 inline constexpr bool __is_in_place_type_v<in_place_type_t<_Tp>> = true;
587
588 template<typename>
589 inline constexpr bool __is_in_place_index_v = false;
590
591 template<size_t _Nm>
592 inline constexpr bool __is_in_place_index_v<in_place_index_t<_Nm>> = true;
593
594#endif // C++17
595
596#if _GLIBCXX_USE_BUILTIN_TRAIT(__type_pack_element)
597 template<size_t _Np, typename... _Types>
598 struct _Nth_type
599 { using type = __type_pack_element<_Np, _Types...>; };
600#else
601 template<size_t _Np, typename... _Types>
602 struct _Nth_type
603 { };
604
605 template<typename _Tp0, typename... _Rest>
606 struct _Nth_type<0, _Tp0, _Rest...>
607 { using type = _Tp0; };
608
609 template<typename _Tp0, typename _Tp1, typename... _Rest>
610 struct _Nth_type<1, _Tp0, _Tp1, _Rest...>
611 { using type = _Tp1; };
612
613 template<typename _Tp0, typename _Tp1, typename _Tp2, typename... _Rest>
614 struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...>
615 { using type = _Tp2; };
616
617 template<size_t _Np, typename _Tp0, typename _Tp1, typename _Tp2,
618 typename... _Rest>
619#if __cpp_concepts
620 requires (_Np >= 3)
621#endif
622 struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...>
623 : _Nth_type<_Np - 3, _Rest...>
624 { };
625
626#if ! __cpp_concepts // Need additional specializations to avoid ambiguities.
627 template<typename _Tp0, typename _Tp1, typename _Tp2, typename... _Rest>
628 struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...>
629 { using type = _Tp0; };
630
631 template<typename _Tp0, typename _Tp1, typename _Tp2, typename... _Rest>
632 struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...>
633 { using type = _Tp1; };
634#endif
635#endif
636
637#if __glibcxx_ranges
638 namespace ranges::__detail
639 {
640 template<typename _Range>
641 inline constexpr bool __is_subrange = false;
642 } // namespace __detail
643#endif
644
645 // A class (and instance) which can be used in 'tie' when an element
646 // of a tuple is not required.
647 struct _Swallow_assign
648 {
649 template<class _Tp>
650 constexpr const _Swallow_assign&
651 operator=(const _Tp&) const noexcept
652 { return *this; }
653 };
654
655 // _GLIBCXX_RESOLVE_LIB_DEFECTS
656 // 2773. Making std::ignore constexpr
657 /** Used with `std::tie` to ignore an element of a tuple
658 *
659 * When using `std::tie` to assign the elements of a tuple to variables,
660 * unwanted elements can be ignored by using `std::ignore`. For example:
661 *
662 * ```
663 * int x, y;
664 * std::tie(x, std::ignore, y) = std::make_tuple(1, 2, 3);
665 * ```
666 *
667 * This assignment will perform `x=1; std::ignore=2; y=3;` which results
668 * in the second element being ignored.
669 *
670 * @since C++11
671 */
672 _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
673
674#if __glibcxx_flat_map || __glibcxx_flat_set // >= C++23
675 struct sorted_unique_t { explicit sorted_unique_t() = default; };
676 inline constexpr sorted_unique_t sorted_unique{};
677
678 struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
679 inline constexpr sorted_equivalent_t sorted_equivalent{};
680#endif
681
682_GLIBCXX_END_NAMESPACE_VERSION
683} // namespace
684
685#endif // C++11
686#endif /* _GLIBCXX_UTILITY_H */
std::operator*
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition complex:434
std::operator-
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
Definition complex:404
std::operator+
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
Definition complex:374
std::operator/
constexpr complex< _Tp > operator/(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x divided by y.
Definition complex:464
std
ISO C++ entities toplevel namespace is std.
std::make_index_sequence
make_integer_sequence< size_t, _Num > make_index_sequence
Alias template make_index_sequence.
Definition utility.h:533
std::index_sequence
integer_sequence< size_t, _Idx... > index_sequence
Alias template index_sequence.
Definition utility.h:529
std::make_integer_sequence
__make_integer_seq< integer_sequence, _Tp, _Num > make_integer_sequence
Alias template make_integer_sequence.
Definition utility.h:522
std::ignore
constexpr _Swallow_assign ignore
Definition utility.h:670
std::operator^
constexpr bitset< _Nb > operator^(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition bitset:1638
std::operator>>
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition bitset:1658
std::operator<<
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition bitset:1754
std::operator|
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition bitset:1628
std::index_sequence_for
make_index_sequence< sizeof...(_Types)> index_sequence_for
Alias template index_sequence_for.
Definition utility.h:537
std::operator&
constexpr bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition bitset:1618
std::integral_constant
integral_constant
Definition type_traits:96
std::enable_if
Define a member typedef type only if a boolean constant is true.
Definition type_traits:137
std::tuple_size
Finds the size of a given tuple type.
Definition utility.h:51
std::tuple_element
Gives the type of the ith element of a given tuple type.
Definition utility.h:82
std::integer_sequence
Class template integer_sequence.
Definition utility.h:476