Line data Source code
1 : // Raw memory manipulators -*- C++ -*-
2 :
3 : // Copyright (C) 2001-2016 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 : namespace std _GLIBCXX_VISIBILITY(default)
60 : {
61 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
62 :
63 : template<bool _TrivialValueTypes>
64 : struct __uninitialized_copy
65 : {
66 : template<typename _InputIterator, typename _ForwardIterator>
67 : static _ForwardIterator
68 1586 : __uninit_copy(_InputIterator __first, _InputIterator __last,
69 : _ForwardIterator __result)
70 : {
71 1586 : _ForwardIterator __cur = __result;
72 : __try
73 : {
74 20300 : for (; __first != __last; ++__first, (void)++__cur)
75 9357 : std::_Construct(std::__addressof(*__cur), *__first);
76 1586 : return __cur;
77 : }
78 0 : __catch(...)
79 : {
80 0 : std::_Destroy(__result, __cur);
81 0 : __throw_exception_again;
82 : }
83 : }
84 : };
85 :
86 : template<>
87 : struct __uninitialized_copy<true>
88 : {
89 : template<typename _InputIterator, typename _ForwardIterator>
90 : static _ForwardIterator
91 2232 : __uninit_copy(_InputIterator __first, _InputIterator __last,
92 : _ForwardIterator __result)
93 2232 : { return std::copy(__first, __last, __result); }
94 : };
95 :
96 : /**
97 : * @brief Copies the range [first,last) into result.
98 : * @param __first An input iterator.
99 : * @param __last An input iterator.
100 : * @param __result An output iterator.
101 : * @return __result + (__first - __last)
102 : *
103 : * Like copy(), but does not require an initialized output range.
104 : */
105 : template<typename _InputIterator, typename _ForwardIterator>
106 : inline _ForwardIterator
107 3818 : uninitialized_copy(_InputIterator __first, _InputIterator __last,
108 : _ForwardIterator __result)
109 : {
110 : typedef typename iterator_traits<_InputIterator>::value_type
111 : _ValueType1;
112 : typedef typename iterator_traits<_ForwardIterator>::value_type
113 : _ValueType2;
114 : #if __cplusplus < 201103L
115 : const bool __assignable = true;
116 : #else
117 : // trivial types can have deleted assignment
118 : typedef typename iterator_traits<_InputIterator>::reference _RefType1;
119 : typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
120 3818 : const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
121 : #endif
122 :
123 : return std::__uninitialized_copy<__is_trivial(_ValueType1)
124 : && __is_trivial(_ValueType2)
125 : && __assignable>::
126 3818 : __uninit_copy(__first, __last, __result);
127 : }
128 :
129 :
130 : template<bool _TrivialValueType>
131 : struct __uninitialized_fill
132 : {
133 : template<typename _ForwardIterator, typename _Tp>
134 : static void
135 : __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
136 : const _Tp& __x)
137 : {
138 : _ForwardIterator __cur = __first;
139 : __try
140 : {
141 : for (; __cur != __last; ++__cur)
142 : std::_Construct(std::__addressof(*__cur), __x);
143 : }
144 : __catch(...)
145 : {
146 : std::_Destroy(__first, __cur);
147 : __throw_exception_again;
148 : }
149 : }
150 : };
151 :
152 : template<>
153 : struct __uninitialized_fill<true>
154 : {
155 : template<typename _ForwardIterator, typename _Tp>
156 : static void
157 : __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
158 : const _Tp& __x)
159 : { std::fill(__first, __last, __x); }
160 : };
161 :
162 : /**
163 : * @brief Copies the value x into the range [first,last).
164 : * @param __first An input iterator.
165 : * @param __last An input iterator.
166 : * @param __x The source value.
167 : * @return Nothing.
168 : *
169 : * Like fill(), but does not require an initialized output range.
170 : */
171 : template<typename _ForwardIterator, typename _Tp>
172 : inline void
173 : uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
174 : const _Tp& __x)
175 : {
176 : typedef typename iterator_traits<_ForwardIterator>::value_type
177 : _ValueType;
178 : #if __cplusplus < 201103L
179 : const bool __assignable = true;
180 : #else
181 : // trivial types can have deleted assignment
182 : const bool __assignable = is_copy_assignable<_ValueType>::value;
183 : #endif
184 :
185 : std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
186 : __uninit_fill(__first, __last, __x);
187 : }
188 :
189 :
190 : template<bool _TrivialValueType>
191 : struct __uninitialized_fill_n
192 : {
193 : template<typename _ForwardIterator, typename _Size, typename _Tp>
194 : static _ForwardIterator
195 : __uninit_fill_n(_ForwardIterator __first, _Size __n,
196 : const _Tp& __x)
197 : {
198 : _ForwardIterator __cur = __first;
199 : __try
200 : {
201 : for (; __n > 0; --__n, ++__cur)
202 : std::_Construct(std::__addressof(*__cur), __x);
203 : return __cur;
204 : }
205 : __catch(...)
206 : {
207 : std::_Destroy(__first, __cur);
208 : __throw_exception_again;
209 : }
210 : }
211 : };
212 :
213 : template<>
214 : struct __uninitialized_fill_n<true>
215 : {
216 : template<typename _ForwardIterator, typename _Size, typename _Tp>
217 : static _ForwardIterator
218 : __uninit_fill_n(_ForwardIterator __first, _Size __n,
219 : const _Tp& __x)
220 : { return std::fill_n(__first, __n, __x); }
221 : };
222 :
223 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
224 : // DR 1339. uninitialized_fill_n should return the end of its range
225 : /**
226 : * @brief Copies the value x into the range [first,first+n).
227 : * @param __first An input iterator.
228 : * @param __n The number of copies to make.
229 : * @param __x The source value.
230 : * @return Nothing.
231 : *
232 : * Like fill_n(), but does not require an initialized output range.
233 : */
234 : template<typename _ForwardIterator, typename _Size, typename _Tp>
235 : inline _ForwardIterator
236 : uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
237 : {
238 : typedef typename iterator_traits<_ForwardIterator>::value_type
239 : _ValueType;
240 : #if __cplusplus < 201103L
241 : const bool __assignable = true;
242 : #else
243 : // trivial types can have deleted assignment
244 : const bool __assignable = is_copy_assignable<_ValueType>::value;
245 : #endif
246 : return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
247 : __uninit_fill_n(__first, __n, __x);
248 : }
249 :
250 : // Extensions: versions of uninitialized_copy, uninitialized_fill,
251 : // and uninitialized_fill_n that take an allocator parameter.
252 : // We dispatch back to the standard versions when we're given the
253 : // default allocator. For nondefault allocators we do not use
254 : // any of the POD optimizations.
255 :
256 : template<typename _InputIterator, typename _ForwardIterator,
257 : typename _Allocator>
258 : _ForwardIterator
259 : __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
260 : _ForwardIterator __result, _Allocator& __alloc)
261 : {
262 : _ForwardIterator __cur = __result;
263 : __try
264 : {
265 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
266 : for (; __first != __last; ++__first, (void)++__cur)
267 : __traits::construct(__alloc, std::__addressof(*__cur), *__first);
268 : return __cur;
269 : }
270 : __catch(...)
271 : {
272 : std::_Destroy(__result, __cur, __alloc);
273 : __throw_exception_again;
274 : }
275 : }
276 :
277 : template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
278 : inline _ForwardIterator
279 3818 : __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
280 : _ForwardIterator __result, allocator<_Tp>&)
281 3818 : { return std::uninitialized_copy(__first, __last, __result); }
282 :
283 : template<typename _InputIterator, typename _ForwardIterator,
284 : typename _Allocator>
285 : inline _ForwardIterator
286 : __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
287 : _ForwardIterator __result, _Allocator& __alloc)
288 : {
289 : return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
290 : _GLIBCXX_MAKE_MOVE_ITERATOR(__last),
291 : __result, __alloc);
292 : }
293 :
294 : template<typename _InputIterator, typename _ForwardIterator,
295 : typename _Allocator>
296 : inline _ForwardIterator
297 3590 : __uninitialized_move_if_noexcept_a(_InputIterator __first,
298 : _InputIterator __last,
299 : _ForwardIterator __result,
300 : _Allocator& __alloc)
301 : {
302 : return std::__uninitialized_copy_a
303 3590 : (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
304 3590 : _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
305 : }
306 :
307 : template<typename _ForwardIterator, typename _Tp, typename _Allocator>
308 : void
309 : __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
310 : const _Tp& __x, _Allocator& __alloc)
311 : {
312 : _ForwardIterator __cur = __first;
313 : __try
314 : {
315 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
316 : for (; __cur != __last; ++__cur)
317 : __traits::construct(__alloc, std::__addressof(*__cur), __x);
318 : }
319 : __catch(...)
320 : {
321 : std::_Destroy(__first, __cur, __alloc);
322 : __throw_exception_again;
323 : }
324 : }
325 :
326 : template<typename _ForwardIterator, typename _Tp, typename _Tp2>
327 : inline void
328 : __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
329 : const _Tp& __x, allocator<_Tp2>&)
330 : { std::uninitialized_fill(__first, __last, __x); }
331 :
332 : template<typename _ForwardIterator, typename _Size, typename _Tp,
333 : typename _Allocator>
334 : _ForwardIterator
335 : __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
336 : const _Tp& __x, _Allocator& __alloc)
337 : {
338 : _ForwardIterator __cur = __first;
339 : __try
340 : {
341 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
342 : for (; __n > 0; --__n, ++__cur)
343 : __traits::construct(__alloc, std::__addressof(*__cur), __x);
344 : return __cur;
345 : }
346 : __catch(...)
347 : {
348 : std::_Destroy(__first, __cur, __alloc);
349 : __throw_exception_again;
350 : }
351 : }
352 :
353 : template<typename _ForwardIterator, typename _Size, typename _Tp,
354 : typename _Tp2>
355 : inline _ForwardIterator
356 : __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
357 : const _Tp& __x, allocator<_Tp2>&)
358 : { return std::uninitialized_fill_n(__first, __n, __x); }
359 :
360 :
361 : // Extensions: __uninitialized_copy_move, __uninitialized_move_copy,
362 : // __uninitialized_fill_move, __uninitialized_move_fill.
363 : // All of these algorithms take a user-supplied allocator, which is used
364 : // for construction and destruction.
365 :
366 : // __uninitialized_copy_move
367 : // Copies [first1, last1) into [result, result + (last1 - first1)), and
368 : // move [first2, last2) into
369 : // [result, result + (last1 - first1) + (last2 - first2)).
370 : template<typename _InputIterator1, typename _InputIterator2,
371 : typename _ForwardIterator, typename _Allocator>
372 : inline _ForwardIterator
373 : __uninitialized_copy_move(_InputIterator1 __first1,
374 : _InputIterator1 __last1,
375 : _InputIterator2 __first2,
376 : _InputIterator2 __last2,
377 : _ForwardIterator __result,
378 : _Allocator& __alloc)
379 : {
380 : _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
381 : __result,
382 : __alloc);
383 : __try
384 : {
385 : return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
386 : }
387 : __catch(...)
388 : {
389 : std::_Destroy(__result, __mid, __alloc);
390 : __throw_exception_again;
391 : }
392 : }
393 :
394 : // __uninitialized_move_copy
395 : // Moves [first1, last1) into [result, result + (last1 - first1)), and
396 : // copies [first2, last2) into
397 : // [result, result + (last1 - first1) + (last2 - first2)).
398 : template<typename _InputIterator1, typename _InputIterator2,
399 : typename _ForwardIterator, typename _Allocator>
400 : inline _ForwardIterator
401 : __uninitialized_move_copy(_InputIterator1 __first1,
402 : _InputIterator1 __last1,
403 : _InputIterator2 __first2,
404 : _InputIterator2 __last2,
405 : _ForwardIterator __result,
406 : _Allocator& __alloc)
407 : {
408 : _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
409 : __result,
410 : __alloc);
411 : __try
412 : {
413 : return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
414 : }
415 : __catch(...)
416 : {
417 : std::_Destroy(__result, __mid, __alloc);
418 : __throw_exception_again;
419 : }
420 : }
421 :
422 : // __uninitialized_fill_move
423 : // Fills [result, mid) with x, and moves [first, last) into
424 : // [mid, mid + (last - first)).
425 : template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
426 : typename _Allocator>
427 : inline _ForwardIterator
428 : __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
429 : const _Tp& __x, _InputIterator __first,
430 : _InputIterator __last, _Allocator& __alloc)
431 : {
432 : std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
433 : __try
434 : {
435 : return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
436 : }
437 : __catch(...)
438 : {
439 : std::_Destroy(__result, __mid, __alloc);
440 : __throw_exception_again;
441 : }
442 : }
443 :
444 : // __uninitialized_move_fill
445 : // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and
446 : // fills [first2 + (last1 - first1), last2) with x.
447 : template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
448 : typename _Allocator>
449 : inline void
450 : __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
451 : _ForwardIterator __first2,
452 : _ForwardIterator __last2, const _Tp& __x,
453 : _Allocator& __alloc)
454 : {
455 : _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
456 : __first2,
457 : __alloc);
458 : __try
459 : {
460 : std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
461 : }
462 : __catch(...)
463 : {
464 : std::_Destroy(__first2, __mid2, __alloc);
465 : __throw_exception_again;
466 : }
467 : }
468 :
469 : #if __cplusplus >= 201103L
470 : // Extensions: __uninitialized_default, __uninitialized_default_n,
471 : // __uninitialized_default_a, __uninitialized_default_n_a.
472 :
473 : template<bool _TrivialValueType>
474 : struct __uninitialized_default_1
475 : {
476 : template<typename _ForwardIterator>
477 : static void
478 : __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
479 : {
480 : _ForwardIterator __cur = __first;
481 : __try
482 : {
483 : for (; __cur != __last; ++__cur)
484 : std::_Construct(std::__addressof(*__cur));
485 : }
486 : __catch(...)
487 : {
488 : std::_Destroy(__first, __cur);
489 : __throw_exception_again;
490 : }
491 : }
492 : };
493 :
494 : template<>
495 : struct __uninitialized_default_1<true>
496 : {
497 : template<typename _ForwardIterator>
498 : static void
499 : __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
500 : {
501 : typedef typename iterator_traits<_ForwardIterator>::value_type
502 : _ValueType;
503 :
504 : std::fill(__first, __last, _ValueType());
505 : }
506 : };
507 :
508 : template<bool _TrivialValueType>
509 : struct __uninitialized_default_n_1
510 : {
511 : template<typename _ForwardIterator, typename _Size>
512 : static _ForwardIterator
513 126 : __uninit_default_n(_ForwardIterator __first, _Size __n)
514 : {
515 126 : _ForwardIterator __cur = __first;
516 : __try
517 : {
518 378 : for (; __n > 0; --__n, ++__cur)
519 126 : std::_Construct(std::__addressof(*__cur));
520 126 : return __cur;
521 : }
522 : __catch(...)
523 : {
524 : std::_Destroy(__first, __cur);
525 : __throw_exception_again;
526 : }
527 : }
528 : };
529 :
530 : template<>
531 : struct __uninitialized_default_n_1<true>
532 : {
533 : template<typename _ForwardIterator, typename _Size>
534 : static _ForwardIterator
535 : __uninit_default_n(_ForwardIterator __first, _Size __n)
536 : {
537 : typedef typename iterator_traits<_ForwardIterator>::value_type
538 : _ValueType;
539 :
540 : return std::fill_n(__first, __n, _ValueType());
541 : }
542 : };
543 :
544 : // __uninitialized_default
545 : // Fills [first, last) with std::distance(first, last) default
546 : // constructed value_types(s).
547 : template<typename _ForwardIterator>
548 : inline void
549 : __uninitialized_default(_ForwardIterator __first,
550 : _ForwardIterator __last)
551 : {
552 : typedef typename iterator_traits<_ForwardIterator>::value_type
553 : _ValueType;
554 : // trivial types can have deleted assignment
555 : const bool __assignable = is_copy_assignable<_ValueType>::value;
556 :
557 : std::__uninitialized_default_1<__is_trivial(_ValueType)
558 : && __assignable>::
559 : __uninit_default(__first, __last);
560 : }
561 :
562 : // __uninitialized_default_n
563 : // Fills [first, first + n) with n default constructed value_type(s).
564 : template<typename _ForwardIterator, typename _Size>
565 : inline _ForwardIterator
566 126 : __uninitialized_default_n(_ForwardIterator __first, _Size __n)
567 : {
568 : typedef typename iterator_traits<_ForwardIterator>::value_type
569 : _ValueType;
570 : // trivial types can have deleted assignment
571 126 : const bool __assignable = is_copy_assignable<_ValueType>::value;
572 :
573 : return __uninitialized_default_n_1<__is_trivial(_ValueType)
574 : && __assignable>::
575 126 : __uninit_default_n(__first, __n);
576 : }
577 :
578 :
579 : // __uninitialized_default_a
580 : // Fills [first, last) with std::distance(first, last) default
581 : // constructed value_types(s), constructed with the allocator alloc.
582 : template<typename _ForwardIterator, typename _Allocator>
583 : void
584 : __uninitialized_default_a(_ForwardIterator __first,
585 : _ForwardIterator __last,
586 : _Allocator& __alloc)
587 : {
588 : _ForwardIterator __cur = __first;
589 : __try
590 : {
591 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
592 : for (; __cur != __last; ++__cur)
593 : __traits::construct(__alloc, std::__addressof(*__cur));
594 : }
595 : __catch(...)
596 : {
597 : std::_Destroy(__first, __cur, __alloc);
598 : __throw_exception_again;
599 : }
600 : }
601 :
602 : template<typename _ForwardIterator, typename _Tp>
603 : inline void
604 : __uninitialized_default_a(_ForwardIterator __first,
605 : _ForwardIterator __last,
606 : allocator<_Tp>&)
607 : { std::__uninitialized_default(__first, __last); }
608 :
609 :
610 : // __uninitialized_default_n_a
611 : // Fills [first, first + n) with n default constructed value_types(s),
612 : // constructed with the allocator alloc.
613 : template<typename _ForwardIterator, typename _Size, typename _Allocator>
614 : _ForwardIterator
615 : __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
616 : _Allocator& __alloc)
617 : {
618 : _ForwardIterator __cur = __first;
619 : __try
620 : {
621 : typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
622 : for (; __n > 0; --__n, ++__cur)
623 : __traits::construct(__alloc, std::__addressof(*__cur));
624 : return __cur;
625 : }
626 : __catch(...)
627 : {
628 : std::_Destroy(__first, __cur, __alloc);
629 : __throw_exception_again;
630 : }
631 : }
632 :
633 : template<typename _ForwardIterator, typename _Size, typename _Tp>
634 : inline _ForwardIterator
635 126 : __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
636 : allocator<_Tp>&)
637 126 : { return std::__uninitialized_default_n(__first, __n); }
638 :
639 :
640 : template<typename _InputIterator, typename _Size,
641 : typename _ForwardIterator>
642 : _ForwardIterator
643 : __uninitialized_copy_n(_InputIterator __first, _Size __n,
644 : _ForwardIterator __result, input_iterator_tag)
645 : {
646 : _ForwardIterator __cur = __result;
647 : __try
648 : {
649 : for (; __n > 0; --__n, ++__first, ++__cur)
650 : std::_Construct(std::__addressof(*__cur), *__first);
651 : return __cur;
652 : }
653 : __catch(...)
654 : {
655 : std::_Destroy(__result, __cur);
656 : __throw_exception_again;
657 : }
658 : }
659 :
660 : template<typename _RandomAccessIterator, typename _Size,
661 : typename _ForwardIterator>
662 : inline _ForwardIterator
663 : __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
664 : _ForwardIterator __result,
665 : random_access_iterator_tag)
666 : { return std::uninitialized_copy(__first, __first + __n, __result); }
667 :
668 : /**
669 : * @brief Copies the range [first,first+n) into result.
670 : * @param __first An input iterator.
671 : * @param __n The number of elements to copy.
672 : * @param __result An output iterator.
673 : * @return __result + __n
674 : *
675 : * Like copy_n(), but does not require an initialized output range.
676 : */
677 : template<typename _InputIterator, typename _Size, typename _ForwardIterator>
678 : inline _ForwardIterator
679 : uninitialized_copy_n(_InputIterator __first, _Size __n,
680 : _ForwardIterator __result)
681 : { return std::__uninitialized_copy_n(__first, __n, __result,
682 : std::__iterator_category(__first)); }
683 : #endif
684 :
685 : _GLIBCXX_END_NAMESPACE_VERSION
686 : } // namespace
687 :
688 : #endif /* _STL_UNINITIALIZED_H */
|
