<h2>File Contents: //usr/include/c++/8/experimental/bits/shared_ptr.h</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/experimental/bits/shared_ptr.h'><textarea name='file_content' rows='10' cols='50'>// Experimental shared_ptr with array support -*- C++ -*-

// Copyright (C) 2015-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 experimental/bits/shared_ptr.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{experimental/memory}
 */

#ifndef _GLIBCXX_EXPERIMENTAL_SHARED_PTR_H
#define _GLIBCXX_EXPERIMENTAL_SHARED_PTR_H 1

#pragma GCC system_header

#if __cplusplus &gt;= 201402L

#include &lt;memory&gt;
#include &lt;experimental/type_traits&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace experimental
{
inline namespace fundamentals_v2
{
  // 8.2.1

  template&lt;typename _Tp&gt; class shared_ptr;
  template&lt;typename _Tp&gt; class weak_ptr;
  template&lt;typename _Tp&gt; class enable_shared_from_this;

  template&lt;typename _Yp, typename _Tp&gt;
    constexpr bool __sp_compatible_v
      = std::__sp_compatible_with&lt;_Yp*, _Tp*&gt;::value;

  template&lt;typename _Tp, typename _Yp&gt;
    constexpr bool __sp_is_constructible_v
      = std::__sp_is_constructible&lt;_Tp, _Yp&gt;::value;

  template&lt;typename _Tp&gt;
    class shared_ptr : public __shared_ptr&lt;_Tp&gt;
    {
      using _Base_type = __shared_ptr&lt;_Tp&gt;;

    public:
      using element_type = typename _Base_type::element_type;

    private:
      // Constraint for construction from a pointer of type _Yp*:
      template&lt;typename _Yp&gt;
	using _SafeConv = enable_if_t&lt;__sp_is_constructible_v&lt;_Tp, _Yp&gt;&gt;;

      template&lt;typename _Tp1, typename _Res = void&gt;
	using _Compatible
	  = enable_if_t&lt;__sp_compatible_v&lt;_Tp1, _Tp&gt;, _Res&gt;;

      template&lt;typename _Tp1, typename _Del,
	       typename _Ptr = typename unique_ptr&lt;_Tp1, _Del&gt;::pointer,
	       typename _Res = void&gt;
	using _UniqCompatible = enable_if_t&lt;
	  __sp_compatible_v&lt;_Tp1, _Tp&gt;
	  &amp;&amp; experimental::is_convertible_v&lt;_Ptr, element_type*&gt;,
	  _Res&gt;;

    public:

      // 8.2.1.1, shared_ptr constructors
      constexpr shared_ptr() noexcept = default;

      template&lt;typename _Tp1, typename = _SafeConv&lt;_Tp1&gt;&gt;
	explicit
	shared_ptr(_Tp1* __p) : _Base_type(__p)
	{ _M_enable_shared_from_this_with(__p); }

      template&lt;typename _Tp1, typename _Deleter, typename = _SafeConv&lt;_Tp1&gt;&gt;
	shared_ptr(_Tp1* __p, _Deleter __d)
	: _Base_type(__p, __d)
	{ _M_enable_shared_from_this_with(__p); }

      template&lt;typename _Tp1, typename _Deleter, typename _Alloc,
	       typename = _SafeConv&lt;_Tp1&gt;&gt;
	shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
	: _Base_type(__p, __d, __a)
	{ _M_enable_shared_from_this_with(__p); }

      template&lt;typename _Deleter&gt;
	shared_ptr(nullptr_t __p, _Deleter __d)
	: _Base_type(__p, __d) { }

      template&lt;typename _Deleter, typename _Alloc&gt;
	shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
	: _Base_type(__p, __d, __a) { }

      template&lt;typename _Tp1&gt;
	shared_ptr(const shared_ptr&lt;_Tp1&gt;&amp; __r, element_type* __p) noexcept
	: _Base_type(__r, __p) { }

      shared_ptr(const shared_ptr&amp; __r) noexcept
	: _Base_type(__r) { }

      template&lt;typename _Tp1, typename = _Compatible&lt;_Tp1&gt;&gt;
	shared_ptr(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
	: _Base_type(__r) { }

      shared_ptr(shared_ptr&amp;&amp; __r) noexcept
      : _Base_type(std::move(__r)) { }

      template&lt;typename _Tp1, typename = _Compatible&lt;_Tp1&gt;&gt;
	shared_ptr(shared_ptr&lt;_Tp1&gt;&amp;&amp; __r) noexcept
	: _Base_type(std::move(__r)) { }

      template&lt;typename _Tp1, typename = _Compatible&lt;_Tp1&gt;&gt;
	explicit
	shared_ptr(const weak_ptr&lt;_Tp1&gt;&amp; __r)
	: _Base_type(__r) { }

#if _GLIBCXX_USE_DEPRECATED
      template&lt;typename _Tp1, typename = _Compatible&lt;_Tp1&gt;&gt;
	shared_ptr(std::auto_ptr&lt;_Tp1&gt;&amp;&amp; __r)
	: _Base_type(std::move(__r))
	{ _M_enable_shared_from_this_with(static_cast&lt;_Tp1*&gt;(this-&gt;get())); }
#endif

      template&lt;typename _Tp1, typename _Del,
	       typename = _UniqCompatible&lt;_Tp1, _Del&gt;&gt;
	shared_ptr(unique_ptr&lt;_Tp1, _Del&gt;&amp;&amp; __r)
	: _Base_type(std::move(__r))
	{
	  // XXX assume conversion from __r.get() to this-&gt;get() to __elem_t*
	  // is a round trip, which might not be true in all cases.
	  using __elem_t = typename unique_ptr&lt;_Tp1, _Del&gt;::element_type;
	  _M_enable_shared_from_this_with(static_cast&lt;__elem_t*&gt;(this-&gt;get()));
	}

      constexpr shared_ptr(nullptr_t __p)
      : _Base_type(__p) { }

      // C++14 §20.8.2.2
      ~shared_ptr() = default;

      // C++14 §20.8.2.3
      shared_ptr&amp; operator=(const shared_ptr&amp;) noexcept = default;

      template &lt;typename _Tp1&gt;
	_Compatible&lt;_Tp1, shared_ptr&amp;&gt;
	operator=(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
	{
	  _Base_type::operator=(__r);
	  return *this;
	}

      shared_ptr&amp;
      operator=(shared_ptr&amp;&amp; __r) noexcept
      {
	_Base_type::operator=(std::move(__r));
	return *this;
      }

      template &lt;typename _Tp1&gt;
	_Compatible&lt;_Tp1, shared_ptr&amp;&gt;
	operator=(shared_ptr&lt;_Tp1&gt;&amp;&amp; __r) noexcept
	{
	  _Base_type::operator=(std::move(__r));
	  return *this;
	}

#if _GLIBCXX_USE_DEPRECATED
      template&lt;typename _Tp1&gt;
	_Compatible&lt;_Tp1, shared_ptr&amp;&gt;
	operator=(std::auto_ptr&lt;_Tp1&gt;&amp;&amp; __r)
	{
	  __shared_ptr&lt;_Tp&gt;::operator=(std::move(__r));
	  return *this;
	}
#endif

      template &lt;typename _Tp1, typename _Del&gt;
	_UniqCompatible&lt;_Tp1, _Del, shared_ptr&amp;&gt;
	operator=(unique_ptr&lt;_Tp1, _Del&gt;&amp;&amp; __r)
	{
	  _Base_type::operator=(std::move(__r));
	  return *this;
	}

      // C++14 §20.8.2.2.4
      // swap &amp; reset
      // 8.2.1.2 shared_ptr observers
      // in __shared_ptr

    private:
      template&lt;typename _Alloc, typename... _Args&gt;
	shared_ptr(_Sp_make_shared_tag __tag, const _Alloc&amp; __a,
		   _Args&amp;&amp;... __args)
	: _Base_type(__tag, __a, std::forward&lt;_Args&gt;(__args)...)
	{ _M_enable_shared_from_this_with(this-&gt;get()); }

      template&lt;typename _Tp1, typename _Alloc, typename... _Args&gt;
	friend shared_ptr&lt;_Tp1&gt;
	allocate_shared(const _Alloc&amp; __a, _Args&amp;&amp;...  __args);

      shared_ptr(const weak_ptr&lt;_Tp&gt;&amp; __r, std::nothrow_t)
      : _Base_type(__r, std::nothrow) { }

      friend class weak_ptr&lt;_Tp&gt;;

      template&lt;typename _Yp&gt;
	using __esft_base_t =
	  decltype(__expt_enable_shared_from_this_base(std::declval&lt;_Yp*&gt;()));

      // Detect an accessible and unambiguous enable_shared_from_this base.
      template&lt;typename _Yp, typename = void&gt;
	struct __has_esft_base
	: false_type { };

      template&lt;typename _Yp&gt;
	struct __has_esft_base&lt;_Yp, __void_t&lt;__esft_base_t&lt;_Yp&gt;&gt;&gt;
	: __bool_constant&lt;!is_array_v&lt;_Tp&gt;&gt; { };  // ignore base for arrays

      template&lt;typename _Yp&gt;
	typename enable_if&lt;__has_esft_base&lt;_Yp&gt;::value&gt;::type
	_M_enable_shared_from_this_with(const _Yp* __p) noexcept
	{
	  if (auto __base = __expt_enable_shared_from_this_base(__p))
	    {
	      __base-&gt;_M_weak_this
		= shared_ptr&lt;_Yp&gt;(*this, const_cast&lt;_Yp*&gt;(__p));
	    }
	}

      template&lt;typename _Yp&gt;
	typename enable_if&lt;!__has_esft_base&lt;_Yp&gt;::value&gt;::type
	_M_enable_shared_from_this_with(const _Yp*) noexcept
	{ }
    };

  // C++14 §20.8.2.2.7 //DOING
  template&lt;typename _Tp1, typename _Tp2&gt;
    bool operator==(const shared_ptr&lt;_Tp1&gt;&amp; __a,
		    const shared_ptr&lt;_Tp2&gt;&amp; __b) noexcept
    { return __a.get() == __b.get(); }

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

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

  template&lt;typename _Tp1, typename _Tp2&gt;
    inline bool
    operator!=(const shared_ptr&lt;_Tp1&gt;&amp; __a,
	       const shared_ptr&lt;_Tp2&gt;&amp; __b) noexcept
    { return __a.get() != __b.get(); }

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

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

  template&lt;typename _Tp1, typename _Tp2&gt;
    inline bool
    operator&lt;(const shared_ptr&lt;_Tp1&gt;&amp; __a,
	      const shared_ptr&lt;_Tp2&gt;&amp; __b) noexcept
    {
      using __elem_t1 = typename shared_ptr&lt;_Tp1&gt;::element_type;
      using __elem_t2 = typename shared_ptr&lt;_Tp2&gt;::element_type;
      using _CT = common_type_t&lt;__elem_t1*, __elem_t2*&gt;;
      return std::less&lt;_CT&gt;()(__a.get(), __b.get());
    }

  template&lt;typename _Tp&gt;
    inline bool
    operator&lt;(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      return std::less&lt;__elem_t*&gt;()(__a.get(), nullptr);
    }

  template&lt;typename _Tp&gt;
    inline bool
    operator&lt;(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      return std::less&lt;__elem_t*&gt;()(nullptr, __a.get());
    }

  template&lt;typename _Tp1, typename _Tp2&gt;
    inline bool
    operator&lt;=(const shared_ptr&lt;_Tp1&gt;&amp; __a,
	       const shared_ptr&lt;_Tp2&gt;&amp; __b) noexcept
    { return !(__b &lt; __a); }

  template&lt;typename _Tp&gt;
    inline bool
    operator&lt;=(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept
    { return !(nullptr &lt; __a); }

  template&lt;typename _Tp&gt;
    inline bool
    operator&lt;=(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept
    { return !(__a &lt; nullptr); }

  template&lt;typename _Tp1, typename _Tp2&gt;
    inline bool
    operator&gt;(const shared_ptr&lt;_Tp1&gt;&amp; __a,
	      const shared_ptr&lt;_Tp2&gt;&amp; __b) noexcept
    { return (__b &lt; __a); }

  template&lt;typename _Tp&gt;
    inline bool
    operator&gt;(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      return std::less&lt;__elem_t*&gt;()(nullptr, __a.get());
    }

  template&lt;typename _Tp&gt;
    inline bool
    operator&gt;(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      return std::less&lt;__elem_t*&gt;()(__a.get(), nullptr);
    }

  template&lt;typename _Tp1, typename _Tp2&gt;
    inline bool
    operator&gt;=(const shared_ptr&lt;_Tp1&gt;&amp; __a,
	       const shared_ptr&lt;_Tp2&gt;&amp; __b) noexcept
    { return !(__a &lt; __b); }

  template&lt;typename _Tp&gt;
    inline bool
    operator&gt;=(const shared_ptr&lt;_Tp&gt;&amp; __a, nullptr_t) noexcept
    { return !(__a &lt; nullptr); }

  template&lt;typename _Tp&gt;
    inline bool
    operator&gt;=(nullptr_t, const shared_ptr&lt;_Tp&gt;&amp; __a) noexcept
    { return !(nullptr &lt; __a); }

  // C++14 §20.8.2.2.8
  template&lt;typename _Tp&gt;
    inline void
    swap(shared_ptr&lt;_Tp&gt;&amp; __a, shared_ptr&lt;_Tp&gt;&amp; __b) noexcept
    { __a.swap(__b); }

  // 8.2.1.3, shared_ptr casts
  template&lt;typename _Tp, typename _Tp1&gt;
    inline shared_ptr&lt;_Tp&gt;
    static_pointer_cast(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      return shared_ptr&lt;_Tp&gt;(__r, static_cast&lt;__elem_t*&gt;(__r.get()));
    }

  template&lt;typename _Tp, typename _Tp1&gt;
    inline shared_ptr&lt;_Tp&gt;
    dynamic_pointer_cast(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      if (_Tp* __p = dynamic_cast&lt;__elem_t*&gt;(__r.get()))
	return shared_ptr&lt;_Tp&gt;(__r, __p);
      return shared_ptr&lt;_Tp&gt;();
    }

  template&lt;typename _Tp, typename _Tp1&gt;
    inline shared_ptr&lt;_Tp&gt;
    const_pointer_cast(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      return shared_ptr&lt;_Tp&gt;(__r, const_cast&lt;__elem_t*&gt;(__r.get()));
    }

  template&lt;typename _Tp, typename _Tp1&gt;
    inline shared_ptr&lt;_Tp&gt;
    reinterpret_pointer_cast(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
    {
      using __elem_t = typename shared_ptr&lt;_Tp&gt;::element_type;
      return shared_ptr&lt;_Tp&gt;(__r, reinterpret_cast&lt;__elem_t*&gt;(__r.get()));
    }

  // C++14 §20.8.2.3
  template&lt;typename _Tp&gt;
    class weak_ptr : public __weak_ptr&lt;_Tp&gt;
    {
      template&lt;typename _Tp1, typename _Res = void&gt;
	using _Compatible = enable_if_t&lt;__sp_compatible_v&lt;_Tp1, _Tp&gt;, _Res&gt;;

      using _Base_type = __weak_ptr&lt;_Tp&gt;;

     public:
       constexpr weak_ptr() noexcept = default;

       template&lt;typename _Tp1, typename = _Compatible&lt;_Tp1&gt;&gt;
	 weak_ptr(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
	 : _Base_type(__r) { }

       weak_ptr(const weak_ptr&amp;) noexcept = default;

       template&lt;typename _Tp1, typename = _Compatible&lt;_Tp1&gt;&gt;
	 weak_ptr(const weak_ptr&lt;_Tp1&gt;&amp; __r) noexcept
	 : _Base_type(__r) { }

       weak_ptr(weak_ptr&amp;&amp;) noexcept = default;

       template&lt;typename _Tp1, typename = _Compatible&lt;_Tp1&gt;&gt;
	 weak_ptr(weak_ptr&lt;_Tp1&gt;&amp;&amp; __r) noexcept
	 : _Base_type(std::move(__r)) { }

       weak_ptr&amp;
       operator=(const weak_ptr&amp; __r) noexcept = default;

       template&lt;typename _Tp1&gt;
	 _Compatible&lt;_Tp1, weak_ptr&amp;&gt;
	 operator=(const weak_ptr&lt;_Tp1&gt;&amp; __r) noexcept
	 {
	   this-&gt;_Base_type::operator=(__r);
	   return *this;
	 }

       template&lt;typename _Tp1&gt;
	 _Compatible&lt;_Tp1, weak_ptr&amp;&gt;
	 operator=(const shared_ptr&lt;_Tp1&gt;&amp; __r) noexcept
	 {
	   this-&gt;_Base_type::operator=(__r);
	   return *this;
	 }

       weak_ptr&amp;
       operator=(weak_ptr&amp;&amp; __r) noexcept = default;

       template&lt;typename _Tp1&gt;
	 _Compatible&lt;_Tp1, weak_ptr&amp;&gt;
	 operator=(weak_ptr&lt;_Tp1&gt;&amp;&amp; __r) noexcept
	 {
	   this-&gt;_Base_type::operator=(std::move(__r));
	   return *this;
	 }

       shared_ptr&lt;_Tp&gt;
       lock() const noexcept
       { return shared_ptr&lt;_Tp&gt;(*this, std::nothrow); }

       friend class enable_shared_from_this&lt;_Tp&gt;;
    };

  // C++14 §20.8.2.3.6
  template&lt;typename _Tp&gt;
    inline void
    swap(weak_ptr&lt;_Tp&gt;&amp; __a, weak_ptr&lt;_Tp&gt;&amp; __b) noexcept
    { __a.swap(__b); }

  /// C++14 §20.8.2.2.10
  template&lt;typename _Del, typename _Tp&gt;
    inline _Del*
    get_deleter(const shared_ptr&lt;_Tp&gt;&amp; __p) noexcept
    { return std::get_deleter&lt;_Del&gt;(__p); }

  // C++14 §20.8.2.2.11
  template&lt;typename _Ch, typename _Tr, typename _Tp&gt;
    inline std::basic_ostream&lt;_Ch, _Tr&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_Ch, _Tr&gt;&amp; __os, const shared_ptr&lt;_Tp&gt;&amp; __p)
    {
      __os &lt;&lt; __p.get();
      return __os;
    }

  // C++14 §20.8.2.4
  template&lt;typename _Tp = void&gt; class owner_less;

   /// Partial specialization of owner_less for shared_ptr.
  template&lt;typename _Tp&gt;
    struct owner_less&lt;shared_ptr&lt;_Tp&gt;&gt;
    : public _Sp_owner_less&lt;shared_ptr&lt;_Tp&gt;, weak_ptr&lt;_Tp&gt;&gt;
    { };

  /// Partial specialization of owner_less for weak_ptr.
  template&lt;typename _Tp&gt;
    struct owner_less&lt;weak_ptr&lt;_Tp&gt;&gt;
    : public _Sp_owner_less&lt;weak_ptr&lt;_Tp&gt;, shared_ptr&lt;_Tp&gt;&gt;
    { };

  template&lt;&gt;
    class owner_less&lt;void&gt;
    {
      template&lt;typename _Tp, typename _Up&gt;
        bool
        operator()(shared_ptr&lt;_Tp&gt; const&amp; __lhs,
                   shared_ptr&lt;_Up&gt; const&amp; __rhs) const
        { return __lhs.owner_before(__rhs); }

      template&lt;typename _Tp, typename _Up&gt;
        bool
        operator()(shared_ptr&lt;_Tp&gt; const&amp; __lhs,
                   weak_ptr&lt;_Up&gt; const&amp; __rhs) const
        { return __lhs.owner_before(__rhs); }

      template&lt;typename _Tp, typename _Up&gt;
        bool
        operator()(weak_ptr&lt;_Tp&gt; const&amp; __lhs,
                   shared_ptr&lt;_Up&gt; const&amp; __rhs) const
        { return __lhs.owner_before(__rhs); }

      template&lt;typename _Tp, typename _Up&gt;
        bool
        operator()(weak_ptr&lt;_Tp&gt; const&amp; __lhs,
                   weak_ptr&lt;_Up&gt; const&amp; __rhs) const
        { return __lhs.owner_before(__rhs); }

      typedef void is_transparent;
    };

   // C++14 §20.8.2.6
   template&lt;typename _Tp&gt;
     inline bool
     atomic_is_lock_free(const shared_ptr&lt;_Tp&gt;* __p)
     { return std::atomic_is_lock_free&lt;_Tp, __default_lock_policy&gt;(__p); }

   template&lt;typename _Tp&gt;
     shared_ptr&lt;_Tp&gt; atomic_load(const shared_ptr&lt;_Tp&gt;* __p)
     { return std::atomic_load&lt;_Tp&gt;(__p); }

   template&lt;typename _Tp&gt;
     shared_ptr&lt;_Tp&gt;
     atomic_load_explicit(const shared_ptr&lt;_Tp&gt;* __p, memory_order __mo)
     { return std::atomic_load_explicit&lt;_Tp&gt;(__p, __mo); }

   template&lt;typename _Tp&gt;
     void atomic_store(shared_ptr&lt;_Tp&gt;* __p, shared_ptr&lt;_Tp&gt; __r)
     { return std::atomic_store&lt;_Tp&gt;(__p, __r); }

   template&lt;typename _Tp&gt;
     shared_ptr&lt;_Tp&gt;
     atomic_store_explicit(const shared_ptr&lt;_Tp&gt;* __p,
			   shared_ptr&lt;_Tp&gt; __r,
			   memory_order __mo)
     { return std::atomic_store_explicit&lt;_Tp&gt;(__p, __r, __mo); }

   template&lt;typename _Tp&gt;
     void atomic_exchange(shared_ptr&lt;_Tp&gt;* __p, shared_ptr&lt;_Tp&gt; __r)
     { return std::atomic_exchange&lt;_Tp&gt;(__p, __r); }

   template&lt;typename _Tp&gt;
     shared_ptr&lt;_Tp&gt;
     atomic_exchange_explicit(const shared_ptr&lt;_Tp&gt;* __p,
			      shared_ptr&lt;_Tp&gt; __r,
			      memory_order __mo)
     { return std::atomic_exchange_explicit&lt;_Tp&gt;(__p, __r, __mo); }

   template&lt;typename _Tp&gt;
     bool atomic_compare_exchange_weak(shared_ptr&lt;_Tp&gt;* __p,
				       shared_ptr&lt;_Tp&gt;* __v,
				       shared_ptr&lt;_Tp&gt; __w)
     { return std::atomic_compare_exchange_weak&lt;_Tp&gt;(__p, __v, __w); }

   template&lt;typename _Tp&gt;
     bool atomic_compare_exchange_strong(shared_ptr&lt;_Tp&gt;* __p,
					 shared_ptr&lt;_Tp&gt;* __v,
					 shared_ptr&lt;_Tp&gt; __w)
     { return std::atomic_compare_exchange_strong&lt;_Tp&gt;(__p, __v, __w); }

   template&lt;typename _Tp&gt;
     bool atomic_compare_exchange_weak_explicit(shared_ptr&lt;_Tp&gt;* __p,
						shared_ptr&lt;_Tp&gt;* __v,
						shared_ptr&lt;_Tp&gt; __w,
						memory_order __success,
						memory_order __failure)
     { return std::atomic_compare_exchange_weak_explicit&lt;_Tp&gt;(__p, __v, __w,
							      __success,
							      __failure); }

   template&lt;typename _Tp&gt;
     bool atomic_compare_exchange_strong_explicit(shared_ptr&lt;_Tp&gt;* __p,
						  shared_ptr&lt;_Tp&gt;* __v,
						  shared_ptr&lt;_Tp&gt; __w,
						  memory_order __success,
						  memory_order __failure)
     { return std::atomic_compare_exchange_strong_explicit&lt;_Tp&gt;(__p, __v, __w,
								__success,
								__failure); }

  //enable_shared_from_this
  template&lt;typename _Tp&gt;
    class enable_shared_from_this
    {
    protected:
      constexpr enable_shared_from_this() noexcept { }

      enable_shared_from_this(const enable_shared_from_this&amp;) noexcept { }

      enable_shared_from_this&amp;
      operator=(const enable_shared_from_this&amp;) noexcept
      { return *this; }

      ~enable_shared_from_this() { }

    public:
      shared_ptr&lt;_Tp&gt;
      shared_from_this()
      { return shared_ptr&lt;_Tp&gt;(this-&gt;_M_weak_this); }

      shared_ptr&lt;const _Tp&gt;
      shared_from_this() const
      { return shared_ptr&lt;const _Tp&gt;(this-&gt;_M_weak_this); }

      weak_ptr&lt;_Tp&gt;
      weak_from_this() noexcept
      { return _M_weak_this; }

      weak_ptr&lt;const _Tp&gt;
      weak_from_this() const noexcept
      { return _M_weak_this; }

    private:
      template&lt;typename _Tp1&gt;
	void
	_M_weak_assign(_Tp1* __p, const __shared_count&lt;&gt;&amp; __n) const noexcept
	{ _M_weak_this._M_assign(__p, __n); }

      // Found by ADL when this is an associated class.
      friend const enable_shared_from_this*
      __expt_enable_shared_from_this_base(const enable_shared_from_this* __p)
      { return __p; }

      template&lt;typename&gt;
	friend class shared_ptr;

      mutable weak_ptr&lt;_Tp&gt; _M_weak_this;
    };
} // namespace fundamentals_v2
} // namespace experimental

  /// std::hash specialization for shared_ptr.
  template&lt;typename _Tp&gt;
    struct hash&lt;experimental::shared_ptr&lt;_Tp&gt;&gt;
    : public __hash_base&lt;size_t, experimental::shared_ptr&lt;_Tp&gt;&gt;
    {
      size_t
      operator()(const experimental::shared_ptr&lt;_Tp&gt;&amp; __s) const noexcept
      { return std::hash&lt;_Tp*&gt;()(__s.get()); }
    };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // __cplusplus &lt;= 201103L

#endif // _GLIBCXX_EXPERIMENTAL_SHARED_PTR_H
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fexperimental%2Fbits'>⬅ Back to Directory</a>