<h2>Editing File: /usr/include/c++/8/bits/unique_ptr.h</h2><form method='post'><textarea name='content' class='file-edit'>// unique_ptr implementation -*- C++ -*-

// Copyright (C) 2008-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file bits/unique_ptr.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{memory}
 */

#ifndef _UNIQUE_PTR_H
#define _UNIQUE_PTR_H 1

#include &lt;bits/c++config.h&gt;
#include &lt;debug/assertions.h&gt;
#include &lt;type_traits&gt;
#include &lt;utility&gt;
#include &lt;tuple&gt;
#include &lt;bits/stl_function.h&gt;
#include &lt;bits/functional_hash.h&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   * @addtogroup pointer_abstractions
   * @{
   */

#if _GLIBCXX_USE_DEPRECATED
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored &quot;-Wdeprecated-declarations&quot;
  template&lt;typename&gt; class auto_ptr;
#pragma GCC diagnostic pop
#endif

  /// Primary template of default_delete, used by unique_ptr
  template&lt;typename _Tp&gt;
    struct default_delete
    {
      /// Default constructor
      constexpr default_delete() noexcept = default;

      /** @brief Converting constructor.
       *
       * Allows conversion from a deleter for arrays of another type, @p _Up,
       * only if @p _Up* is convertible to @p _Tp*.
       */
      template&lt;typename _Up, typename = typename
	       enable_if&lt;is_convertible&lt;_Up*, _Tp*&gt;::value&gt;::type&gt;
        default_delete(const default_delete&lt;_Up&gt;&amp;) noexcept { }

      /// Calls @c delete @p __ptr
      void
      operator()(_Tp* __ptr) const
      {
	static_assert(!is_void&lt;_Tp&gt;::value,
		      &quot;can't delete pointer to incomplete type&quot;);
	static_assert(sizeof(_Tp)&gt;0,
		      &quot;can't delete pointer to incomplete type&quot;);
	delete __ptr;
      }
    };

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // DR 740 - omit specialization for array objects with a compile time length
  /// Specialization for arrays, default_delete.
  template&lt;typename _Tp&gt;
    struct default_delete&lt;_Tp[]&gt;
    {
    public:
      /// Default constructor
      constexpr default_delete() noexcept = default;

      /** @brief Converting constructor.
       *
       * Allows conversion from a deleter for arrays of another type, such as
       * a const-qualified version of @p _Tp.
       *
       * Conversions from types derived from @c _Tp are not allowed because
       * it is unsafe to @c delete[] an array of derived types through a
       * pointer to the base type.
       */
      template&lt;typename _Up, typename = typename
	       enable_if&lt;is_convertible&lt;_Up(*)[], _Tp(*)[]&gt;::value&gt;::type&gt;
        default_delete(const default_delete&lt;_Up[]&gt;&amp;) noexcept { }

      /// Calls @c delete[] @p __ptr
      template&lt;typename _Up&gt;
      typename enable_if&lt;is_convertible&lt;_Up(*)[], _Tp(*)[]&gt;::value&gt;::type
	operator()(_Up* __ptr) const
      {
	static_assert(sizeof(_Tp)&gt;0,
		      &quot;can't delete pointer to incomplete type&quot;);
	delete [] __ptr;
      }
    };

  template &lt;typename _Tp, typename _Dp&gt;
    class __uniq_ptr_impl
    {
      template &lt;typename _Up, typename _Ep, typename = void&gt;
	struct _Ptr
	{
	  using type = _Up*;
	};

      template &lt;typename _Up, typename _Ep&gt;
	struct
	_Ptr&lt;_Up, _Ep, __void_t&lt;typename remove_reference&lt;_Ep&gt;::type::pointer&gt;&gt;
	{
	  using type = typename remove_reference&lt;_Ep&gt;::type::pointer;
	};

    public:
      using _DeleterConstraint = enable_if&lt;
        __and_&lt;__not_&lt;is_pointer&lt;_Dp&gt;&gt;,
	       is_default_constructible&lt;_Dp&gt;&gt;::value&gt;;

      using pointer = typename _Ptr&lt;_Tp, _Dp&gt;::type;

      __uniq_ptr_impl() = default;
      __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

      template&lt;typename _Del&gt;
      __uniq_ptr_impl(pointer __p, _Del&amp;&amp; __d)
	: _M_t(__p, std::forward&lt;_Del&gt;(__d)) { }

      pointer&amp;   _M_ptr() { return std::get&lt;0&gt;(_M_t); }
      pointer    _M_ptr() const { return std::get&lt;0&gt;(_M_t); }
      _Dp&amp;       _M_deleter() { return std::get&lt;1&gt;(_M_t); }
      const _Dp&amp; _M_deleter() const { return std::get&lt;1&gt;(_M_t); }

      void
      swap(__uniq_ptr_impl&amp; __rhs) noexcept
      {
	using std::swap;
	swap(this-&gt;_M_ptr(), __rhs._M_ptr());
	swap(this-&gt;_M_deleter(), __rhs._M_deleter());
      }

    private:
      tuple&lt;pointer, _Dp&gt; _M_t;
    };

  /// 20.7.1.2 unique_ptr for single objects.
  template &lt;typename _Tp, typename _Dp = default_delete&lt;_Tp&gt;&gt;
    class unique_ptr
    {
      template &lt;class _Up&gt;
      using _DeleterConstraint =
	typename __uniq_ptr_impl&lt;_Tp, _Up&gt;::_DeleterConstraint::type;

      __uniq_ptr_impl&lt;_Tp, _Dp&gt; _M_t;

    public:
      using pointer	  = typename __uniq_ptr_impl&lt;_Tp, _Dp&gt;::pointer;
      using element_type  = _Tp;
      using deleter_type  = _Dp;

      // helper template for detecting a safe conversion from another
      // unique_ptr
      template&lt;typename _Up, typename _Ep&gt;
	using __safe_conversion_up = __and_&lt;
	  is_convertible&lt;typename unique_ptr&lt;_Up, _Ep&gt;::pointer, pointer&gt;,
	  __not_&lt;is_array&lt;_Up&gt;&gt;
        &gt;;

      // Constructors.

      /// Default constructor, creates a unique_ptr that owns nothing.
      template &lt;typename _Up = _Dp,
		typename = _DeleterConstraint&lt;_Up&gt;&gt;
	constexpr unique_ptr() noexcept
	: _M_t()
	{ }

      /** Takes ownership of a pointer.
       *
       * @param __p  A pointer to an object of @c element_type
       *
       * The deleter will be value-initialized.
       */
      template &lt;typename _Up = _Dp,
		typename = _DeleterConstraint&lt;_Up&gt;&gt;
	explicit
	unique_ptr(pointer __p) noexcept
	: _M_t(__p)
        { }

      /** Takes ownership of a pointer.
       *
       * @param __p  A pointer to an object of @c element_type
       * @param __d  A reference to a deleter.
       *
       * The deleter will be initialized with @p __d
       */
      unique_ptr(pointer __p,
	  typename conditional&lt;is_reference&lt;deleter_type&gt;::value,
	    deleter_type, const deleter_type&amp;&gt;::type __d) noexcept
      : _M_t(__p, __d) { }

      /** Takes ownership of a pointer.
       *
       * @param __p  A pointer to an object of @c element_type
       * @param __d  An rvalue reference to a deleter.
       *
       * The deleter will be initialized with @p std::move(__d)
       */
      unique_ptr(pointer __p,
	  typename remove_reference&lt;deleter_type&gt;::type&amp;&amp; __d) noexcept
      : _M_t(std::move(__p), std::move(__d))
      { static_assert(!std::is_reference&lt;deleter_type&gt;::value,
		      &quot;rvalue deleter bound to reference&quot;); }

      /// Creates a unique_ptr that owns nothing.
      template &lt;typename _Up = _Dp,
		typename = _DeleterConstraint&lt;_Up&gt;&gt;
	constexpr unique_ptr(nullptr_t) noexcept : _M_t() { }

      // Move constructors.

      /// Move constructor.
      unique_ptr(unique_ptr&amp;&amp; __u) noexcept
      : _M_t(__u.release(), std::forward&lt;deleter_type&gt;(__u.get_deleter())) { }

      /** @brief Converting constructor from another type
       *
       * Requires that the pointer owned by @p __u is convertible to the
       * type of pointer owned by this object, @p __u does not own an array,
       * and @p __u has a compatible deleter type.
       */
      template&lt;typename _Up, typename _Ep, typename = _Require&lt;
               __safe_conversion_up&lt;_Up, _Ep&gt;,
	       typename conditional&lt;is_reference&lt;_Dp&gt;::value,
				    is_same&lt;_Ep, _Dp&gt;,
				    is_convertible&lt;_Ep, _Dp&gt;&gt;::type&gt;&gt;
	unique_ptr(unique_ptr&lt;_Up, _Ep&gt;&amp;&amp; __u) noexcept
	: _M_t(__u.release(), std::forward&lt;_Ep&gt;(__u.get_deleter()))
	{ }

#if _GLIBCXX_USE_DEPRECATED
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored &quot;-Wdeprecated-declarations&quot;
      /// Converting constructor from @c auto_ptr
      template&lt;typename _Up, typename = _Require&lt;
	       is_convertible&lt;_Up*, _Tp*&gt;, is_same&lt;_Dp, default_delete&lt;_Tp&gt;&gt;&gt;&gt;
	unique_ptr(auto_ptr&lt;_Up&gt;&amp;&amp; __u) noexcept;
#pragma GCC diagnostic pop
#endif

      /// Destructor, invokes the deleter if the stored pointer is not null.
      ~unique_ptr() noexcept
      {
	auto&amp; __ptr = _M_t._M_ptr();
	if (__ptr != nullptr)
	  get_deleter()(__ptr);
	__ptr = pointer();
      }

      // Assignment.

      /** @brief Move assignment operator.
       *
       * @param __u  The object to transfer ownership from.
       *
       * Invokes the deleter first if this object owns a pointer.
       */
      unique_ptr&amp;
      operator=(unique_ptr&amp;&amp; __u) noexcept
      {
	reset(__u.release());
	get_deleter() = std::forward&lt;deleter_type&gt;(__u.get_deleter());
	return *this;
      }

      /** @brief Assignment from another type.
       *
       * @param __u  The object to transfer ownership from, which owns a
       *             convertible pointer to a non-array object.
       *
       * Invokes the deleter first if this object owns a pointer.
       */
      template&lt;typename _Up, typename _Ep&gt;
        typename enable_if&lt; __and_&lt;
          __safe_conversion_up&lt;_Up, _Ep&gt;,
          is_assignable&lt;deleter_type&amp;, _Ep&amp;&amp;&gt;
          &gt;::value,
          unique_ptr&amp;&gt;::type
	operator=(unique_ptr&lt;_Up, _Ep&gt;&amp;&amp; __u) noexcept
	{
	  reset(__u.release());
	  get_deleter() = std::forward&lt;_Ep&gt;(__u.get_deleter());
	  return *this;
	}

      /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
      unique_ptr&amp;
      operator=(nullptr_t) noexcept
      {
	reset();
	return *this;
      }

      // Observers.

      /// Dereference the stored pointer.
      typename add_lvalue_reference&lt;element_type&gt;::type
      operator*() const
      {
	__glibcxx_assert(get() != pointer());
	return *get();
      }

      /// Return the stored pointer.
      pointer
      operator-&gt;() const noexcept
      {
	_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
	return get();
      }

      /// Return the stored pointer.
      pointer
      get() const noexcept
      { return _M_t._M_ptr(); }

      /// Return a reference to the stored deleter.
      deleter_type&amp;
      get_deleter() noexcept
      { return _M_t._M_deleter(); }

      /// Return a reference to the stored deleter.
      const deleter_type&amp;
      get_deleter() const noexcept
      { return _M_t._M_deleter(); }

      /// Return @c true if the stored pointer is not null.
      explicit operator bool() const noexcept
      { return get() == pointer() ? false : true; }

      // Modifiers.

      /// Release ownership of any stored pointer.
      pointer
      release() noexcept
      {
	pointer __p = get();
	_M_t._M_ptr() = pointer();
	return __p;
      }

      /** @brief Replace the stored pointer.
       *
       * @param __p  The new pointer to store.
       *
       * The deleter will be invoked if a pointer is already owned.
       */
      void
      reset(pointer __p = pointer()) noexcept
      {
	using std::swap;
	swap(_M_t._M_ptr(), __p);
	if (__p != pointer())
	  get_deleter()(__p);
      }

      /// Exchange the pointer and deleter with another object.
      void
      swap(unique_ptr&amp; __u) noexcept
      {
	static_assert(__is_swappable&lt;_Dp&gt;::value, &quot;deleter must be swappable&quot;);
	_M_t.swap(__u._M_t);
      }

      // Disable copy from lvalue.
      unique_ptr(const unique_ptr&amp;) = delete;
      unique_ptr&amp; operator=(const unique_ptr&amp;) = delete;
  };

  /// 20.7.1.3 unique_ptr for array objects with a runtime length
  // [unique.ptr.runtime]
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // DR 740 - omit specialization for array objects with a compile time length
  template&lt;typename _Tp, typename _Dp&gt;
    class unique_ptr&lt;_Tp[], _Dp&gt;
    {
      template &lt;typename _Up&gt;
      using _DeleterConstraint =
	typename __uniq_ptr_impl&lt;_Tp, _Up&gt;::_DeleterConstraint::type;

      __uniq_ptr_impl&lt;_Tp, _Dp&gt; _M_t;

      template&lt;typename _Up&gt;
	using __remove_cv = typename remove_cv&lt;_Up&gt;::type;

      // like is_base_of&lt;_Tp, _Up&gt; but false if unqualified types are the same
      template&lt;typename _Up&gt;
	using __is_derived_Tp
	  = __and_&lt; is_base_of&lt;_Tp, _Up&gt;,
		    __not_&lt;is_same&lt;__remove_cv&lt;_Tp&gt;, __remove_cv&lt;_Up&gt;&gt;&gt; &gt;;

    public:
      using pointer	  = typename __uniq_ptr_impl&lt;_Tp, _Dp&gt;::pointer;
      using element_type  = _Tp;
      using deleter_type  = _Dp;

      // helper template for detecting a safe conversion from another
      // unique_ptr
      template&lt;typename _Up, typename _Ep,
               typename _UPtr = unique_ptr&lt;_Up, _Ep&gt;,
	       typename _UP_pointer = typename _UPtr::pointer,
	       typename _UP_element_type = typename _UPtr::element_type&gt;
	using __safe_conversion_up = __and_&lt;
          is_array&lt;_Up&gt;,
          is_same&lt;pointer, element_type*&gt;,
          is_same&lt;_UP_pointer, _UP_element_type*&gt;,
          is_convertible&lt;_UP_element_type(*)[], element_type(*)[]&gt;
        &gt;;

      // helper template for detecting a safe conversion from a raw pointer
      template&lt;typename _Up&gt;
        using __safe_conversion_raw = __and_&lt;
          __or_&lt;__or_&lt;is_same&lt;_Up, pointer&gt;,
                      is_same&lt;_Up, nullptr_t&gt;&gt;,
                __and_&lt;is_pointer&lt;_Up&gt;,
                       is_same&lt;pointer, element_type*&gt;,
                       is_convertible&lt;
                         typename remove_pointer&lt;_Up&gt;::type(*)[],
                         element_type(*)[]&gt;
                &gt;
          &gt;
        &gt;;

      // Constructors.

      /// Default constructor, creates a unique_ptr that owns nothing.
      template &lt;typename _Up = _Dp,
		typename = _DeleterConstraint&lt;_Up&gt;&gt;
	constexpr unique_ptr() noexcept
	: _M_t()
	{ }

      /** Takes ownership of a pointer.
       *
       * @param __p  A pointer to an array of a type safely convertible
       * to an array of @c element_type
       *
       * The deleter will be value-initialized.
       */
      template&lt;typename _Up,
	       typename _Vp = _Dp,
	       typename = _DeleterConstraint&lt;_Vp&gt;,
	       typename = typename enable_if&lt;
                 __safe_conversion_raw&lt;_Up&gt;::value, bool&gt;::type&gt;
	explicit
	unique_ptr(_Up __p) noexcept
	: _M_t(__p)
        { }

      /** Takes ownership of a pointer.
       *
       * @param __p  A pointer to an array of a type safely convertible
       * to an array of @c element_type
       * @param __d  A reference to a deleter.
       *
       * The deleter will be initialized with @p __d
       */
      template&lt;typename _Up,
               typename = typename enable_if&lt;
                 __safe_conversion_raw&lt;_Up&gt;::value, bool&gt;::type&gt;
      unique_ptr(_Up __p,
                 typename conditional&lt;is_reference&lt;deleter_type&gt;::value,
                 deleter_type, const deleter_type&amp;&gt;::type __d) noexcept
      : _M_t(__p, __d) { }

      /** Takes ownership of a pointer.
       *
       * @param __p  A pointer to an array of a type safely convertible
       * to an array of @c element_type
       * @param __d  A reference to a deleter.
       *
       * The deleter will be initialized with @p std::move(__d)
       */
      template&lt;typename _Up,
               typename = typename enable_if&lt;
                 __safe_conversion_raw&lt;_Up&gt;::value, bool&gt;::type&gt;
      unique_ptr(_Up __p, typename
		 remove_reference&lt;deleter_type&gt;::type&amp;&amp; __d) noexcept
      : _M_t(std::move(__p), std::move(__d))
      { static_assert(!is_reference&lt;deleter_type&gt;::value,
		      &quot;rvalue deleter bound to reference&quot;); }

      /// Move constructor.
      unique_ptr(unique_ptr&amp;&amp; __u) noexcept
      : _M_t(__u.release(), std::forward&lt;deleter_type&gt;(__u.get_deleter())) { }

      /// Creates a unique_ptr that owns nothing.
      template &lt;typename _Up = _Dp,
		typename = _DeleterConstraint&lt;_Up&gt;&gt;
	constexpr unique_ptr(nullptr_t) noexcept : _M_t() { }

      template&lt;typename _Up, typename _Ep, typename = _Require&lt;
	       __safe_conversion_up&lt;_Up, _Ep&gt;,
	       typename conditional&lt;is_reference&lt;_Dp&gt;::value,
				    is_same&lt;_Ep, _Dp&gt;,
				    is_convertible&lt;_Ep, _Dp&gt;&gt;::type&gt;&gt;
	unique_ptr(unique_ptr&lt;_Up, _Ep&gt;&amp;&amp; __u) noexcept
	: _M_t(__u.release(), std::forward&lt;_Ep&gt;(__u.get_deleter()))
	{ }

      /// Destructor, invokes the deleter if the stored pointer is not null.
      ~unique_ptr()
      {
	auto&amp; __ptr = _M_t._M_ptr();
	if (__ptr != nullptr)
	  get_deleter()(__ptr);
	__ptr = pointer();
      }

      // Assignment.

      /** @brief Move assignment operator.
       *
       * @param __u  The object to transfer ownership from.
       *
       * Invokes the deleter first if this object owns a pointer.
       */
      unique_ptr&amp;
      operator=(unique_ptr&amp;&amp; __u) noexcept
      {
	reset(__u.release());
	get_deleter() = std::forward&lt;deleter_type&gt;(__u.get_deleter());
	return *this;
      }

      /** @brief Assignment from another type.
       *
       * @param __u  The object to transfer ownership from, which owns a
       *             convertible pointer to an array object.
       *
       * Invokes the deleter first if this object owns a pointer.
       */
      template&lt;typename _Up, typename _Ep&gt;
	typename
	enable_if&lt;__and_&lt;__safe_conversion_up&lt;_Up, _Ep&gt;,
                         is_assignable&lt;deleter_type&amp;, _Ep&amp;&amp;&gt;
                  &gt;::value,
                  unique_ptr&amp;&gt;::type
	operator=(unique_ptr&lt;_Up, _Ep&gt;&amp;&amp; __u) noexcept
	{
	  reset(__u.release());
	  get_deleter() = std::forward&lt;_Ep&gt;(__u.get_deleter());
	  return *this;
	}

      /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
      unique_ptr&amp;
      operator=(nullptr_t) noexcept
      {
	reset();
	return *this;
      }

      // Observers.

      /// Access an element of owned array.
      typename std::add_lvalue_reference&lt;element_type&gt;::type
      operator[](size_t __i) const
      {
	__glibcxx_assert(get() != pointer());
	return get()[__i];
      }

      /// Return the stored pointer.
      pointer
      get() const noexcept
      { return _M_t._M_ptr(); }

      /// Return a reference to the stored deleter.
      deleter_type&amp;
      get_deleter() noexcept
      { return _M_t._M_deleter(); }

      /// Return a reference to the stored deleter.
      const deleter_type&amp;
      get_deleter() const noexcept
      { return _M_t._M_deleter(); }

      /// Return @c true if the stored pointer is not null.
      explicit operator bool() const noexcept
      { return get() == pointer() ? false : true; }

      // Modifiers.

      /// Release ownership of any stored pointer.
      pointer
      release() noexcept
      {
	pointer __p = get();
	_M_t._M_ptr() = pointer();
	return __p;
      }

      /** @brief Replace the stored pointer.
       *
       * @param __p  The new pointer to store.
       *
       * The deleter will be invoked if a pointer is already owned.
       */
      template &lt;typename _Up,
                typename = _Require&lt;
                  __or_&lt;is_same&lt;_Up, pointer&gt;,
                        __and_&lt;is_same&lt;pointer, element_type*&gt;,
                               is_pointer&lt;_Up&gt;,
                               is_convertible&lt;
                                 typename remove_pointer&lt;_Up&gt;::type(*)[],
                                 element_type(*)[]
                               &gt;
                        &gt;
                  &gt;
               &gt;&gt;
      void
      reset(_Up __p) noexcept
      {
	pointer __ptr = __p;
	using std::swap;
	swap(_M_t._M_ptr(), __ptr);
	if (__ptr != nullptr)
	  get_deleter()(__ptr);
      }

      void reset(nullptr_t = nullptr) noexcept
      {
        reset(pointer());
      }

      /// Exchange the pointer and deleter with another object.
      void
      swap(unique_ptr&amp; __u) noexcept
      {
	static_assert(__is_swappable&lt;_Dp&gt;::value, &quot;deleter must be swappable&quot;);
	_M_t.swap(__u._M_t);
      }

      // Disable copy from lvalue.
      unique_ptr(const unique_ptr&amp;) = delete;
      unique_ptr&amp; operator=(const unique_ptr&amp;) = delete;
    };

  template&lt;typename _Tp, typename _Dp&gt;
    inline
#if __cplusplus &gt; 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
    // Constrained free swap overload, see p0185r1
    typename enable_if&lt;__is_swappable&lt;_Dp&gt;::value&gt;::type
#else
    void
#endif
    swap(unique_ptr&lt;_Tp, _Dp&gt;&amp; __x,
	 unique_ptr&lt;_Tp, _Dp&gt;&amp; __y) noexcept
    { __x.swap(__y); }

#if __cplusplus &gt; 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
  template&lt;typename _Tp, typename _Dp&gt;
    typename enable_if&lt;!__is_swappable&lt;_Dp&gt;::value&gt;::type
    swap(unique_ptr&lt;_Tp, _Dp&gt;&amp;,
	 unique_ptr&lt;_Tp, _Dp&gt;&amp;) = delete;
#endif

  template&lt;typename _Tp, typename _Dp,
	   typename _Up, typename _Ep&gt;
    inline bool
    operator==(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x,
	       const unique_ptr&lt;_Up, _Ep&gt;&amp; __y)
    { return __x.get() == __y.get(); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator==(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x, nullptr_t) noexcept
    { return !__x; }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator==(nullptr_t, const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x) noexcept
    { return !__x; }

  template&lt;typename _Tp, typename _Dp,
	   typename _Up, typename _Ep&gt;
    inline bool
    operator!=(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x,
	       const unique_ptr&lt;_Up, _Ep&gt;&amp; __y)
    { return __x.get() != __y.get(); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator!=(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x, nullptr_t) noexcept
    { return (bool)__x; }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator!=(nullptr_t, const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x) noexcept
    { return (bool)__x; }

  template&lt;typename _Tp, typename _Dp,
	   typename _Up, typename _Ep&gt;
    inline bool
    operator&lt;(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x,
	      const unique_ptr&lt;_Up, _Ep&gt;&amp; __y)
    {
      typedef typename
	std::common_type&lt;typename unique_ptr&lt;_Tp, _Dp&gt;::pointer,
	                 typename unique_ptr&lt;_Up, _Ep&gt;::pointer&gt;::type _CT;
      return std::less&lt;_CT&gt;()(__x.get(), __y.get());
    }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&lt;(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x, nullptr_t)
    { return std::less&lt;typename unique_ptr&lt;_Tp, _Dp&gt;::pointer&gt;()(__x.get(),
								 nullptr); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&lt;(nullptr_t, const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x)
    { return std::less&lt;typename unique_ptr&lt;_Tp, _Dp&gt;::pointer&gt;()(nullptr,
								 __x.get()); }

  template&lt;typename _Tp, typename _Dp,
	   typename _Up, typename _Ep&gt;
    inline bool
    operator&lt;=(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x,
	       const unique_ptr&lt;_Up, _Ep&gt;&amp; __y)
    { return !(__y &lt; __x); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&lt;=(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x, nullptr_t)
    { return !(nullptr &lt; __x); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&lt;=(nullptr_t, const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x)
    { return !(__x &lt; nullptr); }

  template&lt;typename _Tp, typename _Dp,
	   typename _Up, typename _Ep&gt;
    inline bool
    operator&gt;(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x,
	      const unique_ptr&lt;_Up, _Ep&gt;&amp; __y)
    { return (__y &lt; __x); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&gt;(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x, nullptr_t)
    { return std::less&lt;typename unique_ptr&lt;_Tp, _Dp&gt;::pointer&gt;()(nullptr,
								 __x.get()); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&gt;(nullptr_t, const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x)
    { return std::less&lt;typename unique_ptr&lt;_Tp, _Dp&gt;::pointer&gt;()(__x.get(),
								 nullptr); }

  template&lt;typename _Tp, typename _Dp,
	   typename _Up, typename _Ep&gt;
    inline bool
    operator&gt;=(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x,
	       const unique_ptr&lt;_Up, _Ep&gt;&amp; __y)
    { return !(__x &lt; __y); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&gt;=(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x, nullptr_t)
    { return !(__x &lt; nullptr); }

  template&lt;typename _Tp, typename _Dp&gt;
    inline bool
    operator&gt;=(nullptr_t, const unique_ptr&lt;_Tp, _Dp&gt;&amp; __x)
    { return !(nullptr &lt; __x); }

  /// std::hash specialization for unique_ptr.
  template&lt;typename _Tp, typename _Dp&gt;
    struct hash&lt;unique_ptr&lt;_Tp, _Dp&gt;&gt;
    : public __hash_base&lt;size_t, unique_ptr&lt;_Tp, _Dp&gt;&gt;,
    private __poison_hash&lt;typename unique_ptr&lt;_Tp, _Dp&gt;::pointer&gt;
    {
      size_t
      operator()(const unique_ptr&lt;_Tp, _Dp&gt;&amp; __u) const noexcept
      {
	typedef unique_ptr&lt;_Tp, _Dp&gt; _UP;
	return std::hash&lt;typename _UP::pointer&gt;()(__u.get());
      }
    };

#if __cplusplus &gt; 201103L

#define __cpp_lib_make_unique 201304

  template&lt;typename _Tp&gt;
    struct _MakeUniq
    { typedef unique_ptr&lt;_Tp&gt; __single_object; };

  template&lt;typename _Tp&gt;
    struct _MakeUniq&lt;_Tp[]&gt;
    { typedef unique_ptr&lt;_Tp[]&gt; __array; };

  template&lt;typename _Tp, size_t _Bound&gt;
    struct _MakeUniq&lt;_Tp[_Bound]&gt;
    { struct __invalid_type { }; };

  /// std::make_unique for single objects
  template&lt;typename _Tp, typename... _Args&gt;
    inline typename _MakeUniq&lt;_Tp&gt;::__single_object
    make_unique(_Args&amp;&amp;... __args)
    { return unique_ptr&lt;_Tp&gt;(new _Tp(std::forward&lt;_Args&gt;(__args)...)); }

  /// std::make_unique for arrays of unknown bound
  template&lt;typename _Tp&gt;
    inline typename _MakeUniq&lt;_Tp&gt;::__array
    make_unique(size_t __num)
    { return unique_ptr&lt;_Tp&gt;(new remove_extent_t&lt;_Tp&gt;[__num]()); }

  /// Disable std::make_unique for arrays of known bound
  template&lt;typename _Tp, typename... _Args&gt;
    inline typename _MakeUniq&lt;_Tp&gt;::__invalid_type
    make_unique(_Args&amp;&amp;...) = delete;
#endif

  // @} group pointer_abstractions

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif /* _UNIQUE_PTR_H */
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fbits'>Back to Directory</a>