1// Raw memory manipulators -*- C++ -*- 
2 
3// Copyright (C) 2001-2019 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 
67namespace 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 copy constructor, but the std::copy 
126 // optimization that uses memmove would happily "copy" them anyway. 
127 static_assert(is_constructible<_ValueType2, decltype(*__first)>::value, 
128 "result type must be constructible from value type of input range"); 
129 
130 typedef typename iterator_traits<_InputIterator>::reference _RefType1; 
131 typedef typename iterator_traits<_ForwardIterator>::reference _RefType2; 
132 // Trivial types can have deleted assignment, so using std::copy 
133 // would be ill-formed. Require assignability before using std::copy: 
134 const bool __assignable = is_assignable<_RefType2, _RefType1>::value; 
135#endif 
136 
137 return std::__uninitialized_copy<__is_trivial(_ValueType1) 
138 && __is_trivial(_ValueType2) 
139 && __assignable>:: 
140 __uninit_copy(__first, __last, __result); 
141 } 
142 
143 
144 template<bool _TrivialValueType> 
145 struct __uninitialized_fill 
146 { 
147 template<typename _ForwardIterator, typename _Tp> 
148 static void 
149 __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, 
150 const _Tp& __x) 
151 { 
152 _ForwardIterator __cur = __first; 
153 __try 
154 { 
155 for (; __cur != __last; ++__cur) 
156 std::_Construct(std::__addressof(*__cur), __x); 
157 } 
158 __catch(...) 
159 { 
160 std::_Destroy(__first, __cur); 
161 __throw_exception_again; 
162 } 
163 } 
164 }; 
165 
166 template<> 
167 struct __uninitialized_fill<true> 
168 { 
169 template<typename _ForwardIterator, typename _Tp> 
170 static void 
171 __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, 
172 const _Tp& __x) 
173 { std::fill(__first, __last, __x); } 
174 }; 
175 
176 /** 
177 * @brief Copies the value x into the range [first,last). 
178 * @param __first An input iterator. 
179 * @param __last An input iterator. 
180 * @param __x The source value. 
181 * @return Nothing. 
182 * 
183 * Like fill(), but does not require an initialized output range. 
184 */ 
185 template<typename _ForwardIterator, typename _Tp> 
186 inline void 
187 uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, 
188 const _Tp& __x) 
189 { 
190 typedef typename iterator_traits<_ForwardIterator>::value_type 
191 _ValueType; 
192#if __cplusplus < 201103L 
193 const bool __assignable = true; 
194#else 
195 // Trivial types can have deleted copy constructor, but the std::fill 
196 // optimization that uses memmove would happily "copy" them anyway. 
197 static_assert(is_constructible<_ValueType, const _Tp&>::value, 
198 "result type must be constructible from input type"); 
199 
200 // Trivial types can have deleted assignment, so using std::fill 
201 // would be ill-formed. Require assignability before using std::fill: 
202 const bool __assignable = is_copy_assignable<_ValueType>::value; 
203#endif 
204 
205 std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>:: 
206 __uninit_fill(__first, __last, __x); 
207 } 
208 
209 
210 template<bool _TrivialValueType> 
211 struct __uninitialized_fill_n 
212 { 
213 template<typename _ForwardIterator, typename _Size, typename _Tp> 
214 static _ForwardIterator 
215 __uninit_fill_n(_ForwardIterator __first, _Size __n, 
216 const _Tp& __x) 
217 { 
218 _ForwardIterator __cur = __first; 
219 __try 
220 { 
221 for (; __n > 0; --__n, (void) ++__cur) 
222 std::_Construct(std::__addressof(*__cur), __x); 
223 return __cur; 
224 } 
225 __catch(...) 
226 { 
227 std::_Destroy(__first, __cur); 
228 __throw_exception_again; 
229 } 
230 } 
231 }; 
232 
233 template<> 
234 struct __uninitialized_fill_n<true> 
235 { 
236 template<typename _ForwardIterator, typename _Size, typename _Tp> 
237 static _ForwardIterator 
238 __uninit_fill_n(_ForwardIterator __first, _Size __n, 
239 const _Tp& __x) 
240 { return std::fill_n(__first, __n, __x); } 
241 }; 
242 
243 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
244 // DR 1339. uninitialized_fill_n should return the end of its range 
245 /** 
246 * @brief Copies the value x into the range [first,first+n). 
247 * @param __first An input iterator. 
248 * @param __n The number of copies to make. 
249 * @param __x The source value. 
250 * @return Nothing. 
251 * 
252 * Like fill_n(), but does not require an initialized output range. 
253 */ 
254 template<typename _ForwardIterator, typename _Size, typename _Tp> 
255 inline _ForwardIterator 
256 uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) 
257 { 
258 typedef typename iterator_traits<_ForwardIterator>::value_type 
259 _ValueType; 
260#if __cplusplus < 201103L 
261 const bool __assignable = true; 
262#else 
263 // Trivial types can have deleted copy constructor, but the std::fill 
264 // optimization that uses memmove would happily "copy" them anyway. 
265 static_assert(is_constructible<_ValueType, const _Tp&>::value, 
266 "result type must be constructible from input type"); 
267 
268 // Trivial types can have deleted assignment, so using std::fill 
269 // would be ill-formed. Require assignability before using std::fill: 
270 const bool __assignable = is_copy_assignable<_ValueType>::value; 
271#endif 
272 return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>:: 
273 __uninit_fill_n(__first, __n, __x); 
274 } 
275 
276 // Extensions: versions of uninitialized_copy, uninitialized_fill, 
277 // and uninitialized_fill_n that take an allocator parameter. 
278 // We dispatch back to the standard versions when we're given the 
279 // default allocator. For nondefault allocators we do not use  
280 // any of the POD optimizations. 
281 
282 template<typename _InputIterator, typename _ForwardIterator, 
283 typename _Allocator> 
284 _ForwardIterator 
285 __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, 
286 _ForwardIterator __result, _Allocator& __alloc) 
287 { 
288 _ForwardIterator __cur = __result; 
289 __try 
290 { 
291 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; 
292 for (; __first != __last; ++__first, (void)++__cur) 
293 __traits::construct(__alloc, std::__addressof(*__cur), *__first); 
294 return __cur; 
295 } 
296 __catch(...) 
297 { 
298 std::_Destroy(__result, __cur, __alloc); 
299 __throw_exception_again; 
300 } 
301 } 
302 
303 template<typename _InputIterator, typename _ForwardIterator, typename _Tp> 
304 inline _ForwardIterator 
305 __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, 
306 _ForwardIterator __result, allocator<_Tp>&) 
307 { return std::uninitialized_copy(__first, __last, __result); } 
308 
309 template<typename _InputIterator, typename _ForwardIterator, 
310 typename _Allocator> 
311 inline _ForwardIterator 
312 __uninitialized_move_a(_InputIterator __first, _InputIterator __last, 
313 _ForwardIterator __result, _Allocator& __alloc) 
314 { 
315 return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first), 
316 _GLIBCXX_MAKE_MOVE_ITERATOR(__last), 
317 __result, __alloc); 
318 } 
319 
320 template<typename _InputIterator, typename _ForwardIterator, 
321 typename _Allocator> 
322 inline _ForwardIterator 
323 __uninitialized_move_if_noexcept_a(_InputIterator __first, 
324 _InputIterator __last, 
325 _ForwardIterator __result, 
326 _Allocator& __alloc) 
327 { 
328 return std::__uninitialized_copy_a 
329 (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first), 
330 _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc); 
331 } 
332 
333 template<typename _ForwardIterator, typename _Tp, typename _Allocator> 
334 void 
335 __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, 
336 const _Tp& __x, _Allocator& __alloc) 
337 { 
338 _ForwardIterator __cur = __first; 
339 __try 
340 { 
341 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; 
342 for (; __cur != __last; ++__cur) 
343 __traits::construct(__alloc, std::__addressof(*__cur), __x); 
344 } 
345 __catch(...) 
346 { 
347 std::_Destroy(__first, __cur, __alloc); 
348 __throw_exception_again; 
349 } 
350 } 
351 
352 template<typename _ForwardIterator, typename _Tp, typename _Tp2> 
353 inline void 
354 __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, 
355 const _Tp& __x, allocator<_Tp2>&) 
356 { std::uninitialized_fill(__first, __last, __x); } 
357 
358 template<typename _ForwardIterator, typename _Size, typename _Tp, 
359 typename _Allocator> 
360 _ForwardIterator 
361 __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,  
362 const _Tp& __x, _Allocator& __alloc) 
363 { 
364 _ForwardIterator __cur = __first; 
365 __try 
366 { 
367 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; 
368 for (; __n > 0; --__n, (void) ++__cur) 
369 __traits::construct(__alloc, std::__addressof(*__cur), __x); 
370 return __cur; 
371 } 
372 __catch(...) 
373 { 
374 std::_Destroy(__first, __cur, __alloc); 
375 __throw_exception_again; 
376 } 
377 } 
378 
379 template<typename _ForwardIterator, typename _Size, typename _Tp, 
380 typename _Tp2> 
381 inline _ForwardIterator 
382 __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,  
383 const _Tp& __x, allocator<_Tp2>&) 
384 { return std::uninitialized_fill_n(__first, __n, __x); } 
385 
386 
387 // Extensions: __uninitialized_copy_move, __uninitialized_move_copy, 
388 // __uninitialized_fill_move, __uninitialized_move_fill. 
389 // All of these algorithms take a user-supplied allocator, which is used 
390 // for construction and destruction. 
391 
392 // __uninitialized_copy_move 
393 // Copies [first1, last1) into [result, result + (last1 - first1)), and 
394 // move [first2, last2) into 
395 // [result, result + (last1 - first1) + (last2 - first2)). 
396 template<typename _InputIterator1, typename _InputIterator2, 
397 typename _ForwardIterator, typename _Allocator> 
398 inline _ForwardIterator 
399 __uninitialized_copy_move(_InputIterator1 __first1, 
400 _InputIterator1 __last1, 
401 _InputIterator2 __first2, 
402 _InputIterator2 __last2, 
403 _ForwardIterator __result, 
404 _Allocator& __alloc) 
405 { 
406 _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, 
407 __result, 
408 __alloc); 
409 __try 
410 { 
411 return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); 
412 } 
413 __catch(...) 
414 { 
415 std::_Destroy(__result, __mid, __alloc); 
416 __throw_exception_again; 
417 } 
418 } 
419 
420 // __uninitialized_move_copy 
421 // Moves [first1, last1) into [result, result + (last1 - first1)), and 
422 // copies [first2, last2) into 
423 // [result, result + (last1 - first1) + (last2 - first2)). 
424 template<typename _InputIterator1, typename _InputIterator2, 
425 typename _ForwardIterator, typename _Allocator> 
426 inline _ForwardIterator 
427 __uninitialized_move_copy(_InputIterator1 __first1, 
428 _InputIterator1 __last1, 
429 _InputIterator2 __first2, 
430 _InputIterator2 __last2, 
431 _ForwardIterator __result, 
432 _Allocator& __alloc) 
433 { 
434 _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, 
435 __result, 
436 __alloc); 
437 __try 
438 { 
439 return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); 
440 } 
441 __catch(...) 
442 { 
443 std::_Destroy(__result, __mid, __alloc); 
444 __throw_exception_again; 
445 } 
446 } 
447  
448 // __uninitialized_fill_move 
449 // Fills [result, mid) with x, and moves [first, last) into 
450 // [mid, mid + (last - first)). 
451 template<typename _ForwardIterator, typename _Tp, typename _InputIterator, 
452 typename _Allocator> 
453 inline _ForwardIterator 
454 __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, 
455 const _Tp& __x, _InputIterator __first, 
456 _InputIterator __last, _Allocator& __alloc) 
457 { 
458 std::__uninitialized_fill_a(__result, __mid, __x, __alloc); 
459 __try 
460 { 
461 return std::__uninitialized_move_a(__first, __last, __mid, __alloc); 
462 } 
463 __catch(...) 
464 { 
465 std::_Destroy(__result, __mid, __alloc); 
466 __throw_exception_again; 
467 } 
468 } 
469 
470 // __uninitialized_move_fill 
471 // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and 
472 // fills [first2 + (last1 - first1), last2) with x. 
473 template<typename _InputIterator, typename _ForwardIterator, typename _Tp, 
474 typename _Allocator> 
475 inline void 
476 __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, 
477 _ForwardIterator __first2, 
478 _ForwardIterator __last2, const _Tp& __x, 
479 _Allocator& __alloc) 
480 { 
481 _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, 
482 __first2, 
483 __alloc); 
484 __try 
485 { 
486 std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); 
487 } 
488 __catch(...) 
489 { 
490 std::_Destroy(__first2, __mid2, __alloc); 
491 __throw_exception_again; 
492 } 
493 } 
494 
495#if __cplusplus >= 201103L 
496 // Extensions: __uninitialized_default, __uninitialized_default_n, 
497 // __uninitialized_default_a, __uninitialized_default_n_a. 
498 
499 template<bool _TrivialValueType> 
500 struct __uninitialized_default_1 
501 { 
502 template<typename _ForwardIterator> 
503 static void 
504 __uninit_default(_ForwardIterator __first, _ForwardIterator __last) 
505 { 
506 _ForwardIterator __cur = __first; 
507 __try 
508 { 
509 for (; __cur != __last; ++__cur) 
510 std::_Construct(std::__addressof(*__cur)); 
511 } 
512 __catch(...) 
513 { 
514 std::_Destroy(__first, __cur); 
515 __throw_exception_again; 
516 } 
517 } 
518 }; 
519 
520 template<> 
521 struct __uninitialized_default_1<true> 
522 { 
523 template<typename _ForwardIterator> 
524 static void 
525 __uninit_default(_ForwardIterator __first, _ForwardIterator __last) 
526 { 
527 typedef typename iterator_traits<_ForwardIterator>::value_type 
528 _ValueType; 
529 
530 std::fill(__first, __last, _ValueType()); 
531 } 
532 }; 
533 
534 template<bool _TrivialValueType> 
535 struct __uninitialized_default_n_1 
536 { 
537 template<typename _ForwardIterator, typename _Size> 
538 static _ForwardIterator 
539 __uninit_default_n(_ForwardIterator __first, _Size __n) 
540 { 
541 _ForwardIterator __cur = __first; 
542 __try 
543 { 
544 for (; __n > 0; --__n, (void) ++__cur) 
545 std::_Construct(std::__addressof(*__cur)); 
546 return __cur; 
547 } 
548 __catch(...) 
549 { 
550 std::_Destroy(__first, __cur); 
551 __throw_exception_again; 
552 } 
553 } 
554 }; 
555 
556 template<> 
557 struct __uninitialized_default_n_1<true> 
558 { 
559 template<typename _ForwardIterator, typename _Size> 
560 static _ForwardIterator 
561 __uninit_default_n(_ForwardIterator __first, _Size __n) 
562 { 
563 typedef typename iterator_traits<_ForwardIterator>::value_type 
564 _ValueType; 
565 
566 return std::fill_n(__first, __n, _ValueType()); 
567 } 
568 }; 
569 
570 // __uninitialized_default 
571 // Fills [first, last) with std::distance(first, last) default 
572 // constructed value_types(s). 
573 template<typename _ForwardIterator> 
574 inline void 
575 __uninitialized_default(_ForwardIterator __first, 
576 _ForwardIterator __last) 
577 { 
578 typedef typename iterator_traits<_ForwardIterator>::value_type 
579 _ValueType; 
580 // trivial types can have deleted assignment 
581 const bool __assignable = is_copy_assignable<_ValueType>::value; 
582 
583 std::__uninitialized_default_1<__is_trivial(_ValueType) 
584 && __assignable>:: 
585 __uninit_default(__first, __last); 
586 } 
587 
588 // __uninitialized_default_n 
589 // Fills [first, first + n) with n default constructed value_type(s). 
590 template<typename _ForwardIterator, typename _Size> 
591 inline _ForwardIterator 
592 __uninitialized_default_n(_ForwardIterator __first, _Size __n) 
593 { 
594 typedef typename iterator_traits<_ForwardIterator>::value_type 
595 _ValueType; 
596 // trivial types can have deleted assignment 
597 const bool __assignable = is_copy_assignable<_ValueType>::value; 
598 
599 return __uninitialized_default_n_1<__is_trivial(_ValueType) 
600 && __assignable>:: 
601 __uninit_default_n(__first, __n); 
602 } 
603 
604 
605 // __uninitialized_default_a 
606 // Fills [first, last) with std::distance(first, last) default 
607 // constructed value_types(s), constructed with the allocator alloc. 
608 template<typename _ForwardIterator, typename _Allocator> 
609 void 
610 __uninitialized_default_a(_ForwardIterator __first, 
611 _ForwardIterator __last, 
612 _Allocator& __alloc) 
613 { 
614 _ForwardIterator __cur = __first; 
615 __try 
616 { 
617 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; 
618 for (; __cur != __last; ++__cur) 
619 __traits::construct(__alloc, std::__addressof(*__cur)); 
620 } 
621 __catch(...) 
622 { 
623 std::_Destroy(__first, __cur, __alloc); 
624 __throw_exception_again; 
625 } 
626 } 
627 
628 template<typename _ForwardIterator, typename _Tp> 
629 inline void 
630 __uninitialized_default_a(_ForwardIterator __first, 
631 _ForwardIterator __last, 
632 allocator<_Tp>&) 
633 { std::__uninitialized_default(__first, __last); } 
634 
635 
636 // __uninitialized_default_n_a 
637 // Fills [first, first + n) with n default constructed value_types(s), 
638 // constructed with the allocator alloc. 
639 template<typename _ForwardIterator, typename _Size, typename _Allocator> 
640 _ForwardIterator 
641 __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,  
642 _Allocator& __alloc) 
643 { 
644 _ForwardIterator __cur = __first; 
645 __try 
646 { 
647 typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; 
648 for (; __n > 0; --__n, (void) ++__cur) 
649 __traits::construct(__alloc, std::__addressof(*__cur)); 
650 return __cur; 
651 } 
652 __catch(...) 
653 { 
654 std::_Destroy(__first, __cur, __alloc); 
655 __throw_exception_again; 
656 } 
657 } 
658 
659 template<typename _ForwardIterator, typename _Size, typename _Tp> 
660 inline _ForwardIterator 
661 __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,  
662 allocator<_Tp>&) 
663 { return std::__uninitialized_default_n(__first, __n); } 
664 
665 template<bool _TrivialValueType> 
666 struct __uninitialized_default_novalue_1 
667 { 
668 template<typename _ForwardIterator> 
669 static void 
670 __uninit_default_novalue(_ForwardIterator __first, 
671 _ForwardIterator __last) 
672 { 
673 _ForwardIterator __cur = __first; 
674 __try 
675 { 
676 for (; __cur != __last; ++__cur) 
677 std::_Construct_novalue(std::__addressof(*__cur)); 
678 } 
679 __catch(...) 
680 { 
681 std::_Destroy(__first, __cur); 
682 __throw_exception_again; 
683 } 
684 } 
685 }; 
686 
687 template<> 
688 struct __uninitialized_default_novalue_1<true> 
689 { 
690 template<typename _ForwardIterator> 
691 static void 
692 __uninit_default_novalue(_ForwardIterator __first, 
693 _ForwardIterator __last) 
694 { 
695 } 
696 }; 
697 
698 template<bool _TrivialValueType> 
699 struct __uninitialized_default_novalue_n_1 
700 { 
701 template<typename _ForwardIterator, typename _Size> 
702 static _ForwardIterator 
703 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) 
704 { 
705 _ForwardIterator __cur = __first; 
706 __try 
707 { 
708 for (; __n > 0; --__n, (void) ++__cur) 
709 std::_Construct_novalue(std::__addressof(*__cur)); 
710 return __cur; 
711 } 
712 __catch(...) 
713 { 
714 std::_Destroy(__first, __cur); 
715 __throw_exception_again; 
716 } 
717 } 
718 }; 
719 
720 template<> 
721 struct __uninitialized_default_novalue_n_1<true> 
722 { 
723 template<typename _ForwardIterator, typename _Size> 
724 static _ForwardIterator 
725 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) 
726 { return std::next(__first, __n); } 
727 }; 
728 
729 // __uninitialized_default_novalue 
730 // Fills [first, last) with std::distance(first, last) default-initialized 
731 // value_types(s). 
732 template<typename _ForwardIterator> 
733 inline void 
734 __uninitialized_default_novalue(_ForwardIterator __first, 
735 _ForwardIterator __last) 
736 { 
737 typedef typename iterator_traits<_ForwardIterator>::value_type 
738 _ValueType; 
739 
740 std::__uninitialized_default_novalue_1< 
741 is_trivially_default_constructible<_ValueType>::value>:: 
742 __uninit_default_novalue(__first, __last); 
743 } 
744 
745 // __uninitialized_default_n 
746 // Fills [first, first + n) with n default-initialized value_type(s). 
747 template<typename _ForwardIterator, typename _Size> 
748 inline _ForwardIterator 
749 __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) 
750 { 
751 typedef typename iterator_traits<_ForwardIterator>::value_type 
752 _ValueType; 
753 
754 return __uninitialized_default_novalue_n_1< 
755 is_trivially_default_constructible<_ValueType>::value>:: 
756 __uninit_default_novalue_n(__first, __n); 
757 } 
758 
759 template<typename _InputIterator, typename _Size, 
760 typename _ForwardIterator> 
761 _ForwardIterator 
762 __uninitialized_copy_n(_InputIterator __first, _Size __n, 
763 _ForwardIterator __result, input_iterator_tag) 
764 { 
765 _ForwardIterator __cur = __result; 
766 __try 
767 { 
768 for (; __n > 0; --__n, (void) ++__first, ++__cur) 
769 std::_Construct(std::__addressof(*__cur), *__first); 
770 return __cur; 
771 } 
772 __catch(...) 
773 { 
774 std::_Destroy(__result, __cur); 
775 __throw_exception_again; 
776 } 
777 } 
778 
779 template<typename _RandomAccessIterator, typename _Size, 
780 typename _ForwardIterator> 
781 inline _ForwardIterator 
782 __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, 
783 _ForwardIterator __result, 
784 random_access_iterator_tag) 
785 { return std::uninitialized_copy(__first, __first + __n, __result); } 
786 
787 template<typename _InputIterator, typename _Size, 
788 typename _ForwardIterator> 
789 pair<_InputIterator, _ForwardIterator> 
790 __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, 
791 _ForwardIterator __result, input_iterator_tag) 
792 { 
793 _ForwardIterator __cur = __result; 
794 __try 
795 { 
796 for (; __n > 0; --__n, (void) ++__first, ++__cur) 
797 std::_Construct(std::__addressof(*__cur), *__first); 
798 return {__first, __cur}; 
799 } 
800 __catch(...) 
801 { 
802 std::_Destroy(__result, __cur); 
803 __throw_exception_again; 
804 } 
805 } 
806 
807 template<typename _RandomAccessIterator, typename _Size, 
808 typename _ForwardIterator> 
809 inline pair<_RandomAccessIterator, _ForwardIterator> 
810 __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, 
811 _ForwardIterator __result, 
812 random_access_iterator_tag) 
813 { 
814 auto __second_res = uninitialized_copy(__first, __first + __n, __result); 
815 auto __first_res = std::next(__first, __n); 
816 return {__first_res, __second_res}; 
817 } 
818 
819 /** 
820 * @brief Copies the range [first,first+n) into result. 
821 * @param __first An input iterator. 
822 * @param __n The number of elements to copy. 
823 * @param __result An output iterator. 
824 * @return __result + __n 
825 * 
826 * Like copy_n(), but does not require an initialized output range. 
827 */ 
828 template<typename _InputIterator, typename _Size, typename _ForwardIterator> 
829 inline _ForwardIterator 
830 uninitialized_copy_n(_InputIterator __first, _Size __n, 
831 _ForwardIterator __result) 
832 { return std::__uninitialized_copy_n(__first, __n, __result, 
833 std::__iterator_category(__first)); } 
834 
835 template<typename _InputIterator, typename _Size, typename _ForwardIterator> 
836 inline pair<_InputIterator, _ForwardIterator> 
837 __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, 
838 _ForwardIterator __result) 
839 { 
840 return 
841 std::__uninitialized_copy_n_pair(__first, __n, __result, 
842 std::__iterator_category(__first)); 
843 } 
844 
845#endif 
846 
847#if __cplusplus >= 201703L 
848# define __cpp_lib_raw_memory_algorithms 201606L 
849 
850 template <typename _ForwardIterator> 
851 inline void 
852 uninitialized_default_construct(_ForwardIterator __first, 
853 _ForwardIterator __last) 
854 { 
855 __uninitialized_default_novalue(__first, __last); 
856 } 
857 
858 template <typename _ForwardIterator, typename _Size> 
859 inline _ForwardIterator 
860 uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) 
861 { 
862 return __uninitialized_default_novalue_n(__first, __count); 
863 } 
864 
865 template <typename _ForwardIterator> 
866 inline void 
867 uninitialized_value_construct(_ForwardIterator __first, 
868 _ForwardIterator __last) 
869 { 
870 return __uninitialized_default(__first, __last); 
871 } 
872 
873 template <typename _ForwardIterator, typename _Size> 
874 inline _ForwardIterator 
875 uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) 
876 { 
877 return __uninitialized_default_n(__first, __count); 
878 } 
879 
880 template <typename _InputIterator, typename _ForwardIterator> 
881 inline _ForwardIterator 
882 uninitialized_move(_InputIterator __first, _InputIterator __last, 
883 _ForwardIterator __result) 
884 { 
885 return std::uninitialized_copy 
886 (_GLIBCXX_MAKE_MOVE_ITERATOR(__first), 
887 _GLIBCXX_MAKE_MOVE_ITERATOR(__last), __result); 
888 } 
889 
890 template <typename _InputIterator, typename _Size, typename _ForwardIterator> 
891 inline pair<_InputIterator, _ForwardIterator> 
892 uninitialized_move_n(_InputIterator __first, _Size __count, 
893 _ForwardIterator __result) 
894 { 
895 auto __res = std::__uninitialized_copy_n_pair 
896 (_GLIBCXX_MAKE_MOVE_ITERATOR(__first), 
897 __count, __result); 
898 return {__res.first.base(), __res.second}; 
899 } 
900#endif // C++17 
901 
902#if __cplusplus >= 201103L 
903 template<typename _Tp, typename _Up, typename _Allocator> 
904 inline void 
905 __relocate_object_a(_Tp* __dest, _Up* __orig, _Allocator& __alloc) 
906 noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, 
907 __dest, std::move(*__orig))) 
908 && noexcept(std::allocator_traits<_Allocator>::destroy( 
909 __alloc, std::__addressof(*__orig)))) 
910 { 
911 typedef std::allocator_traits<_Allocator> __traits; 
912 __traits::construct(__alloc, __dest, std::move(*__orig)); 
913 __traits::destroy(__alloc, std::__addressof(*__orig)); 
914 } 
915 
916 // This class may be specialized for specific types. 
917 // Also known as is_trivially_relocatable. 
918 template<typename _Tp, typename = void> 
919 struct __is_bitwise_relocatable 
920 : is_trivial<_Tp> { }; 
921 
922 template <typename _Tp, typename _Up> 
923 inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*> 
924 __relocate_a_1(_Tp* __first, _Tp* __last, 
925 _Tp* __result, allocator<_Up>&) noexcept 
926 { 
927 ptrdiff_t __count = __last - __first; 
928 if (__count > 0) 
929 __builtin_memmove(__result, __first, __count * sizeof(_Tp)); 
930 return __result + __count; 
931 } 
932 
933 template <typename _InputIterator, typename _ForwardIterator, 
934 typename _Allocator> 
935 inline _ForwardIterator 
936 __relocate_a_1(_InputIterator __first, _InputIterator __last, 
937 _ForwardIterator __result, _Allocator& __alloc) 
938 noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), 
939 std::addressof(*__first), 
940 __alloc))) 
941 { 
942 typedef typename iterator_traits<_InputIterator>::value_type 
943 _ValueType; 
944 typedef typename iterator_traits<_ForwardIterator>::value_type 
945 _ValueType2; 
946 static_assert(std::is_same<_ValueType, _ValueType2>::value, 
947 "relocation is only possible for values of the same type"); 
948 _ForwardIterator __cur = __result; 
949 for (; __first != __last; ++__first, (void)++__cur) 
950 std::__relocate_object_a(std::__addressof(*__cur), 
951 std::__addressof(*__first), __alloc); 
952 return __cur; 
953 } 
954 
955 template <typename _InputIterator, typename _ForwardIterator, 
956 typename _Allocator> 
957 inline _ForwardIterator 
958 __relocate_a(_InputIterator __first, _InputIterator __last, 
959 _ForwardIterator __result, _Allocator& __alloc) 
960 noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), 
961 std::__niter_base(__last), 
962 std::__niter_base(__result), __alloc))) 
963 { 
964 return __relocate_a_1(std::__niter_base(__first), 
965 std::__niter_base(__last), 
966 std::__niter_base(__result), __alloc); 
967 } 
968#endif 
969 
970_GLIBCXX_END_NAMESPACE_VERSION 
971} // namespace 
972 
973#endif /* _STL_UNINITIALIZED_H */ 
974