libstdc++-v3/include/bits/unique_ptr.h

   1
   2 // unique_ptr implementation -*- C++ -*-
   3
   4 // Copyright (C) 2008-2024 Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file bits/unique_ptr.h
  27  *  This is an internal header file, included by other library headers.
  28  *  Do not attempt to use it directly. @headername{memory}
  29  */
  30
  31 #ifndef _UNIQUE_PTR_H
  32 #define _UNIQUE_PTR_H 1
  33
  34 #include <bits/c++config.h>
  35 #include <debug/assertions.h>
  36 #include <type_traits>
  37 #include <tuple>
  38 #include <bits/stl_function.h>
  39 #include <bits/functional_hash.h>
  40 #if __cplusplus >= 202002L
  41 # include <compare>
  42 # if _GLIBCXX_HOSTED
  43 #  include <ostream>
  44 # endif
  45 #endif
  46
  47 namespace std _GLIBCXX_VISIBILITY(default)
  48 {
  49 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  50
  51   /**
  52    * @addtogroup pointer_abstractions
  53    * @{
  54    */
  55
  56 #if _GLIBCXX_USE_DEPRECATED
  57 #pragma GCC diagnostic push
  58 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  59   template<typename> class auto_ptr;
  60 #pragma GCC diagnostic pop
  61 #endif
  62
  63   /** Primary template of default_delete, used by unique_ptr for single objects
  64    *
  65    * @headerfile memory
  66    * @since C++11
  67    */
  68   template<typename _Tp>
  69     struct default_delete
  70     {
  71       /// Default constructor
  72       constexpr default_delete() noexcept = default;
  73
  74       /** @brief Converting constructor.
  75        *
  76        * Allows conversion from a deleter for objects of another type, `_Up`,
  77        * only if `_Up*` is convertible to `_Tp*`.
  78        */
  79       template<typename _Up,
  80                typename = _Require<is_convertible<_Up*, _Tp*>>>
  81         _GLIBCXX23_CONSTEXPR
  82         default_delete(const default_delete<_Up>&) noexcept { }
  83
  84       /// Calls `delete __ptr`
  85       _GLIBCXX23_CONSTEXPR
  86       void
  87       operator()(_Tp* __ptr) const
  88       {
  89         static_assert(!is_void<_Tp>::value,
  90                       "can't delete pointer to incomplete type");
  91         static_assert(sizeof(_Tp)>0,
  92                       "can't delete pointer to incomplete type");
  93         delete __ptr;
  94       }
  95     };
  96
  97   // _GLIBCXX_RESOLVE_LIB_DEFECTS
  98   // DR 740 - omit specialization for array objects with a compile time length
  99
 100   /** Specialization of default_delete for arrays, used by `unique_ptr<T[]>`
 101    *
 102    * @headerfile memory
 103    * @since C++11
 104    */
 105   template<typename _Tp>
 106     struct default_delete<_Tp[]>
 107     {
 108     public:
 109       /// Default constructor
 110       constexpr default_delete() noexcept = default;
 111
 112       /** @brief Converting constructor.
 113        *
 114        * Allows conversion from a deleter for arrays of another type, such as
 115        * a const-qualified version of `_Tp`.
 116        *
 117        * Conversions from types derived from `_Tp` are not allowed because
 118        * it is undefined to `delete[]` an array of derived types through a
 119        * pointer to the base type.
 120        */
 121       template<typename _Up,
 122                typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
 123         _GLIBCXX23_CONSTEXPR
 124         default_delete(const default_delete<_Up[]>&) noexcept { }
 125
 126       /// Calls `delete[] __ptr`
 127       template<typename _Up>
 128         _GLIBCXX23_CONSTEXPR
 129         typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
 130         operator()(_Up* __ptr) const
 131         {
 132           static_assert(sizeof(_Tp)>0,
 133                         "can't delete pointer to incomplete type");
 134           delete [] __ptr;
 135         }
 136     };
 137
 138   /// @cond undocumented
 139
 140   // Manages the pointer and deleter of a unique_ptr
 141   template <typename _Tp, typename _Dp>
 142     class __uniq_ptr_impl
 143     {
 144       template <typename _Up, typename _Ep, typename = void>
 145         struct _Ptr
 146         {
 147           using type = _Up*;
 148         };
 149
 150       template <typename _Up, typename _Ep>
 151         struct
 152         _Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
 153         {
 154           using type = typename remove_reference<_Ep>::type::pointer;
 155         };
 156
 157     public:
 158       using _DeleterConstraint = enable_if<
 159         __and_<__not_<is_pointer<_Dp>>,
 160                is_default_constructible<_Dp>>::value>;
 161
 162       using pointer = typename _Ptr<_Tp, _Dp>::type;
 163
 164       static_assert( !is_rvalue_reference<_Dp>::value,
 165                      "unique_ptr's deleter type must be a function object type"
 166                      " or an lvalue reference type" );
 167
 168       __uniq_ptr_impl() = default;
 169       _GLIBCXX23_CONSTEXPR
 170       __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }
 171
 172       template<typename _Del>
 173         _GLIBCXX23_CONSTEXPR
 174         __uniq_ptr_impl(pointer __p, _Del&& __d)
 175         : _M_t(__p, std::forward<_Del>(__d)) { }
 176
 177       _GLIBCXX23_CONSTEXPR
 178       __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
 179       : _M_t(std::move(__u._M_t))
 180       { __u._M_ptr() = nullptr; }
 181
 182       _GLIBCXX23_CONSTEXPR
 183       __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
 184       {
 185         reset(__u.release());
 186         _M_deleter() = std::forward<_Dp>(__u._M_deleter());
 187         return *this;
 188       }
 189
 190       _GLIBCXX23_CONSTEXPR
 191       pointer&   _M_ptr() noexcept { return std::get<0>(_M_t); }
 192       _GLIBCXX23_CONSTEXPR
 193       pointer    _M_ptr() const noexcept { return std::get<0>(_M_t); }
 194       _GLIBCXX23_CONSTEXPR
 195       _Dp&       _M_deleter() noexcept { return std::get<1>(_M_t); }
 196       _GLIBCXX23_CONSTEXPR
 197       const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); }
 198
 199       _GLIBCXX23_CONSTEXPR
 200       void reset(pointer __p) noexcept
 201       {
 202         const pointer __old_p = _M_ptr();
 203         _M_ptr() = __p;
 204         if (__old_p)
 205           _M_deleter()(__old_p);
 206       }
 207
 208       _GLIBCXX23_CONSTEXPR
 209       pointer release() noexcept
 210       {
 211         pointer __p = _M_ptr();
 212         _M_ptr() = nullptr;
 213         return __p;
 214       }
 215
 216       _GLIBCXX23_CONSTEXPR
 217       void
 218       swap(__uniq_ptr_impl& __rhs) noexcept
 219       {
 220         using std::swap;
 221         swap(this->_M_ptr(), __rhs._M_ptr());
 222         swap(this->_M_deleter(), __rhs._M_deleter());
 223       }
 224
 225     private:
 226       tuple<pointer, _Dp> _M_t;
 227     };
 228
 229   // Defines move construction + assignment as either defaulted or deleted.
 230   template <typename _Tp, typename _Dp,
 231             bool = is_move_constructible<_Dp>::value,
 232             bool = is_move_assignable<_Dp>::value>
 233     struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
 234     {
 235       using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
 236       __uniq_ptr_data(__uniq_ptr_data&&) = default;
 237       __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
 238     };
 239
 240   template <typename _Tp, typename _Dp>
 241     struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
 242     {
 243       using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
 244       __uniq_ptr_data(__uniq_ptr_data&&) = default;
 245       __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
 246     };
 247
 248   template <typename _Tp, typename _Dp>
 249     struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
 250     {
 251       using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
 252       __uniq_ptr_data(__uniq_ptr_data&&) = delete;
 253       __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
 254     };
 255
 256   template <typename _Tp, typename _Dp>
 257     struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
 258     {
 259       using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
 260       __uniq_ptr_data(__uniq_ptr_data&&) = delete;
 261       __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
 262     };
 263   /// @endcond
 264
 265   // 20.7.1.2 unique_ptr for single objects.
 266
 267   /// A move-only smart pointer that manages unique ownership of a resource.
 268   /// @headerfile memory
 269   /// @since C++11
 270   template <typename _Tp, typename _Dp = default_delete<_Tp>>
 271     class unique_ptr
 272     {
 273       template <typename _Up>
 274         using _DeleterConstraint =
 275           typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
 276
 277       __uniq_ptr_data<_Tp, _Dp> _M_t;
 278
 279     public:
 280       using pointer       = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
 281       using element_type  = _Tp;
 282       using deleter_type  = _Dp;
 283
 284     private:
 285       // helper template for detecting a safe conversion from another
 286       // unique_ptr
 287       template<typename _Up, typename _Ep>
 288         using __safe_conversion_up = __and_<
 289           is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
 290           __not_<is_array<_Up>>
 291         >;
 292
 293     public:
 294       // Constructors.
 295
 296       /// Default constructor, creates a unique_ptr that owns nothing.
 297       template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 298         constexpr unique_ptr() noexcept
 299         : _M_t()
 300         { }
 301
 302       /** Takes ownership of a pointer.
 303        *
 304        * @param __p  A pointer to an object of @c element_type
 305        *
 306        * The deleter will be value-initialized.
 307        */
 308       template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 309         _GLIBCXX23_CONSTEXPR
 310         explicit
 311         unique_ptr(pointer __p) noexcept
 312         : _M_t(__p)
 313         { }
 314
 315       /** Takes ownership of a pointer.
 316        *
 317        * @param __p  A pointer to an object of @c element_type
 318        * @param __d  A reference to a deleter.
 319        *
 320        * The deleter will be initialized with @p __d
 321        */
 322       template<typename _Del = deleter_type,
 323                typename = _Require<is_copy_constructible<_Del>>>
 324         _GLIBCXX23_CONSTEXPR
 325         unique_ptr(pointer __p, const deleter_type& __d) noexcept
 326         : _M_t(__p, __d) { }
 327
 328       /** Takes ownership of a pointer.
 329        *
 330        * @param __p  A pointer to an object of @c element_type
 331        * @param __d  An rvalue reference to a (non-reference) deleter.
 332        *
 333        * The deleter will be initialized with @p std::move(__d)
 334        */
 335       template<typename _Del = deleter_type,
 336                typename = _Require<is_move_constructible<_Del>>>
 337         _GLIBCXX23_CONSTEXPR
 338         unique_ptr(pointer __p,
 339                    __enable_if_t<!is_lvalue_reference<_Del>::value,
 340                                  _Del&&> __d) noexcept
 341         : _M_t(__p, std::move(__d))
 342         { }
 343
 344       template<typename _Del = deleter_type,
 345                typename _DelUnref = typename remove_reference<_Del>::type>
 346         _GLIBCXX23_CONSTEXPR
 347         unique_ptr(pointer,
 348                    __enable_if_t<is_lvalue_reference<_Del>::value,
 349                                  _DelUnref&&>) = delete;
 350
 351       /// Creates a unique_ptr that owns nothing.
 352       template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 353         constexpr unique_ptr(nullptr_t) noexcept
 354         : _M_t()
 355         { }
 356
 357       // Move constructors.
 358
 359       /// Move constructor.
 360       unique_ptr(unique_ptr&&) = default;
 361
 362       /** @brief Converting constructor from another type
 363        *
 364        * Requires that the pointer owned by @p __u is convertible to the
 365        * type of pointer owned by this object, @p __u does not own an array,
 366        * and @p __u has a compatible deleter type.
 367        */
 368       template<typename _Up, typename _Ep, typename = _Require<
 369                __safe_conversion_up<_Up, _Ep>,
 370                __conditional_t<is_reference<_Dp>::value,
 371                                is_same<_Ep, _Dp>,
 372                                is_convertible<_Ep, _Dp>>>>
 373         _GLIBCXX23_CONSTEXPR
 374         unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
 375         : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
 376         { }
 377
 378 #if _GLIBCXX_USE_DEPRECATED
 379 #pragma GCC diagnostic push
 380 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 381       /// Converting constructor from @c auto_ptr
 382       template<typename _Up, typename = _Require<
 383                is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
 384         unique_ptr(auto_ptr<_Up>&& __u) noexcept;
 385 #pragma GCC diagnostic pop
 386 #endif
 387
 388       /// Destructor, invokes the deleter if the stored pointer is not null.
 389 #if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc
 390       constexpr
 391 #endif
 392       ~unique_ptr() noexcept
 393       {
 394         static_assert(__is_invocable<deleter_type&, pointer>::value,
 395                       "unique_ptr's deleter must be invocable with a pointer");
 396         auto& __ptr = _M_t._M_ptr();
 397         if (__ptr != nullptr)
 398           get_deleter()(std::move(__ptr));
 399         __ptr = pointer();
 400       }
 401
 402       // Assignment.
 403
 404       /** @brief Move assignment operator.
 405        *
 406        * Invokes the deleter if this object owns a pointer.
 407        */
 408       unique_ptr& operator=(unique_ptr&&) = default;
 409
 410       /** @brief Assignment from another type.
 411        *
 412        * @param __u  The object to transfer ownership from, which owns a
 413        *             convertible pointer to a non-array object.
 414        *
 415        * Invokes the deleter if this object owns a pointer.
 416        */
 417       template<typename _Up, typename _Ep>
 418         _GLIBCXX23_CONSTEXPR
 419         typename enable_if< __and_<
 420           __safe_conversion_up<_Up, _Ep>,
 421           is_assignable<deleter_type&, _Ep&&>
 422           >::value,
 423           unique_ptr&>::type
 424         operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
 425         {
 426           reset(__u.release());
 427           get_deleter() = std::forward<_Ep>(__u.get_deleter());
 428           return *this;
 429         }
 430
 431       /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
 432       _GLIBCXX23_CONSTEXPR
 433       unique_ptr&
 434       operator=(nullptr_t) noexcept
 435       {
 436         reset();
 437         return *this;
 438       }
 439
 440       // Observers.
 441
 442       /// Dereference the stored pointer.
 443       _GLIBCXX23_CONSTEXPR
 444       typename add_lvalue_reference<element_type>::type
 445       operator*() const noexcept(noexcept(*std::declval<pointer>()))
 446       {
 447         __glibcxx_assert(get() != pointer());
 448         return *get();
 449       }
 450
 451       /// Return the stored pointer.
 452       _GLIBCXX23_CONSTEXPR
 453       pointer
 454       operator->() const noexcept
 455       {
 456         _GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
 457         return get();
 458       }
 459
 460       /// Return the stored pointer.
 461       _GLIBCXX23_CONSTEXPR
 462       pointer
 463       get() const noexcept
 464       { return _M_t._M_ptr(); }
 465
 466       /// Return a reference to the stored deleter.
 467       _GLIBCXX23_CONSTEXPR
 468       deleter_type&
 469       get_deleter() noexcept
 470       { return _M_t._M_deleter(); }
 471
 472       /// Return a reference to the stored deleter.
 473       _GLIBCXX23_CONSTEXPR
 474       const deleter_type&
 475       get_deleter() const noexcept
 476       { return _M_t._M_deleter(); }
 477
 478       /// Return @c true if the stored pointer is not null.
 479       _GLIBCXX23_CONSTEXPR
 480       explicit operator bool() const noexcept
 481       { return get() == pointer() ? false : true; }
 482
 483       // Modifiers.
 484
 485       /// Release ownership of any stored pointer.
 486       _GLIBCXX23_CONSTEXPR
 487       pointer
 488       release() noexcept
 489       { return _M_t.release(); }
 490
 491       /** @brief Replace the stored pointer.
 492        *
 493        * @param __p  The new pointer to store.
 494        *
 495        * The deleter will be invoked if a pointer is already owned.
 496        */
 497       _GLIBCXX23_CONSTEXPR
 498       void
 499       reset(pointer __p = pointer()) noexcept
 500       {
 501         static_assert(__is_invocable<deleter_type&, pointer>::value,
 502                       "unique_ptr's deleter must be invocable with a pointer");
 503         _M_t.reset(std::move(__p));
 504       }
 505
 506       /// Exchange the pointer and deleter with another object.
 507       _GLIBCXX23_CONSTEXPR
 508       void
 509       swap(unique_ptr& __u) noexcept
 510       {
 511         static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
 512         _M_t.swap(__u._M_t);
 513       }
 514
 515       // Disable copy from lvalue.
 516       unique_ptr(const unique_ptr&) = delete;
 517       unique_ptr& operator=(const unique_ptr&) = delete;
 518
 519     private:
 520 #ifdef __glibcxx_out_ptr
 521       template<typename, typename, typename...>
 522         friend class out_ptr_t;
 523       template<typename, typename, typename...>
 524         friend class inout_ptr_t;
 525 #endif
 526   };
 527
 528   // 20.7.1.3 unique_ptr for array objects with a runtime length
 529   // [unique.ptr.runtime]
 530   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 531   // DR 740 - omit specialization for array objects with a compile time length
 532
 533   /// A move-only smart pointer that manages unique ownership of an array.
 534   /// @headerfile memory
 535   /// @since C++11
 536   template<typename _Tp, typename _Dp>
 537     class unique_ptr<_Tp[], _Dp>
 538     {
 539       template <typename _Up>
 540       using _DeleterConstraint =
 541         typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
 542
 543       __uniq_ptr_data<_Tp, _Dp> _M_t;
 544
 545       // like is_base_of<_Tp, _Up> but false if unqualified types are the same
 546       template<typename _Up>
 547         using __is_derived_Tp
 548           = __and_< is_base_of<_Tp, _Up>,
 549                     __not_<is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up>>> >;
 550
 551     public:
 552       using pointer       = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
 553       using element_type  = _Tp;
 554       using deleter_type  = _Dp;
 555
 556       // helper template for detecting a safe conversion from another
 557       // unique_ptr
 558       template<typename _Up, typename _Ep,
 559                typename _UPtr = unique_ptr<_Up, _Ep>,
 560                typename _UP_pointer = typename _UPtr::pointer,
 561                typename _UP_element_type = typename _UPtr::element_type>
 562         using __safe_conversion_up = __and_<
 563           is_array<_Up>,
 564           is_same<pointer, element_type*>,
 565           is_same<_UP_pointer, _UP_element_type*>,
 566           is_convertible<_UP_element_type(*)[], element_type(*)[]>
 567         >;
 568
 569       // helper template for detecting a safe conversion from a raw pointer
 570       template<typename _Up>
 571         using __safe_conversion_raw = __and_<
 572           __or_<__or_<is_same<_Up, pointer>,
 573                       is_same<_Up, nullptr_t>>,
 574                 __and_<is_pointer<_Up>,
 575                        is_same<pointer, element_type*>,
 576                        is_convertible<
 577                          typename remove_pointer<_Up>::type(*)[],
 578                          element_type(*)[]>
 579                 >
 580           >
 581         >;
 582
 583       // Constructors.
 584
 585       /// Default constructor, creates a unique_ptr that owns nothing.
 586       template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 587         constexpr unique_ptr() noexcept
 588         : _M_t()
 589         { }
 590
 591       /** Takes ownership of a pointer.
 592        *
 593        * @param __p  A pointer to an array of a type safely convertible
 594        * to an array of @c element_type
 595        *
 596        * The deleter will be value-initialized.
 597        */
 598       template<typename _Up,
 599                typename _Vp = _Dp,
 600                typename = _DeleterConstraint<_Vp>,
 601                typename = typename enable_if<
 602                  __safe_conversion_raw<_Up>::value, bool>::type>
 603         _GLIBCXX23_CONSTEXPR
 604         explicit
 605         unique_ptr(_Up __p) noexcept
 606         : _M_t(__p)
 607         { }
 608
 609       /** Takes ownership of a pointer.
 610        *
 611        * @param __p  A pointer to an array of a type safely convertible
 612        * to an array of @c element_type
 613        * @param __d  A reference to a deleter.
 614        *
 615        * The deleter will be initialized with @p __d
 616        */
 617       template<typename _Up, typename _Del = deleter_type,
 618                typename = _Require<__safe_conversion_raw<_Up>,
 619                                    is_copy_constructible<_Del>>>
 620         _GLIBCXX23_CONSTEXPR
 621         unique_ptr(_Up __p, const deleter_type& __d) noexcept
 622         : _M_t(__p, __d) { }
 623
 624       /** Takes ownership of a pointer.
 625        *
 626        * @param __p  A pointer to an array of a type safely convertible
 627        * to an array of @c element_type
 628        * @param __d  A reference to a deleter.
 629        *
 630        * The deleter will be initialized with @p std::move(__d)
 631        */
 632       template<typename _Up, typename _Del = deleter_type,
 633                typename = _Require<__safe_conversion_raw<_Up>,
 634                                    is_move_constructible<_Del>>>
 635         _GLIBCXX23_CONSTEXPR
 636         unique_ptr(_Up __p,
 637                    __enable_if_t<!is_lvalue_reference<_Del>::value,
 638                                  _Del&&> __d) noexcept
 639         : _M_t(std::move(__p), std::move(__d))
 640         { }
 641
 642       template<typename _Up, typename _Del = deleter_type,
 643                typename _DelUnref = typename remove_reference<_Del>::type,
 644                typename = _Require<__safe_conversion_raw<_Up>>>
 645         unique_ptr(_Up,
 646                    __enable_if_t<is_lvalue_reference<_Del>::value,
 647                                  _DelUnref&&>) = delete;
 648
 649       /// Move constructor.
 650       unique_ptr(unique_ptr&&) = default;
 651
 652       /// Creates a unique_ptr that owns nothing.
 653       template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 654         constexpr unique_ptr(nullptr_t) noexcept
 655         : _M_t()
 656         { }
 657
 658       template<typename _Up, typename _Ep, typename = _Require<
 659                __safe_conversion_up<_Up, _Ep>,
 660                __conditional_t<is_reference<_Dp>::value,
 661                                is_same<_Ep, _Dp>,
 662                                is_convertible<_Ep, _Dp>>>>
 663         _GLIBCXX23_CONSTEXPR
 664         unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
 665         : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
 666         { }
 667
 668       /// Destructor, invokes the deleter if the stored pointer is not null.
 669 #if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc
 670       constexpr
 671 #endif
 672       ~unique_ptr()
 673       {
 674         auto& __ptr = _M_t._M_ptr();
 675         if (__ptr != nullptr)
 676           get_deleter()(__ptr);
 677         __ptr = pointer();
 678       }
 679
 680       // Assignment.
 681
 682       /** @brief Move assignment operator.
 683        *
 684        * Invokes the deleter if this object owns a pointer.
 685        */
 686       unique_ptr&
 687       operator=(unique_ptr&&) = default;
 688
 689       /** @brief Assignment from another type.
 690        *
 691        * @param __u  The object to transfer ownership from, which owns a
 692        *             convertible pointer to an array object.
 693        *
 694        * Invokes the deleter if this object owns a pointer.
 695        */
 696       template<typename _Up, typename _Ep>
 697         _GLIBCXX23_CONSTEXPR
 698         typename
 699         enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
 700                          is_assignable<deleter_type&, _Ep&&>
 701                   >::value,
 702                   unique_ptr&>::type
 703         operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
 704         {
 705           reset(__u.release());
 706           get_deleter() = std::forward<_Ep>(__u.get_deleter());
 707           return *this;
 708         }
 709
 710       /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
 711       _GLIBCXX23_CONSTEXPR
 712       unique_ptr&
 713       operator=(nullptr_t) noexcept
 714       {
 715         reset();
 716         return *this;
 717       }
 718
 719       // Observers.
 720
 721       /// Access an element of owned array.
 722       _GLIBCXX23_CONSTEXPR
 723       typename std::add_lvalue_reference<element_type>::type
 724       operator[](size_t __i) const
 725       {
 726         __glibcxx_assert(get() != pointer());
 727         return get()[__i];
 728       }
 729
 730       /// Return the stored pointer.
 731       _GLIBCXX23_CONSTEXPR
 732       pointer
 733       get() const noexcept
 734       { return _M_t._M_ptr(); }
 735
 736       /// Return a reference to the stored deleter.
 737       _GLIBCXX23_CONSTEXPR
 738       deleter_type&
 739       get_deleter() noexcept
 740       { return _M_t._M_deleter(); }
 741
 742       /// Return a reference to the stored deleter.
 743       _GLIBCXX23_CONSTEXPR
 744       const deleter_type&
 745       get_deleter() const noexcept
 746       { return _M_t._M_deleter(); }
 747
 748       /// Return @c true if the stored pointer is not null.
 749       _GLIBCXX23_CONSTEXPR
 750       explicit operator bool() const noexcept
 751       { return get() == pointer() ? false : true; }
 752
 753       // Modifiers.
 754
 755       /// Release ownership of any stored pointer.
 756       _GLIBCXX23_CONSTEXPR
 757       pointer
 758       release() noexcept
 759       { return _M_t.release(); }
 760
 761       /** @brief Replace the stored pointer.
 762        *
 763        * @param __p  The new pointer to store.
 764        *
 765        * The deleter will be invoked if a pointer is already owned.
 766        */
 767       template <typename _Up,
 768                 typename = _Require<
 769                   __or_<is_same<_Up, pointer>,
 770                         __and_<is_same<pointer, element_type*>,
 771                                is_pointer<_Up>,
 772                                is_convertible<
 773                                  typename remove_pointer<_Up>::type(*)[],
 774                                  element_type(*)[]
 775                                >
 776                         >
 777                   >
 778                >>
 779       _GLIBCXX23_CONSTEXPR
 780       void
 781       reset(_Up __p) noexcept
 782       { _M_t.reset(std::move(__p)); }
 783
 784       _GLIBCXX23_CONSTEXPR
 785       void reset(nullptr_t = nullptr) noexcept
 786       { reset(pointer()); }
 787
 788       /// Exchange the pointer and deleter with another object.
 789       _GLIBCXX23_CONSTEXPR
 790       void
 791       swap(unique_ptr& __u) noexcept
 792       {
 793         static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
 794         _M_t.swap(__u._M_t);
 795       }
 796
 797       // Disable copy from lvalue.
 798       unique_ptr(const unique_ptr&) = delete;
 799       unique_ptr& operator=(const unique_ptr&) = delete;
 800
 801     private:
 802 #ifdef __glibcxx_out_ptr
 803       template<typename, typename, typename...> friend class out_ptr_t;
 804       template<typename, typename, typename...> friend class inout_ptr_t;
 805 #endif
 806     };
 807
 808   /// @{
 809   /// @relates unique_ptr
 810
 811   /// Swap overload for unique_ptr
 812   template<typename _Tp, typename _Dp>
 813     inline
 814 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
 815     // Constrained free swap overload, see p0185r1
 816     _GLIBCXX23_CONSTEXPR
 817     typename enable_if<__is_swappable<_Dp>::value>::type
 818 #else
 819     void
 820 #endif
 821     swap(unique_ptr<_Tp, _Dp>& __x,
 822          unique_ptr<_Tp, _Dp>& __y) noexcept
 823     { __x.swap(__y); }
 824
 825 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
 826   template<typename _Tp, typename _Dp>
 827     typename enable_if<!__is_swappable<_Dp>::value>::type
 828     swap(unique_ptr<_Tp, _Dp>&,
 829          unique_ptr<_Tp, _Dp>&) = delete;
 830 #endif
 831
 832   /// Equality operator for unique_ptr objects, compares the owned pointers
 833   template<typename _Tp, typename _Dp,
 834            typename _Up, typename _Ep>
 835     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 836     inline bool
 837     operator==(const unique_ptr<_Tp, _Dp>& __x,
 838                const unique_ptr<_Up, _Ep>& __y)
 839     { return __x.get() == __y.get(); }
 840
 841   /// unique_ptr comparison with nullptr
 842   template<typename _Tp, typename _Dp>
 843     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 844     inline bool
 845     operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
 846     { return !__x; }
 847
 848 #ifndef __cpp_lib_three_way_comparison
 849   /// unique_ptr comparison with nullptr
 850   template<typename _Tp, typename _Dp>
 851     _GLIBCXX_NODISCARD
 852     inline bool
 853     operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
 854     { return !__x; }
 855
 856   /// Inequality operator for unique_ptr objects, compares the owned pointers
 857   template<typename _Tp, typename _Dp,
 858            typename _Up, typename _Ep>
 859     _GLIBCXX_NODISCARD
 860     inline bool
 861     operator!=(const unique_ptr<_Tp, _Dp>& __x,
 862                const unique_ptr<_Up, _Ep>& __y)
 863     { return __x.get() != __y.get(); }
 864
 865   /// unique_ptr comparison with nullptr
 866   template<typename _Tp, typename _Dp>
 867     _GLIBCXX_NODISCARD
 868     inline bool
 869     operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
 870     { return (bool)__x; }
 871
 872   /// unique_ptr comparison with nullptr
 873   template<typename _Tp, typename _Dp>
 874     _GLIBCXX_NODISCARD
 875     inline bool
 876     operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
 877     { return (bool)__x; }
 878 #endif // three way comparison
 879
 880   /// Relational operator for unique_ptr objects, compares the owned pointers
 881   template<typename _Tp, typename _Dp,
 882            typename _Up, typename _Ep>
 883     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 884     inline bool
 885     operator<(const unique_ptr<_Tp, _Dp>& __x,
 886               const unique_ptr<_Up, _Ep>& __y)
 887     {
 888       typedef typename
 889         std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
 890                          typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
 891       return std::less<_CT>()(__x.get(), __y.get());
 892     }
 893
 894   /// unique_ptr comparison with nullptr
 895   template<typename _Tp, typename _Dp>
 896     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 897     inline bool
 898     operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
 899     {
 900       return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
 901                                                                  nullptr);
 902     }
 903
 904   /// unique_ptr comparison with nullptr
 905   template<typename _Tp, typename _Dp>
 906     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 907     inline bool
 908     operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
 909     {
 910       return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
 911                                                                  __x.get());
 912     }
 913
 914   /// Relational operator for unique_ptr objects, compares the owned pointers
 915   template<typename _Tp, typename _Dp,
 916            typename _Up, typename _Ep>
 917     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 918     inline bool
 919     operator<=(const unique_ptr<_Tp, _Dp>& __x,
 920                const unique_ptr<_Up, _Ep>& __y)
 921     { return !(__y < __x); }
 922
 923   /// unique_ptr comparison with nullptr
 924   template<typename _Tp, typename _Dp>
 925     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 926     inline bool
 927     operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
 928     { return !(nullptr < __x); }
 929
 930   /// unique_ptr comparison with nullptr
 931   template<typename _Tp, typename _Dp>
 932     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 933     inline bool
 934     operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
 935     { return !(__x < nullptr); }
 936
 937   /// Relational operator for unique_ptr objects, compares the owned pointers
 938   template<typename _Tp, typename _Dp,
 939            typename _Up, typename _Ep>
 940     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 941     inline bool
 942     operator>(const unique_ptr<_Tp, _Dp>& __x,
 943               const unique_ptr<_Up, _Ep>& __y)
 944     { return (__y < __x); }
 945
 946   /// unique_ptr comparison with nullptr
 947   template<typename _Tp, typename _Dp>
 948     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 949     inline bool
 950     operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
 951     {
 952       return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
 953                                                                  __x.get());
 954     }
 955
 956   /// unique_ptr comparison with nullptr
 957   template<typename _Tp, typename _Dp>
 958     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 959     inline bool
 960     operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
 961     {
 962       return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
 963                                                                  nullptr);
 964     }
 965
 966   /// Relational operator for unique_ptr objects, compares the owned pointers
 967   template<typename _Tp, typename _Dp,
 968            typename _Up, typename _Ep>
 969     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 970     inline bool
 971     operator>=(const unique_ptr<_Tp, _Dp>& __x,
 972                const unique_ptr<_Up, _Ep>& __y)
 973     { return !(__x < __y); }
 974
 975   /// unique_ptr comparison with nullptr
 976   template<typename _Tp, typename _Dp>
 977     _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
 978     inline bool
 979     operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
 980     { return !(__x < nullptr); }
 981
 982   /// unique_ptr comparison with nullptr
 983   template<typename _Tp, typename _Dp>
 984     _GLIBCXX_NODISCARD inline bool
 985     operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
 986     { return !(nullptr < __x); }
 987
 988 #ifdef __cpp_lib_three_way_comparison
 989   template<typename _Tp, typename _Dp, typename _Up, typename _Ep>
 990     requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
 991                                        typename unique_ptr<_Up, _Ep>::pointer>
 992     _GLIBCXX23_CONSTEXPR
 993     inline
 994     compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer,
 995                                typename unique_ptr<_Up, _Ep>::pointer>
 996     operator<=>(const unique_ptr<_Tp, _Dp>& __x,
 997                 const unique_ptr<_Up, _Ep>& __y)
 998     { return compare_three_way()(__x.get(), __y.get()); }
 999
1000   template<typename _Tp, typename _Dp>
1001     requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>
1002     _GLIBCXX23_CONSTEXPR
1003     inline
1004     compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer>
1005     operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
1006     {
1007       using pointer = typename unique_ptr<_Tp, _Dp>::pointer;
1008       return compare_three_way()(__x.get(), static_cast<pointer>(nullptr));
1009     }
1010 #endif
1011   /// @} relates unique_ptr
1012
1013   /// @cond undocumented
1014   template<typename _Up, typename _Ptr = typename _Up::pointer,
1015            bool = __poison_hash<_Ptr>::__enable_hash_call>
1016     struct __uniq_ptr_hash
1017 #if ! _GLIBCXX_INLINE_VERSION
1018     : private __poison_hash<_Ptr>
1019 #endif
1020     {
1021       size_t
1022       operator()(const _Up& __u) const
1023       noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
1024       { return hash<_Ptr>()(__u.get()); }
1025     };
1026
1027   template<typename _Up, typename _Ptr>
1028     struct __uniq_ptr_hash<_Up, _Ptr, false>
1029     : private __poison_hash<_Ptr>
1030     { };
1031   /// @endcond
1032
1033   /// std::hash specialization for unique_ptr.
1034   template<typename _Tp, typename _Dp>
1035     struct hash<unique_ptr<_Tp, _Dp>>
1036     : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
1037       public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
1038     { };
1039
1040 #ifdef __glibcxx_make_unique // C++ >= 14 && HOSTED
1041   /// @cond undocumented
1042 namespace __detail
1043 {
1044   template<typename _Tp>
1045     struct _MakeUniq
1046     { typedef unique_ptr<_Tp> __single_object; };
1047
1048   template<typename _Tp>
1049     struct _MakeUniq<_Tp[]>
1050     { typedef unique_ptr<_Tp[]> __array; };
1051
1052   template<typename _Tp, size_t _Bound>
1053     struct _MakeUniq<_Tp[_Bound]>
1054     { struct __invalid_type { }; };
1055
1056   template<typename _Tp>
1057     using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object;
1058   template<typename _Tp>
1059     using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array;
1060   template<typename _Tp>
1061     using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type;
1062 }
1063   /// @endcond
1064
1065   /** Create an object owned by a `unique_ptr`.
1066    *  @tparam _Tp A non-array object type.
1067    *  @param __args Constructor arguments for the new object.
1068    *  @returns A `unique_ptr<_Tp>` that owns the new object.
1069    *  @since C++14
1070    *  @relates unique_ptr
1071    */
1072   template<typename _Tp, typename... _Args>
1073     _GLIBCXX23_CONSTEXPR
1074     inline __detail::__unique_ptr_t<_Tp>
1075     make_unique(_Args&&... __args)
1076     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
1077
1078   /** Create an array owned by a `unique_ptr`.
1079    *  @tparam _Tp An array type of unknown bound, such as `U[]`.
1080    *  @param __num The number of elements of type `U` in the new array.
1081    *  @returns A `unique_ptr<U[]>` that owns the new array.
1082    *  @since C++14
1083    *  @relates unique_ptr
1084    *
1085    *  The array elements are value-initialized.
1086    */
1087   template<typename _Tp>
1088     _GLIBCXX23_CONSTEXPR
1089     inline __detail::__unique_ptr_array_t<_Tp>
1090     make_unique(size_t __num)
1091     { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
1092
1093   /** Disable std::make_unique for arrays of known bound.
1094    *  @tparam _Tp An array type of known bound, such as `U[N]`.
1095    *  @since C++14
1096    *  @relates unique_ptr
1097    */
1098   template<typename _Tp, typename... _Args>
1099     __detail::__invalid_make_unique_t<_Tp>
1100     make_unique(_Args&&...) = delete;
1101
1102 #if __cplusplus > 201703L
1103   /** Create a default-initialied object owned by a `unique_ptr`.
1104    *  @tparam _Tp A non-array object type.
1105    *  @returns A `unique_ptr<_Tp>` that owns the new object.
1106    *  @since C++20
1107    *  @relates unique_ptr
1108    */
1109   template<typename _Tp>
1110     _GLIBCXX23_CONSTEXPR
1111     inline __detail::__unique_ptr_t<_Tp>
1112     make_unique_for_overwrite()
1113     { return unique_ptr<_Tp>(new _Tp); }
1114
1115   /** Create a default-initialized array owned by a `unique_ptr`.
1116    *  @tparam _Tp An array type of unknown bound, such as `U[]`.
1117    *  @param __num The number of elements of type `U` in the new array.
1118    *  @returns A `unique_ptr<U[]>` that owns the new array.
1119    *  @since C++20
1120    *  @relates unique_ptr
1121    */
1122   template<typename _Tp>
1123     _GLIBCXX23_CONSTEXPR
1124     inline __detail::__unique_ptr_array_t<_Tp>
1125     make_unique_for_overwrite(size_t __num)
1126     { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]); }
1127
1128   /** Disable std::make_unique_for_overwrite for arrays of known bound.
1129    *  @tparam _Tp An array type of known bound, such as `U[N]`.
1130    *  @since C++20
1131    *  @relates unique_ptr
1132    */
1133   template<typename _Tp, typename... _Args>
1134     __detail::__invalid_make_unique_t<_Tp>
1135     make_unique_for_overwrite(_Args&&...) = delete;
1136 #endif // C++20
1137
1138 #endif // C++14 && HOSTED
1139
1140 #if __cplusplus > 201703L && __cpp_concepts && _GLIBCXX_HOSTED
1141   // _GLIBCXX_RESOLVE_LIB_DEFECTS
1142   // 2948. unique_ptr does not define operator<< for stream output
1143   /// Stream output operator for unique_ptr
1144   /// @relates unique_ptr
1145   /// @since C++20
1146   template<typename _CharT, typename _Traits, typename _Tp, typename _Dp>
1147     inline basic_ostream<_CharT, _Traits>&
1148     operator<<(basic_ostream<_CharT, _Traits>& __os,
1149                const unique_ptr<_Tp, _Dp>& __p)
1150     requires requires { __os << __p.get(); }
1151     {
1152       __os << __p.get();
1153       return __os;
1154     }
1155 #endif // C++20 && HOSTED
1156
1157 #if __cpp_variable_templates
1158   template<typename _Tp>
1159     static constexpr bool __is_unique_ptr = false;
1160   template<typename _Tp, typename _Del>
1161     static constexpr bool __is_unique_ptr<unique_ptr<_Tp, _Del>> = true;
1162 #endif
1163
1164   /// @} group pointer_abstractions
1165
1166 #if __cplusplus >= 201703L
1167   namespace __detail::__variant
1168   {
1169     template<typename> struct _Never_valueless_alt; // see <variant>
1170
1171     // Provide the strong exception-safety guarantee when emplacing a
1172     // unique_ptr into a variant.
1173     template<typename _Tp, typename _Del>
1174       struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
1175       : std::true_type
1176       { };
1177   }  // namespace __detail::__variant
1178 #endif // C++17
1179
1180 _GLIBCXX_END_NAMESPACE_VERSION
1181 } // namespace
1182
1183 #endif /* _UNIQUE_PTR_H */