libstdc++
ranges_uninitialized.h
Go to the documentation of this file.
1// Raw memory manipulators -*- C++ -*-
2
3// Copyright (C) 2020-2025 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 bits/ranges_uninitialized.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{memory}
28 */
29
30#ifndef _RANGES_UNINITIALIZED_H
31#define _RANGES_UNINITIALIZED_H 1
32
33#if __cplusplus > 201703L
34#if __cpp_lib_concepts
35
37
38namespace std _GLIBCXX_VISIBILITY(default)
39{
40_GLIBCXX_BEGIN_NAMESPACE_VERSION
41namespace ranges
42{
43 namespace __detail
44 {
45 template<typename _Tp>
46 constexpr void*
47 __voidify(_Tp& __obj) noexcept
48 {
49 return const_cast<void*>
50 (static_cast<const volatile void*>(std::__addressof(__obj)));
51 }
52
53 template<typename _Iter>
54 concept __nothrow_input_iterator
55 = (input_iterator<_Iter>
56 && is_lvalue_reference_v<iter_reference_t<_Iter>>
57 && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
58 iter_value_t<_Iter>>);
59
60 template<typename _Sent, typename _Iter>
61 concept __nothrow_sentinel = sentinel_for<_Sent, _Iter>;
62
63 template<typename _Range>
64 concept __nothrow_input_range
65 = (range<_Range>
66 && __nothrow_input_iterator<iterator_t<_Range>>
67 && __nothrow_sentinel<sentinel_t<_Range>, iterator_t<_Range>>);
68
69 template<typename _Iter>
70 concept __nothrow_forward_iterator
71 = (__nothrow_input_iterator<_Iter>
72 && forward_iterator<_Iter>
73 && __nothrow_sentinel<_Iter, _Iter>);
74
75 template<typename _Range>
76 concept __nothrow_forward_range
77 = (__nothrow_input_range<_Range>
78 && __nothrow_forward_iterator<iterator_t<_Range>>);
79 } // namespace __detail
80
81 struct __destroy_fn
82 {
83 template<__detail::__nothrow_input_iterator _Iter,
84 __detail::__nothrow_sentinel<_Iter> _Sent>
85 requires destructible<iter_value_t<_Iter>>
86 constexpr _Iter
87 operator()(_Iter __first, _Sent __last) const noexcept;
88
89 template<__detail::__nothrow_input_range _Range>
90 requires destructible<range_value_t<_Range>>
91 constexpr borrowed_iterator_t<_Range>
92 operator()(_Range&& __r) const noexcept;
93 };
94
95 inline constexpr __destroy_fn destroy{};
96
97 namespace __detail
98 {
99 template<typename _Iter>
100 requires destructible<iter_value_t<_Iter>>
101 struct _DestroyGuard
102 {
103 private:
104 _Iter _M_first;
105 const _Iter* _M_cur;
106
107 public:
108 constexpr
109 explicit
110 _DestroyGuard(const _Iter& __iter)
111 : _M_first(__iter), _M_cur(std::__addressof(__iter))
112 { }
113
114 constexpr
115 void
116 release() noexcept
117 { _M_cur = nullptr; }
118
119 constexpr
120 ~_DestroyGuard()
121 {
122 if (_M_cur != nullptr)
123 ranges::destroy(std::move(_M_first), *_M_cur);
124 }
125 };
126
127 template<typename _Iter>
128 requires destructible<iter_value_t<_Iter>>
129 && is_trivially_destructible_v<iter_value_t<_Iter>>
130 struct _DestroyGuard<_Iter>
131 {
132 constexpr
133 explicit
134 _DestroyGuard(const _Iter&)
135 { }
136
137 constexpr
138 void
139 release() noexcept
140 { }
141 };
142 } // namespace __detail
143
144 struct __uninitialized_default_construct_fn
145 {
146 template<__detail::__nothrow_forward_iterator _Iter,
147 __detail::__nothrow_sentinel<_Iter> _Sent>
148 requires default_initializable<iter_value_t<_Iter>>
149 _GLIBCXX26_CONSTEXPR
150 _Iter
151 operator()(_Iter __first, _Sent __last) const
152 {
153 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
154 if constexpr (is_trivially_default_constructible_v<_ValueType>)
155 return ranges::next(__first, __last);
156 else
157 {
158 auto __guard = __detail::_DestroyGuard(__first);
159 for (; __first != __last; ++__first)
160 ::new (__detail::__voidify(*__first)) _ValueType;
161 __guard.release();
162 return __first;
163 }
164 }
165
166 template<__detail::__nothrow_forward_range _Range>
167 requires default_initializable<range_value_t<_Range>>
168 _GLIBCXX26_CONSTEXPR
169 borrowed_iterator_t<_Range>
170 operator()(_Range&& __r) const
171 {
172 return (*this)(ranges::begin(__r), ranges::end(__r));
173 }
174 };
175
176 inline constexpr __uninitialized_default_construct_fn
178
179 struct __uninitialized_default_construct_n_fn
180 {
181 template<__detail::__nothrow_forward_iterator _Iter>
182 requires default_initializable<iter_value_t<_Iter>>
183 _GLIBCXX26_CONSTEXPR
184 _Iter
185 operator()(_Iter __first, iter_difference_t<_Iter> __n) const
186 {
187 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
188 if constexpr (is_trivially_default_constructible_v<_ValueType>)
189 return ranges::next(__first, __n);
190 else
191 {
192 auto __guard = __detail::_DestroyGuard(__first);
193 for (; __n > 0; ++__first, (void) --__n)
194 ::new (__detail::__voidify(*__first)) _ValueType;
195 __guard.release();
196 return __first;
197 }
198 }
199 };
200
201 inline constexpr __uninitialized_default_construct_n_fn
203
204 struct __uninitialized_value_construct_fn
205 {
206 template<__detail::__nothrow_forward_iterator _Iter,
207 __detail::__nothrow_sentinel<_Iter> _Sent>
208 requires default_initializable<iter_value_t<_Iter>>
209 _GLIBCXX26_CONSTEXPR
210 _Iter
211 operator()(_Iter __first, _Sent __last) const
212 {
213 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
214 if constexpr (is_trivially_default_constructible_v<_ValueType>
215 && is_trivially_copy_assignable_v<_ValueType>)
216 return ranges::fill(__first, __last, _ValueType());
217 else
218 {
219 auto __guard = __detail::_DestroyGuard(__first);
220 for (; __first != __last; ++__first)
221 ::new (__detail::__voidify(*__first)) _ValueType();
222 __guard.release();
223 return __first;
224 }
225 }
226
227 template<__detail::__nothrow_forward_range _Range>
228 requires default_initializable<range_value_t<_Range>>
229 _GLIBCXX26_CONSTEXPR
230 borrowed_iterator_t<_Range>
231 operator()(_Range&& __r) const
232 {
233 return (*this)(ranges::begin(__r), ranges::end(__r));
234 }
235 };
236
237 inline constexpr __uninitialized_value_construct_fn
239
240 struct __uninitialized_value_construct_n_fn
241 {
242 template<__detail::__nothrow_forward_iterator _Iter>
243 requires default_initializable<iter_value_t<_Iter>>
244 _GLIBCXX26_CONSTEXPR
245 _Iter
246 operator()(_Iter __first, iter_difference_t<_Iter> __n) const
247 {
248 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
249 if constexpr (is_trivially_default_constructible_v<_ValueType>
250 && is_trivially_copy_assignable_v<_ValueType>)
251 return ranges::fill_n(__first, __n, _ValueType());
252 else
253 {
254 auto __guard = __detail::_DestroyGuard(__first);
255 for (; __n > 0; ++__first, (void) --__n)
256 ::new (__detail::__voidify(*__first)) _ValueType();
257 __guard.release();
258 return __first;
259 }
260 }
261 };
262
263 inline constexpr __uninitialized_value_construct_n_fn
265
266 template<typename _Iter, typename _Out>
267 using uninitialized_copy_result = in_out_result<_Iter, _Out>;
268
269 struct __uninitialized_copy_fn
270 {
271 template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
272 __detail::__nothrow_forward_iterator _Out,
273 __detail::__nothrow_sentinel<_Out> _OSent>
274 requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>>
275 _GLIBCXX26_CONSTEXPR
276 uninitialized_copy_result<_Iter, _Out>
277 operator()(_Iter __ifirst, _ISent __ilast,
278 _Out __ofirst, _OSent __olast) const
279 {
280 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
281 if constexpr (sized_sentinel_for<_ISent, _Iter>
282 && sized_sentinel_for<_OSent, _Out>
283 && is_trivially_constructible_v<_OutType, iter_reference_t<_Iter>>
284 && is_trivially_default_constructible_v<_OutType>
285 && is_trivially_assignable_v<_OutType&,
286 iter_reference_t<_Iter>>)
287 {
288 auto __d1 = __ilast - __ifirst;
289 auto __d2 = __olast - __ofirst;
290 return ranges::copy_n(std::move(__ifirst), std::min(__d1, __d2),
291 __ofirst);
292 }
293 else
294 {
295 auto __guard = __detail::_DestroyGuard(__ofirst);
296 for (; __ifirst != __ilast && __ofirst != __olast;
297 ++__ofirst, (void)++__ifirst)
298 ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
299 __guard.release();
300 return {std::move(__ifirst), __ofirst};
301 }
302 }
303
304 template<input_range _IRange, __detail::__nothrow_forward_range _ORange>
305 requires constructible_from<range_value_t<_ORange>,
306 range_reference_t<_IRange>>
307 _GLIBCXX26_CONSTEXPR
308 uninitialized_copy_result<borrowed_iterator_t<_IRange>,
309 borrowed_iterator_t<_ORange>>
310 operator()(_IRange&& __inr, _ORange&& __outr) const
311 {
312 return (*this)(ranges::begin(__inr), ranges::end(__inr),
313 ranges::begin(__outr), ranges::end(__outr));
314 }
315 };
316
317 inline constexpr __uninitialized_copy_fn uninitialized_copy{};
318
319 template<typename _Iter, typename _Out>
320 using uninitialized_copy_n_result = in_out_result<_Iter, _Out>;
321
322 struct __uninitialized_copy_n_fn
323 {
324 template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
325 __detail::__nothrow_sentinel<_Out> _Sent>
326 requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>>
327 _GLIBCXX26_CONSTEXPR
328 uninitialized_copy_n_result<_Iter, _Out>
329 operator()(_Iter __ifirst, iter_difference_t<_Iter> __n,
330 _Out __ofirst, _Sent __olast) const
331 {
332 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
333 if constexpr (sized_sentinel_for<_Sent, _Out>
334 && is_trivially_constructible_v<_OutType, iter_reference_t<_Iter>>
335 && is_trivially_default_constructible_v<_OutType>
336 && is_trivially_assignable_v<_OutType&,
337 iter_reference_t<_Iter>>)
338 {
339 auto __d = __olast - __ofirst;
340 return ranges::copy_n(std::move(__ifirst), std::min(__n, __d),
341 __ofirst);
342 }
343 else
344 {
345 auto __guard = __detail::_DestroyGuard(__ofirst);
346 for (; __n > 0 && __ofirst != __olast;
347 ++__ofirst, (void)++__ifirst, (void)--__n)
348 ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
349 __guard.release();
350 return {std::move(__ifirst), __ofirst};
351 }
352 }
353 };
354
355 inline constexpr __uninitialized_copy_n_fn uninitialized_copy_n{};
356
357 template<typename _Iter, typename _Out>
358 using uninitialized_move_result = in_out_result<_Iter, _Out>;
359
360 struct __uninitialized_move_fn
361 {
362 template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
363 __detail::__nothrow_forward_iterator _Out,
364 __detail::__nothrow_sentinel<_Out> _OSent>
365 requires constructible_from<iter_value_t<_Out>,
366 iter_rvalue_reference_t<_Iter>>
367 _GLIBCXX26_CONSTEXPR
368 uninitialized_move_result<_Iter, _Out>
369 operator()(_Iter __ifirst, _ISent __ilast,
370 _Out __ofirst, _OSent __olast) const
371 {
372 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
373 if constexpr (sized_sentinel_for<_ISent, _Iter>
374 && sized_sentinel_for<_OSent, _Out>
375 && is_trivially_constructible_v<_OutType, iter_rvalue_reference_t<_Iter>>
376 && is_trivially_default_constructible_v<_OutType>
377 && is_trivially_assignable_v<_OutType&,
378 iter_rvalue_reference_t<_Iter>>)
379 {
380 auto __d1 = __ilast - __ifirst;
381 auto __d2 = __olast - __ofirst;
382 auto [__in, __out]
383 = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
384 std::min(__d1, __d2), __ofirst);
385 return {std::move(__in).base(), __out};
386 }
387 else
388 {
389 auto __guard = __detail::_DestroyGuard(__ofirst);
390 for (; __ifirst != __ilast && __ofirst != __olast;
391 ++__ofirst, (void)++__ifirst)
392 ::new (__detail::__voidify(*__ofirst))
393 _OutType(ranges::iter_move(__ifirst));
394 __guard.release();
395 return {std::move(__ifirst), __ofirst};
396 }
397 }
398
399 template<input_range _IRange, __detail::__nothrow_forward_range _ORange>
400 requires constructible_from<range_value_t<_ORange>,
401 range_rvalue_reference_t<_IRange>>
402 _GLIBCXX26_CONSTEXPR
403 uninitialized_move_result<borrowed_iterator_t<_IRange>,
404 borrowed_iterator_t<_ORange>>
405 operator()(_IRange&& __inr, _ORange&& __outr) const
406 {
407 return (*this)(ranges::begin(__inr), ranges::end(__inr),
408 ranges::begin(__outr), ranges::end(__outr));
409 }
410 };
411
412 inline constexpr __uninitialized_move_fn uninitialized_move{};
413
414 template<typename _Iter, typename _Out>
415 using uninitialized_move_n_result = in_out_result<_Iter, _Out>;
416
417 struct __uninitialized_move_n_fn
418 {
419 template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
420 __detail::__nothrow_sentinel<_Out> _Sent>
421 requires constructible_from<iter_value_t<_Out>,
422 iter_rvalue_reference_t<_Iter>>
423 _GLIBCXX26_CONSTEXPR
424 uninitialized_move_n_result<_Iter, _Out>
425 operator()(_Iter __ifirst, iter_difference_t<_Iter> __n,
426 _Out __ofirst, _Sent __olast) const
427 {
428 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
429 if constexpr (sized_sentinel_for<_Sent, _Out>
430 && is_trivially_constructible_v<_OutType, iter_rvalue_reference_t<_Iter>>
431 && is_trivially_default_constructible_v<_OutType>
432 && is_trivially_assignable_v<_OutType&,
433 iter_rvalue_reference_t<_Iter>>)
434 {
435 auto __d = __olast - __ofirst;
436 auto [__in, __out]
437 = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
438 std::min(__n, __d), __ofirst);
439 return {std::move(__in).base(), __out};
440 }
441 else
442 {
443 auto __guard = __detail::_DestroyGuard(__ofirst);
444 for (; __n > 0 && __ofirst != __olast;
445 ++__ofirst, (void)++__ifirst, (void)--__n)
446 ::new (__detail::__voidify(*__ofirst))
447 _OutType(ranges::iter_move(__ifirst));
448 __guard.release();
449 return {std::move(__ifirst), __ofirst};
450 }
451 }
452 };
453
454 inline constexpr __uninitialized_move_n_fn uninitialized_move_n{};
455
456 struct __uninitialized_fill_fn
457 {
458 template<__detail::__nothrow_forward_iterator _Iter,
459 __detail::__nothrow_sentinel<_Iter> _Sent, typename _Tp>
460 requires constructible_from<iter_value_t<_Iter>, const _Tp&>
461 _GLIBCXX26_CONSTEXPR
462 _Iter
463 operator()(_Iter __first, _Sent __last, const _Tp& __x) const
464 {
465 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
466 if constexpr (is_trivially_constructible_v<_ValueType, const _Tp&>
467 && is_trivially_assignable_v<_ValueType&, const _Tp&>)
468 return ranges::fill(__first, __last, __x);
469 else
470 {
471 auto __guard = __detail::_DestroyGuard(__first);
472 for (; __first != __last; ++__first)
473 ::new (__detail::__voidify(*__first)) _ValueType(__x);
474 __guard.release();
475 return __first;
476 }
477 }
478
479 template<__detail::__nothrow_forward_range _Range, typename _Tp>
480 requires constructible_from<range_value_t<_Range>, const _Tp&>
481 _GLIBCXX26_CONSTEXPR
482 borrowed_iterator_t<_Range>
483 operator()(_Range&& __r, const _Tp& __x) const
484 {
485 return (*this)(ranges::begin(__r), ranges::end(__r), __x);
486 }
487 };
488
489 inline constexpr __uninitialized_fill_fn uninitialized_fill{};
490
491 struct __uninitialized_fill_n_fn
492 {
493 template<__detail::__nothrow_forward_iterator _Iter, typename _Tp>
494 requires constructible_from<iter_value_t<_Iter>, const _Tp&>
495 _GLIBCXX26_CONSTEXPR
496 _Iter
497 operator()(_Iter __first, iter_difference_t<_Iter> __n,
498 const _Tp& __x) const
499 {
500 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
501 if constexpr (is_trivially_constructible_v<_ValueType, const _Tp&>
502 && is_trivially_assignable_v<_ValueType&, const _Tp&>)
503 return ranges::fill_n(__first, __n, __x);
504 else
505 {
506 auto __guard = __detail::_DestroyGuard(__first);
507 for (; __n > 0; ++__first, (void)--__n)
508 ::new (__detail::__voidify(*__first)) _ValueType(__x);
509 __guard.release();
510 return __first;
511 }
512 }
513 };
514
515 inline constexpr __uninitialized_fill_n_fn uninitialized_fill_n{};
516
517 struct __construct_at_fn
518 {
519 template<typename _Tp, typename... _Args>
520 requires requires {
521 ::new (std::declval<void*>()) _Tp(std::declval<_Args>()...);
522 }
523 constexpr _Tp*
524 operator()(_Tp* __location, _Args&&... __args) const
525 noexcept(noexcept(std::construct_at(__location,
526 std::forward<_Args>(__args)...)))
527 {
528 return std::construct_at(__location,
529 std::forward<_Args>(__args)...);
530 }
531 };
532
533 inline constexpr __construct_at_fn construct_at{};
534
535 struct __destroy_at_fn
536 {
537 template<destructible _Tp>
538 constexpr void
539 operator()(_Tp* __location) const noexcept
540 {
541 if constexpr (is_array_v<_Tp>)
542 ranges::destroy(ranges::begin(*__location), ranges::end(*__location));
543 else
544 __location->~_Tp();
545 }
546 };
547
548 inline constexpr __destroy_at_fn destroy_at{};
549
550 template<__detail::__nothrow_input_iterator _Iter,
551 __detail::__nothrow_sentinel<_Iter> _Sent>
552 requires destructible<iter_value_t<_Iter>>
553 constexpr _Iter
554 __destroy_fn::operator()(_Iter __first, _Sent __last) const noexcept
555 {
556 if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
557 return ranges::next(std::move(__first), __last);
558 else
559 {
560 for (; __first != __last; ++__first)
561 ranges::destroy_at(std::__addressof(*__first));
562 return __first;
563 }
564 }
565
566 template<__detail::__nothrow_input_range _Range>
567 requires destructible<range_value_t<_Range>>
568 constexpr borrowed_iterator_t<_Range>
569 __destroy_fn::operator()(_Range&& __r) const noexcept
570 {
571 return (*this)(ranges::begin(__r), ranges::end(__r));
572 }
573
574 struct __destroy_n_fn
575 {
576 template<__detail::__nothrow_input_iterator _Iter>
577 requires destructible<iter_value_t<_Iter>>
578 constexpr _Iter
579 operator()(_Iter __first, iter_difference_t<_Iter> __n) const noexcept
580 {
581 if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
582 return ranges::next(std::move(__first), __n);
583 else
584 {
585 for (; __n > 0; ++__first, (void)--__n)
586 ranges::destroy_at(std::__addressof(*__first));
587 return __first;
588 }
589 }
590 };
591
592 inline constexpr __destroy_n_fn destroy_n{};
593}
594_GLIBCXX_END_NAMESPACE_VERSION
595} // namespace std
596
597#endif // concepts
598#endif // C++20
599#endif // _RANGES_UNINITIALIZED_H
_GLIBCXX26_CONSTEXPR void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp &__x)
Copies the value x into the range [first,last).
_GLIBCXX26_CONSTEXPR _ForwardIterator uninitialized_copy_n(_InputIterator __first, _Size __n, _ForwardIterator __result)
Copies the range [first,first+n) into result.
_GLIBCXX26_CONSTEXPR void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last)
Value-initializes objects in the range [first,last).
_GLIBCXX26_CONSTEXPR void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last)
Default-initializes objects in the range [first,last).
_GLIBCXX26_CONSTEXPR _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp &__x)
Copies the value x into the range [first,first+n).
_GLIBCXX26_CONSTEXPR _ForwardIterator uninitialized_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result)
Copies the range [first,last) into result.
_GLIBCXX26_CONSTEXPR _ForwardIterator uninitialized_move(_InputIterator __first, _InputIterator __last, _ForwardIterator __result)
Move-construct from the range [first,last) into result.
_GLIBCXX26_CONSTEXPR _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
Value-initializes objects in the range [first,first+count).
_GLIBCXX26_CONSTEXPR pair< _InputIterator, _ForwardIterator > uninitialized_move_n(_InputIterator __first, _Size __count, _ForwardIterator __result)
Move-construct from the range [first,first+count) into result.
_GLIBCXX26_CONSTEXPR _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
Default-initializes objects in the range [first,first+count).
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:138
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition move.h:52
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
ISO C++ entities toplevel namespace is std.