contrib/gcc-8.0/libstdc++-v3/include/bits/stl_uninitialized.h

   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
  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 */