libstdc++

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