// unique_ptr implementation -*- C++ -*-
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008-2014 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
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
-/** @file unique_ptr.h
+/** @file bits/unique_ptr.h
* This is an internal header file, included by other library headers.
- * You should not attempt to use it directly.
+ * Do not attempt to use it directly. @headername{memory}
*/
#ifndef _UNIQUE_PTR_H
#define _UNIQUE_PTR_H 1
-#ifndef __GXX_EXPERIMENTAL_CXX0X__
-# include <c++0x_warning.h>
-#endif
-
#include <bits/c++config.h>
#include <debug/debug.h>
#include <type_traits>
#include <utility>
#include <tuple>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup pointer_abstractions
* @{
*/
- /// Primary template, default_delete.
- template<typename _Tp>
+#if _GLIBCXX_USE_DEPRECATED
+ template<typename> class auto_ptr;
+#endif
+
+ /// Primary template of default_delete, used by unique_ptr
+ template<typename _Tp>
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<typename _Up, typename = typename
+ enable_if<is_convertible<_Up*, _Tp*>::value>::type>
+ default_delete(const default_delete<_Up>&) noexcept { }
+
+ /// Calls @c delete @p __ptr
+ void
+ operator()(_Tp* __ptr) const
{
- default_delete() { }
-
- template<typename _Up>
- default_delete(const default_delete<_Up>&) { }
-
- void
- operator()(_Tp* __ptr) const
- {
- static_assert(sizeof(_Tp)>0,
- "can't delete pointer to incomplete type");
- delete __ptr;
- }
+ static_assert(!is_void<_Tp>::value,
+ "can't delete pointer to incomplete type");
+ static_assert(sizeof(_Tp)>0,
+ "can't delete pointer to incomplete type");
+ delete __ptr;
+ }
};
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
- /// Specialization, default_delete.
- template<typename _Tp>
+ /// Specialization for arrays, default_delete.
+ template<typename _Tp>
struct default_delete<_Tp[]>
{
+ private:
+ template<typename _Up>
+ using __remove_cv = typename remove_cv<_Up>::type;
+
+ // Like is_base_of<_Tp, _Up> but false if unqualified types are the same
+ template<typename _Up>
+ using __is_derived_Tp
+ = __and_< is_base_of<_Tp, _Up>,
+ __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+ 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<typename _Up, typename = typename
+ enable_if<!__is_derived_Tp<_Up>::value>::type>
+ default_delete(const default_delete<_Up[]>&) noexcept { }
+
+ /// Calls @c delete[] @p __ptr
void
operator()(_Tp* __ptr) const
{
"can't delete pointer to incomplete type");
delete [] __ptr;
}
+
+ template<typename _Up>
+ typename enable_if<__is_derived_Tp<_Up>::value>::type
+ operator()(_Up*) const = delete;
};
- /// 20.7.12.2 unique_ptr for single objects.
- template <typename _Tp, typename _Tp_Deleter = default_delete<_Tp> >
+ /// 20.7.1.2 unique_ptr for single objects.
+ template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
- typedef std::tuple<_Tp*, _Tp_Deleter> __tuple_type;
- typedef _Tp* unique_ptr::* __unspecified_pointer_type;
+ // use SFINAE to determine whether _Del::pointer exists
+ class _Pointer
+ {
+ template<typename _Up>
+ static typename _Up::pointer __test(typename _Up::pointer*);
+
+ template<typename _Up>
+ static _Tp* __test(...);
+
+ typedef typename remove_reference<_Dp>::type _Del;
+
+ public:
+ typedef decltype(__test<_Del>(0)) type;
+ };
+
+ typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
+ __tuple_type _M_t;
public:
- typedef _Tp* pointer;
- typedef _Tp element_type;
- typedef _Tp_Deleter deleter_type;
+ typedef typename _Pointer::type pointer;
+ typedef _Tp element_type;
+ typedef _Dp deleter_type;
// Constructors.
- unique_ptr()
- : _M_t(pointer(), deleter_type())
- { static_assert(!std::is_pointer<deleter_type>::value,
- "constructed with null function pointer deleter"); }
+ /// Default constructor, creates a unique_ptr that owns nothing.
+ constexpr unique_ptr() noexcept
+ : _M_t()
+ { static_assert(!is_pointer<deleter_type>::value,
+ "constructed with null function pointer deleter"); }
+
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an object of @c element_type
+ *
+ * The deleter will be value-initialized.
+ */
explicit
- unique_ptr(pointer __p)
+ unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
- { static_assert(!std::is_pointer<deleter_type>::value,
+ { static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
+ /** 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 std::conditional<std::is_reference<deleter_type>::value,
- deleter_type, const deleter_type&>::type __d)
+ typename conditional<is_reference<deleter_type>::value,
+ deleter_type, const deleter_type&>::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 std::remove_reference<deleter_type>::type&& __d)
+ typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
- { static_assert(!std::is_reference<deleter_type>::value,
+ { static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
+ /// Creates a unique_ptr that owns nothing.
+ constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
+
// Move constructors.
- unique_ptr(unique_ptr&& __u)
+
+ /// Move constructor.
+ unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
- template<typename _Up, typename _Up_Deleter>
- unique_ptr(unique_ptr<_Up, _Up_Deleter>&& __u)
- : _M_t(__u.release(), std::forward<deleter_type>(__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<typename _Up, typename _Ep, typename = _Require<
+ is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+ __not_<is_array<_Up>>,
+ typename conditional<is_reference<_Dp>::value,
+ is_same<_Ep, _Dp>,
+ is_convertible<_Ep, _Dp>>::type>>
+ unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
- // Destructor.
- ~unique_ptr() { reset(); }
-
+#if _GLIBCXX_USE_DEPRECATED
+ /// Converting constructor from @c auto_ptr
+ template<typename _Up, typename = _Require<
+ is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
+ unique_ptr(auto_ptr<_Up>&& __u) noexcept;
+#endif
+
+ /// Destructor, invokes the deleter if the stored pointer is not null.
+ ~unique_ptr() noexcept
+ {
+ auto& __ptr = std::get<0>(_M_t);
+ 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&
- operator=(unique_ptr&& __u)
- {
- reset(__u.release());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
+ operator=(unique_ptr&& __u) noexcept
+ {
+ reset(__u.release());
+ get_deleter() = std::forward<deleter_type>(__u.get_deleter());
+ return *this;
}
- template<typename _Up, typename _Up_Deleter>
- unique_ptr&
- operator=(unique_ptr<_Up, _Up_Deleter>&& __u)
+ /** @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<typename _Up, typename _Ep>
+ typename enable_if< __and_<
+ is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+ __not_<is_array<_Up>>
+ >::value,
+ unique_ptr&>::type
+ operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
- reset(__u.release());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
- }
+ reset(__u.release());
+ get_deleter() = std::forward<_Ep>(__u.get_deleter());
+ return *this;
+ }
+ /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
unique_ptr&
- operator=(__unspecified_pointer_type)
+ operator=(nullptr_t) noexcept
{
reset();
return *this;
}
// Observers.
- typename std::add_lvalue_reference<element_type>::type operator*() const
+
+ /// Dereference the stored pointer.
+ typename add_lvalue_reference<element_type>::type
+ operator*() const
{
- _GLIBCXX_DEBUG_ASSERT(get() != 0);
+ _GLIBCXX_DEBUG_ASSERT(get() != pointer());
return *get();
}
+ /// Return the stored pointer.
pointer
- operator->() const
+ operator->() const noexcept
{
- _GLIBCXX_DEBUG_ASSERT(get() != 0);
+ _GLIBCXX_DEBUG_ASSERT(get() != pointer());
return get();
}
+ /// Return the stored pointer.
pointer
- get() const
+ get() const noexcept
{ return std::get<0>(_M_t); }
- typename std::add_lvalue_reference<deleter_type>::type
- get_deleter()
+ /// Return a reference to the stored deleter.
+ deleter_type&
+ get_deleter() noexcept
{ return std::get<1>(_M_t); }
- typename std::add_lvalue_reference<
- typename std::add_const<deleter_type>::type
- >::type
- get_deleter() const
+ /// Return a reference to the stored deleter.
+ const deleter_type&
+ get_deleter() const noexcept
{ return std::get<1>(_M_t); }
- explicit operator bool() const
- { return get() == 0 ? false : true; }
+ /// 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()
+ release() noexcept
{
pointer __p = get();
- std::get<0>(_M_t) = 0;
+ std::get<0>(_M_t) = 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())
+ reset(pointer __p = pointer()) noexcept
{
- if (__p != get())
- {
- get_deleter()(get());
- std::get<0>(_M_t) = __p;
- }
+ using std::swap;
+ swap(std::get<0>(_M_t), __p);
+ if (__p != pointer())
+ get_deleter()(__p);
}
+ /// Exchange the pointer and deleter with another object.
void
- swap(unique_ptr& __u)
+ swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
// Disable copy from lvalue.
unique_ptr(const unique_ptr&) = delete;
-
- template<typename _Up, typename _Up_Deleter>
- unique_ptr(const unique_ptr<_Up, _Up_Deleter>&) = delete;
-
unique_ptr& operator=(const unique_ptr&) = delete;
-
- template<typename _Up, typename _Up_Deleter>
- unique_ptr& operator=(const unique_ptr<_Up, _Up_Deleter>&) = delete;
-
- private:
- __tuple_type _M_t;
};
-
- /// 20.7.12.3 unique_ptr for array objects with a runtime length
+
+ /// 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<typename _Tp, typename _Tp_Deleter>
- class unique_ptr<_Tp[], _Tp_Deleter>
+ template<typename _Tp, typename _Dp>
+ class unique_ptr<_Tp[], _Dp>
{
- typedef std::tuple<_Tp*, _Tp_Deleter> __tuple_type;
- typedef _Tp* unique_ptr::* __unspecified_pointer_type;
+ // use SFINAE to determine whether _Del::pointer exists
+ class _Pointer
+ {
+ template<typename _Up>
+ static typename _Up::pointer __test(typename _Up::pointer*);
+
+ template<typename _Up>
+ static _Tp* __test(...);
+
+ typedef typename remove_reference<_Dp>::type _Del;
+
+ public:
+ typedef decltype(__test<_Del>(0)) type;
+ };
+
+ typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
+ __tuple_type _M_t;
+
+ template<typename _Up>
+ using __remove_cv = typename remove_cv<_Up>::type;
+
+ // like is_base_of<_Tp, _Up> but false if unqualified types are the same
+ template<typename _Up>
+ using __is_derived_Tp
+ = __and_< is_base_of<_Tp, _Up>,
+ __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+ template<typename _Up, typename _Ep,
+ typename _Tp_pointer = typename _Pointer::type,
+ typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
+ using __safe_conversion = __and_<
+ is_convertible<_Up_pointer, _Tp_pointer>,
+ is_array<_Up>,
+ __or_<__not_<is_pointer<_Up_pointer>>,
+ __not_<is_pointer<_Tp_pointer>>,
+ __not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
+ >
+ >;
public:
- typedef _Tp* pointer;
- typedef _Tp element_type;
- typedef _Tp_Deleter deleter_type;
+ typedef typename _Pointer::type pointer;
+ typedef _Tp element_type;
+ typedef _Dp deleter_type;
// Constructors.
- unique_ptr()
- : _M_t(pointer(), deleter_type())
+
+ /// Default constructor, creates a unique_ptr that owns nothing.
+ constexpr unique_ptr() noexcept
+ : _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an array of @c element_type
+ *
+ * The deleter will be value-initialized.
+ */
explicit
- unique_ptr(pointer __p)
+ unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
- { static_assert(!std::is_pointer<deleter_type>::value,
+ { static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
+ // Disable construction from convertible pointer types.
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ explicit
+ unique_ptr(_Up* __p) = delete;
+
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an array of @c element_type
+ * @param __d A reference to a deleter.
+ *
+ * The deleter will be initialized with @p __d
+ */
unique_ptr(pointer __p,
- typename std::conditional<std::is_reference<deleter_type>::value,
- deleter_type, const deleter_type&>::type __d)
+ typename conditional<is_reference<deleter_type>::value,
+ deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
- unique_ptr(pointer __p,
- typename std::remove_reference<deleter_type>::type && __d)
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an array of @c element_type
+ * @param __d A reference to a deleter.
+ *
+ * The deleter will be initialized with @p std::move(__d)
+ */
+ unique_ptr(pointer __p, typename
+ remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
- { static_assert(!std::is_reference<deleter_type>::value,
+ { static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
- // Move constructors.
- unique_ptr(unique_ptr&& __u)
+ /// Move constructor.
+ unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
- template<typename _Up, typename _Up_Deleter>
- unique_ptr(unique_ptr<_Up, _Up_Deleter>&& __u)
- : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter()))
+ /// Creates a unique_ptr that owns nothing.
+ constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
+
+ template<typename _Up, typename _Ep,
+ typename = _Require<__safe_conversion<_Up, _Ep>,
+ typename conditional<is_reference<_Dp>::value,
+ is_same<_Ep, _Dp>,
+ is_convertible<_Ep, _Dp>>::type
+ >>
+ unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
- // Destructor.
- ~unique_ptr() { reset(); }
+ /// Destructor, invokes the deleter if the stored pointer is not null.
+ ~unique_ptr()
+ {
+ auto& __ptr = std::get<0>(_M_t);
+ 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&
- operator=(unique_ptr&& __u)
+ operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
+ get_deleter() = std::forward<deleter_type>(__u.get_deleter());
+ return *this;
}
- template<typename _Up, typename _Up_Deleter>
- unique_ptr&
- operator=(unique_ptr<_Up, _Up_Deleter>&& __u)
+ /** @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<typename _Up, typename _Ep>
+ typename
+ enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
+ operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
- reset(__u.release());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
- }
+ reset(__u.release());
+ get_deleter() = std::forward<_Ep>(__u.get_deleter());
+ return *this;
+ }
+ /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
unique_ptr&
- operator=(__unspecified_pointer_type)
+ operator=(nullptr_t) noexcept
{
reset();
return *this;
}
// Observers.
- typename std::add_lvalue_reference<element_type>::type
- operator[](size_t __i) const
+
+ /// Access an element of owned array.
+ typename std::add_lvalue_reference<element_type>::type
+ operator[](size_t __i) const
{
- _GLIBCXX_DEBUG_ASSERT(get() != 0);
+ _GLIBCXX_DEBUG_ASSERT(get() != pointer());
return get()[__i];
}
+ /// Return the stored pointer.
pointer
- get() const
+ get() const noexcept
{ return std::get<0>(_M_t); }
- typename std::add_lvalue_reference<deleter_type>::type
- get_deleter()
+ /// Return a reference to the stored deleter.
+ deleter_type&
+ get_deleter() noexcept
{ return std::get<1>(_M_t); }
- typename std::add_lvalue_reference<
- typename std::add_const<deleter_type>::type
- >::type
- get_deleter() const
- { return std::get<1>(_M_t); }
+ /// Return a reference to the stored deleter.
+ const deleter_type&
+ get_deleter() const noexcept
+ { return std::get<1>(_M_t); }
+
+ /// Return @c true if the stored pointer is not null.
+ explicit operator bool() const noexcept
+ { return get() == pointer() ? false : true; }
- explicit operator bool() const
- { return get() == 0 ? false : true; }
-
// Modifiers.
+
+ /// Release ownership of any stored pointer.
pointer
- release()
+ release() noexcept
{
pointer __p = get();
- std::get<0>(_M_t) = 0;
+ std::get<0>(_M_t) = 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())
+ reset(pointer __p = pointer()) noexcept
{
- if (__p != get())
- {
- get_deleter()(get());
- std::get<0>(_M_t) = __p;
- }
+ using std::swap;
+ swap(std::get<0>(_M_t), __p);
+ if (__p != nullptr)
+ get_deleter()(__p);
}
- // DR 821.
- template<typename _Up>
- void reset(_Up) = delete;
+ // Disable resetting from convertible pointer types.
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ void reset(_Up*) = delete;
+ /// Exchange the pointer and deleter with another object.
void
- swap(unique_ptr& __u)
+ swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
unique_ptr& operator=(const unique_ptr&) = delete;
// Disable construction from convertible pointer types.
- // (N2315 - 20.6.5.3.1)
- template<typename _Up>
- unique_ptr(_Up*, typename
- std::conditional<std::is_reference<deleter_type>::value,
- deleter_type, const deleter_type&>::type,
- typename std::enable_if<std::is_convertible<_Up*,
- pointer>::value>::type* = 0) = delete;
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ unique_ptr(_Up*, typename
+ conditional<is_reference<deleter_type>::value,
+ deleter_type, const deleter_type&>::type) = delete;
- template<typename _Up>
- unique_ptr(_Up*, typename std::remove_reference<deleter_type>::type&&,
- typename std::enable_if<std::is_convertible<_Up*,
- pointer>::value>::type* = 0) = delete;
-
- template<typename _Up>
- explicit
- unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*,
- pointer>::value>::type* = 0) = delete;
+ // Disable construction from convertible pointer types.
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ unique_ptr(_Up*, typename
+ remove_reference<deleter_type>::type&&) = delete;
+ };
- private:
- __tuple_type _M_t;
- };
-
- template<typename _Tp, typename _Tp_Deleter>
+ template<typename _Tp, typename _Dp>
inline void
- swap(unique_ptr<_Tp, _Tp_Deleter>& __x,
- unique_ptr<_Tp, _Tp_Deleter>& __y)
+ swap(unique_ptr<_Tp, _Dp>& __x,
+ unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
inline bool
- operator==(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
+ operator==(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() == __y.get(); }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
inline bool
- operator!=(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return !(__x.get() == __y.get()); }
+ operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+ { return !__x; }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
inline bool
- operator<(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return __x.get() < __y.get(); }
+ operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+ { return !__x; }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
inline bool
- operator<=(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return !(__y.get() < __x.get()); }
+ operator!=(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
+ { return __x.get() != __y.get(); }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
inline bool
- operator>(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return __y.get() < __x.get(); }
+ operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+ { return (bool)__x; }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
inline bool
- operator>=(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return !(__x.get() < __y.get()); }
+ operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+ { return (bool)__x; }
+
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
+ inline bool
+ operator<(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
+ {
+ typedef typename
+ std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
+ typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
+ return std::less<_CT>()(__x.get(), __y.get());
+ }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+ nullptr); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+ __x.get()); }
+
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
+ inline bool
+ operator<=(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
+ { return !(__y < __x); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return !(nullptr < __x); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return !(__x < nullptr); }
+
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
+ inline bool
+ operator>(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
+ { return (__y < __x); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+ __x.get()); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+ nullptr); }
+
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
+ inline bool
+ operator>=(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
+ { return !(__x < __y); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return !(__x < nullptr); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return !(nullptr < __x); }
+
+ /// std::hash specialization for unique_ptr.
+ template<typename _Tp, typename _Dp>
+ struct hash<unique_ptr<_Tp, _Dp>>
+ : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
+ {
+ size_t
+ operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
+ {
+ typedef unique_ptr<_Tp, _Dp> _UP;
+ return std::hash<typename _UP::pointer>()(__u.get());
+ }
+ };
+
+#if __cplusplus > 201103L
+ template<typename _Tp>
+ struct _MakeUniq
+ { typedef unique_ptr<_Tp> __single_object; };
+
+ template<typename _Tp>
+ struct _MakeUniq<_Tp[]>
+ { typedef unique_ptr<_Tp[]> __array; };
+
+ template<typename _Tp, size_t _Bound>
+ struct _MakeUniq<_Tp[_Bound]>
+ { struct __invalid_type { }; };
+
+ /// std::make_unique for single objects
+ template<typename _Tp, typename... _Args>
+ inline typename _MakeUniq<_Tp>::__single_object
+ make_unique(_Args&&... __args)
+ { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
+
+ /// std::make_unique for arrays of unknown bound
+ template<typename _Tp>
+ inline typename _MakeUniq<_Tp>::__array
+ make_unique(size_t __num)
+ { return unique_ptr<_Tp>(new typename remove_extent<_Tp>::type[__num]()); }
+
+ /// Disable std::make_unique for arrays of known bound
+ template<typename _Tp, typename... _Args>
+ inline typename _MakeUniq<_Tp>::__invalid_type
+ make_unique(_Args&&...) = delete;
+#endif
// @} group pointer_abstractions
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _UNIQUE_PTR_H */