1 // Raw memory manipulators -*- C++ -*-
2
3 // Copyright (C) 2001-2018 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 /*
26 *
27 * Copyright (c) 1994
28 * Hewlett-Packard Company
29 *
30 * Permission to use, copy, modify, distribute and sell this software
31 * and its documentation for any purpose is hereby granted without fee,
32 * provided that the above copyright notice appear in all copies and
33 * that both that copyright notice and this permission notice appear
34 * in supporting documentation. Hewlett-Packard Company makes no
35 * representations about the suitability of this software for any
36 * purpose. It is provided "as is" without express or implied warranty.
37 *
38 *
39 * Copyright (c) 1996,1997
40 * Silicon Graphics Computer Systems, Inc.
41 *
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Silicon Graphics makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
49 */
50
51 /** @file bits/stl_uninitialized.h
52 * This is an internal header file, included by other library headers.
53 * Do not attempt to use it directly. @headername{memory}
54 */
55
56 #ifndef _STL_UNINITIALIZED_H
57 #define _STL_UNINITIALIZED_H 1
58
59 #if __cplusplus > 201402L
60 #include <utility>
61 #endif
62
63 #if __cplusplus >= 201103L
64 #include <type_traits>
65 #endif
66
_GLIBCXX_VISIBILITY(default)67 namespace std _GLIBCXX_VISIBILITY(default)
68 {
69 _GLIBCXX_BEGIN_NAMESPACE_VERSION
70
71 template<bool _TrivialValueTypes>
72 struct __uninitialized_copy
73 {
74 template<typename _InputIterator, typename _ForwardIterator>
75 static _ForwardIterator
76 __uninit_copy(_InputIterator __first, _InputIterator __last,
77 _ForwardIterator __result)
78 {
79 _ForwardIterator __cur = __result;
80 __try
81 {
82 for (; __first != __last; ++__first, (void)++__cur)
83 std::_Construct(std::__addressof(*__cur), *__first);
84 return __cur;
85 }
86 __catch(...)
87 {
88 std::_Destroy(__result, __cur);
89 __throw_exception_again;
90 }
91 }
92 };
93
94 template<>
95 struct __uninitialized_copy<true>
96 {
97 template<typename _InputIterator, typename _ForwardIterator>
98 static _ForwardIterator
99 __uninit_copy(_InputIterator __first, _InputIterator __last,
100 _ForwardIterator __result)
101 { return std::copy(__first, __last, __result); }
102 };
103
104 /**
105 * @brief Copies the range [first,last) into result.
106 * @param __first An input iterator.
107 * @param __last An input iterator.
108 * @param __result An output iterator.
109 * @return __result + (__first - __last)
110 *
111 * Like copy(), but does not require an initialized output range.
112 */
113 template<typename _InputIterator, typename _ForwardIterator>
114 inline _ForwardIterator
115 uninitialized_copy(_InputIterator __first, _InputIterator __last,
116 _ForwardIterator __result)
117 {
118 typedef typename iterator_traits<_InputIterator>::value_type
119 _ValueType1;
120 typedef typename iterator_traits<_ForwardIterator>::value_type
121 _ValueType2;
122 #if __cplusplus < 201103L
123 const bool __assignable = true;
124 #else
125 // trivial types can have deleted assignment
126 typedef typename iterator_traits<_InputIterator>::reference _RefType1;
127 typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
128 const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
129 #endif
130
131 return std::__uninitialized_copy<__is_trivial(_ValueType1)
132 && __is_trivial(_ValueType2)
133 && __assignable>::
134 __uninit_copy(__first, __last, __result);
135 }
136
137
138 template<bool _TrivialValueType>
139 struct __uninitialized_fill
140 {
141 template<typename _ForwardIterator, typename _Tp>
142 static void
143 __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
144 const _Tp& __x)
145 {
146 _ForwardIterator __cur = __first;
147 __try
148 {
149 for (; __cur != __last; ++__cur)
150 std::_Construct(std::__addressof(*__cur), __x);
151 }
152 __catch(...)
153 {
154 std::_Destroy(__first, __cur);
155 __throw_exception_again;
156 }
157 }
158 };
159
160 template<>
161 struct __uninitialized_fill<true>
162 {
163 template<typename _ForwardIterator, typename _Tp>
164 static void
165 __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
166 const _Tp& __x)
167 { std::fill(__first, __last, __x); }
168 };
169
170 /**
171 * @brief Copies the value x into the range [first,last).
172 * @param __first An input iterator.
173 * @param __last An input iterator.
174 * @param __x The source value.
175 * @return Nothing.
176 *
177 * Like fill(), but does not require an initialized output range.
178 */
179 template<typename _ForwardIterator, typename _Tp>
180 inline void
181 uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
182 const _Tp& __x)
183 {
184 typedef typename iterator_traits<_ForwardIterator>::value_type
185 _ValueType;
186 #if __cplusplus < 201103L
187 const bool __assignable = true;
188 #else
189 // trivial types can have deleted assignment
190 const bool __assignable = is_copy_assignable<_ValueType>::value;
191 #endif
192
193 std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
194 __uninit_fill(__first, __last, __x);
195 }
196
197
198 template<bool _TrivialValueType>
199 struct __uninitialized_fill_n
200 {
201 template<typename _ForwardIterator, typename _Size, typename _Tp>
202 static _ForwardIterator
203 __uninit_fill_n(_ForwardIterator __first, _Size __n,
204 const _Tp& __x)
205 {
206 _ForwardIterator __cur = __first;
207 __try
208 {
209 for (; __n > 0; --__n, (void) ++__cur)
210 std::_Construct(std::__addressof(*__cur), __x);
211 return __cur;
212 }
213 __catch(...)
214 {
215 std::_Destroy(__first, __cur);
216 __throw_exception_again;
217 }
218 }
219 };
220
221 template<>
222 struct __uninitialized_fill_n<true>
223 {
224 template<typename _ForwardIterator, typename _Size, typename _Tp>
225 static _ForwardIterator
226 __uninit_fill_n(_ForwardIterator __first, _Size __n,
227 const _Tp& __x)
228 { return std::fill_n(__first, __n, __x); }
229 };
230
231 // _GLIBCXX_RESOLVE_LIB_DEFECTS
232 // DR 1339. uninitialized_fill_n should return the end of its range
233 /**
234 * @brief Copies the value x into the range [first,first+n).
235 * @param __first An input iterator.
236 * @param __n The number of copies to make.
237 * @param __x The source value.
238 * @return Nothing.
239 *
240 * Like fill_n(), but does not require an initialized output range.
241 */
242 template<typename _ForwardIterator, typename _Size, typename _Tp>
243 inline _ForwardIterator
244 uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
245 {
246 typedef typename iterator_traits<_ForwardIterator>::value_type
247 _ValueType;
248 #if __cplusplus < 201103L
249 const bool __assignable = true;
250 #else
251 // trivial types can have deleted assignment
252 const bool __assignable = is_copy_assignable<_ValueType>::value;
253 #endif
254 return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
255 __uninit_fill_n(__first, __n, __x);
256 }
257
258 // Extensions: versions of uninitialized_copy, uninitialized_fill,
259 // and uninitialized_fill_n that take an allocator parameter.
260 // We dispatch back to the standard versions when we're given the
261 // default allocator. For nondefault allocators we do not use
262 // any of the POD optimizations.
263
264 template<typename _InputIterator, typename _ForwardIterator,
265 typename _Allocator>
266 _ForwardIterator
267 __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
268 _ForwardIterator __result, _Allocator& __alloc)
269 {
270 _ForwardIterator __cur = __result;
271 __try
272 {
273 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
274 for (; __first != __last; ++__first, (void)++__cur)
275 __traits::construct(__alloc, std::__addressof(*__cur), *__first);
276 return __cur;
277 }
278 __catch(...)
279 {
280 std::_Destroy(__result, __cur, __alloc);
281 __throw_exception_again;
282 }
283 }
284
285 template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
286 inline _ForwardIterator
287 __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
288 _ForwardIterator __result, allocator<_Tp>&)
289 { return std::uninitialized_copy(__first, __last, __result); }
290
291 template<typename _InputIterator, typename _ForwardIterator,
292 typename _Allocator>
293 inline _ForwardIterator
294 __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
295 _ForwardIterator __result, _Allocator& __alloc)
296 {
297 return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
298 _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
299 __result, __alloc);
300 }
301
302 template<typename _InputIterator, typename _ForwardIterator,
303 typename _Allocator>
304 inline _ForwardIterator
305 __uninitialized_move_if_noexcept_a(_InputIterator __first,
306 _InputIterator __last,
307 _ForwardIterator __result,
308 _Allocator& __alloc)
309 {
310 return std::__uninitialized_copy_a
311 (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
312 _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
313 }
314
315 template<typename _ForwardIterator, typename _Tp, typename _Allocator>
316 void
317 __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
318 const _Tp& __x, _Allocator& __alloc)
319 {
320 _ForwardIterator __cur = __first;
321 __try
322 {
323 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
324 for (; __cur != __last; ++__cur)
325 __traits::construct(__alloc, std::__addressof(*__cur), __x);
326 }
327 __catch(...)
328 {
329 std::_Destroy(__first, __cur, __alloc);
330 __throw_exception_again;
331 }
332 }
333
334 template<typename _ForwardIterator, typename _Tp, typename _Tp2>
335 inline void
336 __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
337 const _Tp& __x, allocator<_Tp2>&)
338 { std::uninitialized_fill(__first, __last, __x); }
339
340 template<typename _ForwardIterator, typename _Size, typename _Tp,
341 typename _Allocator>
342 _ForwardIterator
343 __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
344 const _Tp& __x, _Allocator& __alloc)
345 {
346 _ForwardIterator __cur = __first;
347 __try
348 {
349 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
350 for (; __n > 0; --__n, (void) ++__cur)
351 __traits::construct(__alloc, std::__addressof(*__cur), __x);
352 return __cur;
353 }
354 __catch(...)
355 {
356 std::_Destroy(__first, __cur, __alloc);
357 __throw_exception_again;
358 }
359 }
360
361 template<typename _ForwardIterator, typename _Size, typename _Tp,
362 typename _Tp2>
363 inline _ForwardIterator
364 __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
365 const _Tp& __x, allocator<_Tp2>&)
366 { return std::uninitialized_fill_n(__first, __n, __x); }
367
368
369 // Extensions: __uninitialized_copy_move, __uninitialized_move_copy,
370 // __uninitialized_fill_move, __uninitialized_move_fill.
371 // All of these algorithms take a user-supplied allocator, which is used
372 // for construction and destruction.
373
374 // __uninitialized_copy_move
375 // Copies [first1, last1) into [result, result + (last1 - first1)), and
376 // move [first2, last2) into
377 // [result, result + (last1 - first1) + (last2 - first2)).
378 template<typename _InputIterator1, typename _InputIterator2,
379 typename _ForwardIterator, typename _Allocator>
380 inline _ForwardIterator
381 __uninitialized_copy_move(_InputIterator1 __first1,
382 _InputIterator1 __last1,
383 _InputIterator2 __first2,
384 _InputIterator2 __last2,
385 _ForwardIterator __result,
386 _Allocator& __alloc)
387 {
388 _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
389 __result,
390 __alloc);
391 __try
392 {
393 return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
394 }
395 __catch(...)
396 {
397 std::_Destroy(__result, __mid, __alloc);
398 __throw_exception_again;
399 }
400 }
401
402 // __uninitialized_move_copy
403 // Moves [first1, last1) into [result, result + (last1 - first1)), and
404 // copies [first2, last2) into
405 // [result, result + (last1 - first1) + (last2 - first2)).
406 template<typename _InputIterator1, typename _InputIterator2,
407 typename _ForwardIterator, typename _Allocator>
408 inline _ForwardIterator
409 __uninitialized_move_copy(_InputIterator1 __first1,
410 _InputIterator1 __last1,
411 _InputIterator2 __first2,
412 _InputIterator2 __last2,
413 _ForwardIterator __result,
414 _Allocator& __alloc)
415 {
416 _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
417 __result,
418 __alloc);
419 __try
420 {
421 return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
422 }
423 __catch(...)
424 {
425 std::_Destroy(__result, __mid, __alloc);
426 __throw_exception_again;
427 }
428 }
429
430 // __uninitialized_fill_move
431 // Fills [result, mid) with x, and moves [first, last) into
432 // [mid, mid + (last - first)).
433 template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
434 typename _Allocator>
435 inline _ForwardIterator
436 __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
437 const _Tp& __x, _InputIterator __first,
438 _InputIterator __last, _Allocator& __alloc)
439 {
440 std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
441 __try
442 {
443 return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
444 }
445 __catch(...)
446 {
447 std::_Destroy(__result, __mid, __alloc);
448 __throw_exception_again;
449 }
450 }
451
452 // __uninitialized_move_fill
453 // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and
454 // fills [first2 + (last1 - first1), last2) with x.
455 template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
456 typename _Allocator>
457 inline void
458 __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
459 _ForwardIterator __first2,
460 _ForwardIterator __last2, const _Tp& __x,
461 _Allocator& __alloc)
462 {
463 _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
464 __first2,
465 __alloc);
466 __try
467 {
468 std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
469 }
470 __catch(...)
471 {
472 std::_Destroy(__first2, __mid2, __alloc);
473 __throw_exception_again;
474 }
475 }
476
477 #if __cplusplus >= 201103L
478 // Extensions: __uninitialized_default, __uninitialized_default_n,
479 // __uninitialized_default_a, __uninitialized_default_n_a.
480
481 template<bool _TrivialValueType>
482 struct __uninitialized_default_1
483 {
484 template<typename _ForwardIterator>
485 static void
486 __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
487 {
488 _ForwardIterator __cur = __first;
489 __try
490 {
491 for (; __cur != __last; ++__cur)
492 std::_Construct(std::__addressof(*__cur));
493 }
494 __catch(...)
495 {
496 std::_Destroy(__first, __cur);
497 __throw_exception_again;
498 }
499 }
500 };
501
502 template<>
503 struct __uninitialized_default_1<true>
504 {
505 template<typename _ForwardIterator>
506 static void
507 __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
508 {
509 typedef typename iterator_traits<_ForwardIterator>::value_type
510 _ValueType;
511
512 std::fill(__first, __last, _ValueType());
513 }
514 };
515
516 template<bool _TrivialValueType>
517 struct __uninitialized_default_n_1
518 {
519 template<typename _ForwardIterator, typename _Size>
520 static _ForwardIterator
521 __uninit_default_n(_ForwardIterator __first, _Size __n)
522 {
523 _ForwardIterator __cur = __first;
524 __try
525 {
526 for (; __n > 0; --__n, (void) ++__cur)
527 std::_Construct(std::__addressof(*__cur));
528 return __cur;
529 }
530 __catch(...)
531 {
532 std::_Destroy(__first, __cur);
533 __throw_exception_again;
534 }
535 }
536 };
537
538 template<>
539 struct __uninitialized_default_n_1<true>
540 {
541 template<typename _ForwardIterator, typename _Size>
542 static _ForwardIterator
543 __uninit_default_n(_ForwardIterator __first, _Size __n)
544 {
545 typedef typename iterator_traits<_ForwardIterator>::value_type
546 _ValueType;
547
548 return std::fill_n(__first, __n, _ValueType());
549 }
550 };
551
552 // __uninitialized_default
553 // Fills [first, last) with std::distance(first, last) default
554 // constructed value_types(s).
555 template<typename _ForwardIterator>
556 inline void
557 __uninitialized_default(_ForwardIterator __first,
558 _ForwardIterator __last)
559 {
560 typedef typename iterator_traits<_ForwardIterator>::value_type
561 _ValueType;
562 // trivial types can have deleted assignment
563 const bool __assignable = is_copy_assignable<_ValueType>::value;
564
565 std::__uninitialized_default_1<__is_trivial(_ValueType)
566 && __assignable>::
567 __uninit_default(__first, __last);
568 }
569
570 // __uninitialized_default_n
571 // Fills [first, first + n) with n default constructed value_type(s).
572 template<typename _ForwardIterator, typename _Size>
573 inline _ForwardIterator
574 __uninitialized_default_n(_ForwardIterator __first, _Size __n)
575 {
576 typedef typename iterator_traits<_ForwardIterator>::value_type
577 _ValueType;
578 // trivial types can have deleted assignment
579 const bool __assignable = is_copy_assignable<_ValueType>::value;
580
581 return __uninitialized_default_n_1<__is_trivial(_ValueType)
582 && __assignable>::
583 __uninit_default_n(__first, __n);
584 }
585
586
587 // __uninitialized_default_a
588 // Fills [first, last) with std::distance(first, last) default
589 // constructed value_types(s), constructed with the allocator alloc.
590 template<typename _ForwardIterator, typename _Allocator>
591 void
592 __uninitialized_default_a(_ForwardIterator __first,
593 _ForwardIterator __last,
594 _Allocator& __alloc)
595 {
596 _ForwardIterator __cur = __first;
597 __try
598 {
599 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
600 for (; __cur != __last; ++__cur)
601 __traits::construct(__alloc, std::__addressof(*__cur));
602 }
603 __catch(...)
604 {
605 std::_Destroy(__first, __cur, __alloc);
606 __throw_exception_again;
607 }
608 }
609
610 template<typename _ForwardIterator, typename _Tp>
611 inline void
612 __uninitialized_default_a(_ForwardIterator __first,
613 _ForwardIterator __last,
614 allocator<_Tp>&)
615 { std::__uninitialized_default(__first, __last); }
616
617
618 // __uninitialized_default_n_a
619 // Fills [first, first + n) with n default constructed value_types(s),
620 // constructed with the allocator alloc.
621 template<typename _ForwardIterator, typename _Size, typename _Allocator>
622 _ForwardIterator
623 __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
624 _Allocator& __alloc)
625 {
626 _ForwardIterator __cur = __first;
627 __try
628 {
629 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
630 for (; __n > 0; --__n, (void) ++__cur)
631 __traits::construct(__alloc, std::__addressof(*__cur));
632 return __cur;
633 }
634 __catch(...)
635 {
636 std::_Destroy(__first, __cur, __alloc);
637 __throw_exception_again;
638 }
639 }
640
641 template<typename _ForwardIterator, typename _Size, typename _Tp>
642 inline _ForwardIterator
643 __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
644 allocator<_Tp>&)
645 { return std::__uninitialized_default_n(__first, __n); }
646
647 template<bool _TrivialValueType>
648 struct __uninitialized_default_novalue_1
649 {
650 template<typename _ForwardIterator>
651 static void
652 __uninit_default_novalue(_ForwardIterator __first,
653 _ForwardIterator __last)
654 {
655 _ForwardIterator __cur = __first;
656 __try
657 {
658 for (; __cur != __last; ++__cur)
659 std::_Construct_novalue(std::__addressof(*__cur));
660 }
661 __catch(...)
662 {
663 std::_Destroy(__first, __cur);
664 __throw_exception_again;
665 }
666 }
667 };
668
669 template<>
670 struct __uninitialized_default_novalue_1<true>
671 {
672 template<typename _ForwardIterator>
673 static void
674 __uninit_default_novalue(_ForwardIterator __first,
675 _ForwardIterator __last)
676 {
677 }
678 };
679
680 template<bool _TrivialValueType>
681 struct __uninitialized_default_novalue_n_1
682 {
683 template<typename _ForwardIterator, typename _Size>
684 static _ForwardIterator
685 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
686 {
687 _ForwardIterator __cur = __first;
688 __try
689 {
690 for (; __n > 0; --__n, (void) ++__cur)
691 std::_Construct_novalue(std::__addressof(*__cur));
692 return __cur;
693 }
694 __catch(...)
695 {
696 std::_Destroy(__first, __cur);
697 __throw_exception_again;
698 }
699 }
700 };
701
702 template<>
703 struct __uninitialized_default_novalue_n_1<true>
704 {
705 template<typename _ForwardIterator, typename _Size>
706 static _ForwardIterator
707 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
708 { return std::next(__first, __n); }
709 };
710
711 // __uninitialized_default_novalue
712 // Fills [first, last) with std::distance(first, last) default-initialized
713 // value_types(s).
714 template<typename _ForwardIterator>
715 inline void
716 __uninitialized_default_novalue(_ForwardIterator __first,
717 _ForwardIterator __last)
718 {
719 typedef typename iterator_traits<_ForwardIterator>::value_type
720 _ValueType;
721
722 std::__uninitialized_default_novalue_1<
723 is_trivially_default_constructible<_ValueType>::value>::
724 __uninit_default_novalue(__first, __last);
725 }
726
727 // __uninitialized_default_n
728 // Fills [first, first + n) with n default-initialized value_type(s).
729 template<typename _ForwardIterator, typename _Size>
730 inline _ForwardIterator
731 __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)
732 {
733 typedef typename iterator_traits<_ForwardIterator>::value_type
734 _ValueType;
735
736 return __uninitialized_default_novalue_n_1<
737 is_trivially_default_constructible<_ValueType>::value>::
738 __uninit_default_novalue_n(__first, __n);
739 }
740
741 template<typename _InputIterator, typename _Size,
742 typename _ForwardIterator>
743 _ForwardIterator
744 __uninitialized_copy_n(_InputIterator __first, _Size __n,
745 _ForwardIterator __result, input_iterator_tag)
746 {
747 _ForwardIterator __cur = __result;
748 __try
749 {
750 for (; __n > 0; --__n, (void) ++__first, ++__cur)
751 std::_Construct(std::__addressof(*__cur), *__first);
752 return __cur;
753 }
754 __catch(...)
755 {
756 std::_Destroy(__result, __cur);
757 __throw_exception_again;
758 }
759 }
760
761 template<typename _RandomAccessIterator, typename _Size,
762 typename _ForwardIterator>
763 inline _ForwardIterator
764 __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
765 _ForwardIterator __result,
766 random_access_iterator_tag)
767 { return std::uninitialized_copy(__first, __first + __n, __result); }
768
769 template<typename _InputIterator, typename _Size,
770 typename _ForwardIterator>
771 pair<_InputIterator, _ForwardIterator>
772 __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
773 _ForwardIterator __result, input_iterator_tag)
774 {
775 _ForwardIterator __cur = __result;
776 __try
777 {
778 for (; __n > 0; --__n, (void) ++__first, ++__cur)
779 std::_Construct(std::__addressof(*__cur), *__first);
780 return {__first, __cur};
781 }
782 __catch(...)
783 {
784 std::_Destroy(__result, __cur);
785 __throw_exception_again;
786 }
787 }
788
789 template<typename _RandomAccessIterator, typename _Size,
790 typename _ForwardIterator>
791 inline pair<_RandomAccessIterator, _ForwardIterator>
792 __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,
793 _ForwardIterator __result,
794 random_access_iterator_tag)
795 {
796 auto __second_res = uninitialized_copy(__first, __first + __n, __result);
797 auto __first_res = std::next(__first, __n);
798 return {__first_res, __second_res};
799 }
800
801 /**
802 * @brief Copies the range [first,first+n) into result.
803 * @param __first An input iterator.
804 * @param __n The number of elements to copy.
805 * @param __result An output iterator.
806 * @return __result + __n
807 *
808 * Like copy_n(), but does not require an initialized output range.
809 */
810 template<typename _InputIterator, typename _Size, typename _ForwardIterator>
811 inline _ForwardIterator
812 uninitialized_copy_n(_InputIterator __first, _Size __n,
813 _ForwardIterator __result)
814 { return std::__uninitialized_copy_n(__first, __n, __result,
815 std::__iterator_category(__first)); }
816
817 template<typename _InputIterator, typename _Size, typename _ForwardIterator>
818 inline pair<_InputIterator, _ForwardIterator>
819 __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
820 _ForwardIterator __result)
821 {
822 return
823 std::__uninitialized_copy_n_pair(__first, __n, __result,
824 std::__iterator_category(__first));
825 }
826
827 #endif
828
829 #if __cplusplus > 201402L
830 template <typename _ForwardIterator>
831 inline void
832 uninitialized_default_construct(_ForwardIterator __first,
833 _ForwardIterator __last)
834 {
835 __uninitialized_default_novalue(__first, __last);
836 }
837
838 template <typename _ForwardIterator, typename _Size>
839 inline _ForwardIterator
840 uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
841 {
842 return __uninitialized_default_novalue_n(__first, __count);
843 }
844
845 template <typename _ForwardIterator>
846 inline void
847 uninitialized_value_construct(_ForwardIterator __first,
848 _ForwardIterator __last)
849 {
850 return __uninitialized_default(__first, __last);
851 }
852
853 template <typename _ForwardIterator, typename _Size>
854 inline _ForwardIterator
855 uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
856 {
857 return __uninitialized_default_n(__first, __count);
858 }
859
860 template <typename _InputIterator, typename _ForwardIterator>
861 inline _ForwardIterator
862 uninitialized_move(_InputIterator __first, _InputIterator __last,
863 _ForwardIterator __result)
864 {
865 return std::uninitialized_copy
866 (_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
867 _GLIBCXX_MAKE_MOVE_ITERATOR(__last), __result);
868 }
869
870 template <typename _InputIterator, typename _Size, typename _ForwardIterator>
871 inline pair<_InputIterator, _ForwardIterator>
872 uninitialized_move_n(_InputIterator __first, _Size __count,
873 _ForwardIterator __result)
874 {
875 auto __res = std::__uninitialized_copy_n_pair
876 (_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
877 __count, __result);
878 return {__res.first.base(), __res.second};
879 }
880 #endif
881
882 _GLIBCXX_END_NAMESPACE_VERSION
883 } // namespace
884
885 #endif /* _STL_UNINITIALIZED_H */
886