From: Jonathan Wakely Date: Sun, 13 Nov 2016 22:57:45 +0000 (+0000) Subject: Add array support to std::shared_ptr for C++17 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=b2343559f224a16e745256bd6975867966b77a91;p=gcc.git Add array support to std::shared_ptr for C++17 * doc/xml/manual/status_cxx2017.xml: Update status. * doc/html/manual/status.html: Regenerate. * include/bits/shared_ptr.h (shared_ptr(unique_ptr<_Yp, _Del>)): Add extension constructor to maintain C++14 behaviour. * include/bits/shared_ptr_base.h (__sp_array_delete): Add new struct. (__shared_count(_Ptr, false_type), __shared_count(_Ptr, true_type)): New constructors. (__sp_compatible_with, __sp_is_constructible): Add specializations for array support. (__sp_is_constructible_arr, __sp_is_constructible_arrN): New helpers. (__shared_ptr_access): New base class for observer member functions. (__shared_ptr::element_type): Use remove_extent. (__shared_ptr::_UniqCompatible): Add __sp_compatible_with check. (__shared_ptr(_Yp*)): Use tag dispatching to call new __shared_count constructor. (__shared_ptr(unique_ptr<_Yp, _Del>)): Add extension constructor. (__shared_ptr::operator*, __shared_ptr::operator->): Remove and inherit from __shared_ptr_access base class. (__shared_ptr::__has_esft_base): Return false for array types. (__weak_ptr::element_type): Use remove_extent. * include/experimental/bits/shared_ptr.h (__libfund_v1): Remove. (__shared_ptr<__libfund_v1<_Tp>>): Remove specializations. (__wak_ptr<__libfund_v1<_Tp>>): Likewise. (experimental::__sp_compatible_v): Redefine using __sp_compatible_with. (experimental::__sp_is_constructible_v): Redefine using __sp_is_constructible. (get_deleter, operator<<): Change argument from __shared_ptr to shared_ptr. * testsuite/20_util/shared_ptr/cons/array.cc: New test. * testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc: Adjust for new behaviour. * testsuite/20_util/shared_ptr/observers/array.cc: Test observers for arrays. * testsuite/20_util/shared_ptr/observers/array_neg.cc: New test. From-SVN: r242369 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 3df60de0997..83a61393cbb 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,41 @@ +2016-11-13 Jonathan Wakely + + * doc/xml/manual/status_cxx2017.xml: Update status. + * doc/html/manual/status.html: Regenerate. + * include/bits/shared_ptr.h (shared_ptr(unique_ptr<_Yp, _Del>)): Add + extension constructor to maintain C++14 behaviour. + * include/bits/shared_ptr_base.h (__sp_array_delete): Add new struct. + (__shared_count(_Ptr, false_type), __shared_count(_Ptr, true_type)): + New constructors. + (__sp_compatible_with, __sp_is_constructible): Add specializations + for array support. + (__sp_is_constructible_arr, __sp_is_constructible_arrN): New helpers. + (__shared_ptr_access): New base class for observer member functions. + (__shared_ptr::element_type): Use remove_extent. + (__shared_ptr::_UniqCompatible): Add __sp_compatible_with check. + (__shared_ptr(_Yp*)): Use tag dispatching to call new __shared_count + constructor. + (__shared_ptr(unique_ptr<_Yp, _Del>)): Add extension constructor. + (__shared_ptr::operator*, __shared_ptr::operator->): Remove and + inherit from __shared_ptr_access base class. + (__shared_ptr::__has_esft_base): Return false for array types. + (__weak_ptr::element_type): Use remove_extent. + * include/experimental/bits/shared_ptr.h (__libfund_v1): Remove. + (__shared_ptr<__libfund_v1<_Tp>>): Remove specializations. + (__wak_ptr<__libfund_v1<_Tp>>): Likewise. + (experimental::__sp_compatible_v): Redefine using + __sp_compatible_with. + (experimental::__sp_is_constructible_v): Redefine using + __sp_is_constructible. + (get_deleter, operator<<): Change argument from __shared_ptr to + shared_ptr. + * testsuite/20_util/shared_ptr/cons/array.cc: New test. + * testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc: Adjust for + new behaviour. + * testsuite/20_util/shared_ptr/observers/array.cc: Test observers for + arrays. + * testsuite/20_util/shared_ptr/observers/array_neg.cc: New test. + 2016-11-13 Ville Voutilainen Implement P0403R1, Literal suffixes for basic_string_view. diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html index 554d519a0a6..08c9ad06dea 100644 --- a/libstdc++-v3/doc/html/manual/status.html +++ b/libstdc++-v3/doc/html/manual/status.html @@ -565,11 +565,11 @@ Feature-testing recommendations for C++. P0220R1 - 7 __cpp_lib_apply >= 201603 Library Fundamentals V1 TS Components: shared_ptr<T[]> + 7 __cpp_lib_apply >= 201603 Library Fundamentals V1 TS Components: shared_ptr<T[]> P0220R1 - No __cpp_lib_shared_ptr_arrays >= 201603 Library Fundamentals V1 TS Components: Searchers + 7 __cpp_lib_shared_ptr_arrays >= 201603 Library Fundamentals V1 TS Components: Searchers P0220R1 diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml index d008bd9eb9b..dbb26c8f867 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml @@ -158,14 +158,13 @@ Feature-testing recommendations for C++. - Library Fundamentals V1 TS Components: shared_ptr<T[]> P0220R1 - No + 7 __cpp_lib_shared_ptr_arrays >= 201603 diff --git a/libstdc++-v3/include/bits/shared_ptr.h b/libstdc++-v3/include/bits/shared_ptr.h index e562a42b339..cbe4144359e 100644 --- a/libstdc++-v3/include/bits/shared_ptr.h +++ b/libstdc++-v3/include/bits/shared_ptr.h @@ -277,6 +277,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION shared_ptr(unique_ptr<_Yp, _Del>&& __r) : __shared_ptr<_Tp>(std::move(__r)) { } +#if __cplusplus <= 201402L && _GLIBCXX_USE_DEPRECATED + // This non-standard constructor exists to support conversions that + // were possible in C++11 and C++14 but are ill-formed in C++17. + // If an exception is thrown this constructor has no effect. + template, __sp_array_delete>* = 0> + shared_ptr(unique_ptr<_Yp, _Del>&& __r) + : __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { } +#endif + /** * @brief Construct an empty %shared_ptr. * @post use_count() == 0 && get() == nullptr diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h index 5e344b8e090..953aa87436e 100644 --- a/libstdc++-v3/include/bits/shared_ptr_base.h +++ b/libstdc++-v3/include/bits/shared_ptr_base.h @@ -559,6 +559,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Impl _M_impl; }; + // The default deleter for shared_ptr and shared_ptr. + struct __sp_array_delete + { + template + void operator()(_Yp* __p) const { delete[] __p; } + }; template<_Lock_policy _Lp> class __shared_count @@ -582,6 +588,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } } + template + __shared_count(_Ptr __p, /* is_array = */ false_type) + : __shared_count(__p) + { } + + template + __shared_count(_Ptr __p, /* is_array = */ true_type) + : __shared_count(__p, __sp_array_delete{}, allocator()) + { } + template __shared_count(_Ptr __p, _Deleter __d) : __shared_count(__p, std::move(__d), allocator()) @@ -848,8 +864,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_pi = nullptr; } - // Helper traits for shared_ptr +#define __cpp_lib_shared_ptr_arrays 201603 + + // Helper traits for shared_ptr of array: + // A pointer type Y* is said to be compatible with a pointer type T* when + // either Y* is convertible to T* or Y is U[N] and T is U cv []. template struct __sp_compatible_with : false_type @@ -860,17 +880,161 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : is_convertible<_Yp*, _Tp*>::type { }; + template + struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> + : true_type + { }; + + // Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N]. + template + struct __sp_is_constructible_arrN + : false_type + { }; + + template + struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> + : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type + { }; + + // Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[]. + template + struct __sp_is_constructible_arr + : false_type + { }; + + template + struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> + : is_convertible<_Yp(*)[], _Up(*)[]>::type + { }; + + // Trait to check if shared_ptr can be constructed from Y*. + template + struct __sp_is_constructible; + + // When T is U[N], Y(*)[N] shall be convertible to T*; + template + struct __sp_is_constructible<_Up[_Nm], _Yp> + : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type + { }; + + // when T is U[], Y(*)[] shall be convertible to T*; + template + struct __sp_is_constructible<_Up[], _Yp> + : __sp_is_constructible_arr<_Up, _Yp>::type + { }; + + // otherwise, Y* shall be convertible to T*. + template + struct __sp_is_constructible + : is_convertible<_Yp*, _Tp*>::type + { }; + + + // Define operator* and operator-> for shared_ptr. + template::value, bool = is_void<_Tp>::value> + class __shared_ptr_access + { + public: + using element_type = _Tp; + + element_type& + operator*() const noexcept + { + __glibcxx_assert(_M_get() != nullptr); + return *_M_get(); + } + + element_type* + operator->() const noexcept + { + _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); + return _M_get(); + } + + private: + element_type* + _M_get() const noexcept + { return static_cast*>(this)->get(); } + }; + + // Define operator-> for shared_ptr. template - class __shared_ptr + class __shared_ptr_access<_Tp, _Lp, false, true> { public: using element_type = _Tp; + element_type* + operator->() const noexcept + { + _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); + return static_cast*>(this)->get(); + } + }; + + // Define operator[] for shared_ptr and shared_ptr. + template + class __shared_ptr_access<_Tp, _Lp, true, false> + { + public: + using element_type = typename remove_extent<_Tp>::type; + +#if __cplusplus <= 201402L + [[__deprecated__("shared_ptr::operator* is absent from C++17")]] + element_type& + operator*() const noexcept + { + __glibcxx_assert(_M_ptr != nullptr); + return *_M_get(); + } + + [[__deprecated__("shared_ptr::operator-> is absent from C++17")]] + element_type* + operator->() const noexcept + { + _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); + return _M_get(); + } +#endif + + element_type& + operator[](ptrdiff_t __i) const + { + __glibcxx_assert(_M_get() != nullptr); + __glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value); + return _M_get()[__i]; + } + private: - // Trait to check if shared_ptr can be constructed from Y*. - template - using __sp_is_constructible = is_convertible<_Yp*, _Tp1*>; + element_type* + _M_get() const noexcept + { return static_cast*>(this)->get(); } + }; + template + class __shared_ptr + : public __shared_ptr_access<_Tp, _Lp> + { + public: + using element_type = typename remove_extent<_Tp>::type; + + private: // Constraint for taking ownership of a pointer of type _Yp*: template using _SafeConv @@ -888,9 +1052,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Constraint for construction from unique_ptr: template::pointer> - using _UniqCompatible = typename enable_if< - is_convertible<_Ptr, element_type*>::value - , _Res>::type; + using _UniqCompatible = typename enable_if<__and_< + __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*> + >::value, _Res>::type; // Constraint for assignment from unique_ptr: template @@ -909,7 +1073,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template> explicit __shared_ptr(_Yp* __p) - : _M_ptr(__p), _M_refcount(__p) + : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) { static_assert( !is_void<_Yp>::value, "incomplete type" ); static_assert( sizeof(_Yp) > 0, "incomplete type" ); @@ -995,6 +1159,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_enable_shared_from_this_with(__raw); } +#if __cplusplus <= 201402L && _GLIBCXX_USE_DEPRECATED + protected: + // If an exception is thrown this constructor has no effect. + template>, is_array<_Tp1>, + is_convertible::pointer, _Tp*> + >::value, bool>::type = true> + __shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete) + : _M_ptr(__r.get()), _M_refcount() + { + auto __raw = _S_raw_ptr(__r.get()); + _M_refcount = __shared_count<_Lp>(std::move(__r)); + _M_enable_shared_from_this_with(__raw); + } + public: +#endif + #if _GLIBCXX_USE_DEPRECATED // Postcondition: use_count() == 1 and __r.get() == 0 template> @@ -1068,21 +1250,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION reset(_Yp* __p, _Deleter __d, _Alloc __a) { __shared_ptr(__p, __d, std::move(__a)).swap(*this); } - // Allow class instantiation when _Tp is [cv-qual] void. - typename std::add_lvalue_reference::type - operator*() const noexcept - { - __glibcxx_assert(_M_ptr != 0); - return *_M_ptr; - } - - element_type* - operator->() const noexcept - { - _GLIBCXX_DEBUG_PEDASSERT(_M_ptr != 0); - return _M_ptr; - } - element_type* get() const noexcept { return _M_ptr; } @@ -1193,7 +1360,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> - : true_type { }; + : __not_> { }; // No enable shared_from_this for arrays template typename enable_if<__has_esft_base<_Yp>::value>::type @@ -1428,7 +1595,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using _Assignable = _Compatible<_Yp, __weak_ptr&>; public: - using element_type = _Tp; + using element_type = typename remove_extent<_Tp>::type; constexpr __weak_ptr() noexcept : _M_ptr(nullptr), _M_refcount() diff --git a/libstdc++-v3/include/experimental/bits/shared_ptr.h b/libstdc++-v3/include/experimental/bits/shared_ptr.h index e8c533e158c..8a1fc52caf8 100644 --- a/libstdc++-v3/include/experimental/bits/shared_ptr.h +++ b/libstdc++-v3/include/experimental/bits/shared_ptr.h @@ -46,665 +46,20 @@ namespace experimental inline namespace fundamentals_v2 { _GLIBCXX_BEGIN_NAMESPACE_VERSION - template class enable_shared_from_this; -_GLIBCXX_END_NAMESPACE_VERSION -} // namespace fundamentals_v2 -} // namespace experimental - -#define __cpp_lib_experimental_shared_ptr_arrays 201406 - -_GLIBCXX_BEGIN_NAMESPACE_VERSION - - /* - * The specification of std::experimental::shared_ptr is slightly different - * to std::shared_ptr (specifically in terms of "compatible" pointers) so - * to implement std::experimental::shared_ptr without too much duplication - * we make it derive from a partial specialization of std::__shared_ptr - * using a special tag type, __libfund_v1. - * - * There are two partial specializations for the tag type, supporting the - * different interfaces of the array and non-array forms. - */ - - template ::value> - struct __libfund_v1 { using type = _Tp; }; - - // Partial specialization for base class of experimental::shared_ptr - // (i.e. the non-array form of experimental::shared_ptr) - template - class __shared_ptr<__libfund_v1<_Tp, false>, _Lp> - : private __shared_ptr<_Tp, _Lp> - { - // For non-arrays, Y* is compatible with T* if Y* is convertible to T*. - template - using _Compatible - = enable_if_t, _Res>; - - template::pointer, - typename _Res = void> - using _UniqCompatible = enable_if_t< - experimental::is_convertible_v<_Yp*, _Tp*> - && experimental::is_convertible_v<_Ptr, _Tp*>, - _Res>; - - using _Base_type = __shared_ptr<_Tp>; - - _Base_type& _M_get_base() { return *this; } - const _Base_type& _M_get_base() const { return *this; } - - public: - using element_type = _Tp; - - constexpr __shared_ptr() noexcept = default; - - template> - explicit - __shared_ptr(_Tp1* __p) - : _Base_type(__p) - { } - - template> - __shared_ptr(_Tp1* __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template> - __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template - __shared_ptr(nullptr_t __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template - __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r, - element_type* __p) noexcept - : _Base_type(__r._M_get_base(), __p) - { } - - __shared_ptr(const __shared_ptr&) noexcept = default; - __shared_ptr(__shared_ptr&&) noexcept = default; - __shared_ptr& operator=(const __shared_ptr&) noexcept = default; - __shared_ptr& operator=(__shared_ptr&&) noexcept = default; - ~__shared_ptr() = default; - - template> - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - template> - __shared_ptr(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - : _Base_type(std::move((__r._M_get_base()))) - { } - - template> - explicit - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) - : _Base_type(__r._M_get_base()) - { } - - template> - __shared_ptr(unique_ptr<_Tp1, _Del>&& __r) - : _Base_type(std::move(__r)) - { } - -#if _GLIBCXX_USE_DEPRECATED - // Postcondition: use_count() == 1 and __r.get() == 0 - template> - __shared_ptr(std::auto_ptr<_Tp1>&& __r) - : _Base_type(std::move(__r)) - { } -#endif - - constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } - - // reset - void - reset() noexcept - { __shared_ptr(nullptr).swap(*this); } - - template - _Compatible<_Tp1> - reset(_Tp1* __p) - { - _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != get()); - __shared_ptr(__p).swap(*this); - } - - template - _Compatible<_Tp1> - reset(_Tp1* __p, _Deleter __d) - { __shared_ptr(__p, __d).swap(*this); } - - template - _Compatible<_Tp1> - reset(_Tp1* __p, _Deleter __d, _Alloc __a) - { __shared_ptr(__p, __d, std::move(__a)).swap(*this); } - - using _Base_type::operator*; - using _Base_type::operator->; - - template - _Compatible<_Tp1, __shared_ptr&> - operator=(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - { - _Base_type::operator=(__r._M_get_base()); - return *this; - } - - template - _Compatible<_Tp1, __shared_ptr&> - operator=(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - { - _Base_type::operator=(std::move(__r._M_get_base())); - return *this; - } - - template - _UniqCompatible<_Tp1, _Del, __shared_ptr&> - operator=(unique_ptr<_Tp1, _Del>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } - -#if _GLIBCXX_USE_DEPRECATED - template - _Compatible<_Tp1, __shared_ptr&> - operator=(std::auto_ptr<_Tp1>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } -#endif - - void - swap(__shared_ptr& __other) noexcept - { _Base_type::swap(__other); } - - template - bool - owner_before(__shared_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - template - bool - owner_before(__weak_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - using _Base_type::operator bool; - using _Base_type::get; - using _Base_type::unique; - using _Base_type::use_count; - - protected: - - // make_shared not yet support for shared_ptr_arrays - //template - // __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, - // _Args&&... __args) - // : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a, - // std::forward<_Args>(__args)...) - // { - // void* __p = _M_refcount._M_get_deleter(typeid(__tag)); - // _M_ptr = static_cast<_Tp*>(__p); - // } - - // __weak_ptr::lock() - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp>, _Lp>& __r, - std::nothrow_t) - : _Base_type(__r._M_get_base(), std::nothrow) - { } - - private: - template friend class __weak_ptr; - template friend class __shared_ptr; - - // TODO - template - friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; - }; - - // Helper traits for shared_ptr of array: - // Trait that tests if Y* is compatible with T*, for shared_ptr purposes. - template - struct __sp_compatible - : is_convertible<_Yp*, _Tp*>::type - { }; + // 8.2.1 - template - struct __sp_compatible<_Tp[_Nm], _Tp[]> - : true_type - { }; - - template - struct __sp_compatible<_Tp[_Nm], const _Tp[]> - : true_type - { }; + template class shared_ptr; + template class weak_ptr; + template class enable_shared_from_this; template constexpr bool __sp_compatible_v - = __sp_compatible<_Yp, _Tp>::value; - - // Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N]. - template - struct __sp_is_constructible_arrN - : false_type - { }; - - template - struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> - : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type - { }; - - // Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[]. - template - struct __sp_is_constructible_arr - : false_type - { }; - - template - struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> - : is_convertible<_Yp(*)[], _Up(*)[]>::type - { }; - - // Trait to check if shared_ptr can be constructed from Y*. - template - struct __sp_is_constructible; - - // When T is U[N], Y(*)[N] shall be convertible to T*; - template - struct __sp_is_constructible<_Up[_Nm], _Yp> - : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type - { }; - - // when T is U[], Y(*)[] shall be convertible to T*; - template - struct __sp_is_constructible<_Up[], _Yp> - : __sp_is_constructible_arr<_Up, _Yp>::type - { }; - - // otherwise, Y* shall be convertible to T*. - template - struct __sp_is_constructible - : is_convertible<_Yp*, _Tp*>::type - { }; + = std::__sp_compatible_with<_Yp*, _Tp*>::value; template constexpr bool __sp_is_constructible_v - = __sp_is_constructible<_Tp, _Yp>::value; - - - // Partial specialization for base class of experimental::shared_ptr - // and experimental::shared_ptr (i.e. the array forms). - template - class __shared_ptr<__libfund_v1<_Tp, true>, _Lp> - : private __shared_ptr, _Lp> - { - public: - using element_type = remove_extent_t<_Tp>; - - private: - struct _Array_deleter - { - void - operator()(element_type const *__p) const - { delete [] __p; } - }; - - // Constraint for constructing/resetting with a pointer of type _Yp*: - template - using _SafeConv = enable_if_t<__sp_is_constructible_v<_Tp, _Yp>>; - - // Constraint for constructing/assigning from smart_pointer<_Tp1>: - template - using _Compatible = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>; - - // Constraint for constructing/assigning from unique_ptr<_Tp1, _Del>: - template::pointer, - typename _Res = void> - using _UniqCompatible = enable_if_t< - __sp_compatible_v<_Tp1, _Tp> - && experimental::is_convertible_v<_Ptr, element_type*>, - _Res>; - - using _Base_type = __shared_ptr; - - _Base_type& _M_get_base() { return *this; } - const _Base_type& _M_get_base() const { return *this; } - - public: - constexpr __shared_ptr() noexcept - : _Base_type() - { } - - template> - explicit - __shared_ptr(_Tp1* __p) - : _Base_type(__p, _Array_deleter()) - { } - - template> - __shared_ptr(_Tp1* __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template> - __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template - __shared_ptr(nullptr_t __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template - __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r, - element_type* __p) noexcept - : _Base_type(__r._M_get_base(), __p) - { } - - __shared_ptr(const __shared_ptr&) noexcept = default; - __shared_ptr(__shared_ptr&&) noexcept = default; - __shared_ptr& operator=(const __shared_ptr&) noexcept = default; - __shared_ptr& operator=(__shared_ptr&&) noexcept = default; - ~__shared_ptr() = default; - - template> - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - template> - __shared_ptr(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - : _Base_type(std::move((__r._M_get_base()))) - { } - - template> - explicit - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) - : _Base_type(__r._M_get_base()) - { } - - template> - __shared_ptr(unique_ptr<_Tp1, _Del>&& __r) - : _Base_type(std::move(__r)) - { } - -#if _GLIBCXX_USE_DEPRECATED - // Postcondition: use_count() == 1 and __r.get() == 0 - template> - __shared_ptr(auto_ptr<_Tp1>&& __r) - : _Base_type(std::move(__r)) - { } -#endif - - constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } - - // reset - void - reset() noexcept - { __shared_ptr(nullptr).swap(*this); } - - template - _SafeConv<_Tp1> - reset(_Tp1* __p) - { - _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != get()); - __shared_ptr(__p, _Array_deleter()).swap(*this); - } - - template - _SafeConv<_Tp1> - reset(_Tp1* __p, _Deleter __d) - { __shared_ptr(__p, __d).swap(*this); } - - template - _SafeConv<_Tp1> - reset(_Tp1* __p, _Deleter __d, _Alloc __a) - { __shared_ptr(__p, __d, std::move(__a)).swap(*this); } - - element_type& - operator[](ptrdiff_t i) const noexcept - { - _GLIBCXX_DEBUG_ASSERT(get() != 0 && i >= 0); - return get()[i]; - } - - template - _Compatible<_Tp1, __shared_ptr&> - operator=(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - { - _Base_type::operator=(__r._M_get_base()); - return *this; - } - - template - _Compatible<_Tp1, __shared_ptr&> - operator=(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - { - _Base_type::operator=(std::move(__r._M_get_base())); - return *this; - } - - template - _UniqCompatible<_Tp1, _Del, __shared_ptr&> - operator=(unique_ptr<_Tp1, _Del>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } - -#if _GLIBCXX_USE_DEPRECATED - template - _Compatible<_Tp1, __shared_ptr&> - operator=(auto_ptr<_Tp1>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } -#endif - - void - swap(__shared_ptr& __other) noexcept - { _Base_type::swap(__other); } - - template - bool - owner_before(__shared_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - template - bool - owner_before(__weak_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - using _Base_type::operator bool; - using _Base_type::get; - using _Base_type::unique; - using _Base_type::use_count; - - protected: - - // make_shared not yet support for shared_ptr_arrays - //template - // __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, - // _Args&&... __args) - // : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a, - // std::forward<_Args>(__args)...) - // { - // void* __p = _M_refcount._M_get_deleter(typeid(__tag)); - // _M_ptr = static_cast<_Tp*>(__p); - // } - - // __weak_ptr::lock() - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp>, _Lp>& __r, - std::nothrow_t) - : _Base_type(__r._M_get_base(), std::nothrow) - { } - - private: - template friend class __weak_ptr; - template friend class __shared_ptr; - - // TODO - template - friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; - }; - - // weak_ptr specialization for __shared_ptr array - template - class __weak_ptr<__libfund_v1<_Tp>, _Lp> - : __weak_ptr, _Lp> - { - template - using _Compatible - = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>; - - using _Base_type = __weak_ptr>; - - _Base_type& _M_get_base() { return *this; } - const _Base_type& _M_get_base() const { return *this; } - - public: - using element_type = remove_extent_t<_Tp>; - - constexpr __weak_ptr() noexcept - : _Base_type() - { } - - __weak_ptr(const __weak_ptr&) noexcept = default; - - ~__weak_ptr() = default; - - template> - __weak_ptr(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - template> - __weak_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - __weak_ptr(__weak_ptr&& __r) noexcept - : _Base_type(std::move(__r)) - { } - - template> - __weak_ptr(__weak_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - : _Base_type(std::move(__r._M_get_base())) - { } - - __weak_ptr& - operator=(const __weak_ptr& __r) noexcept = default; - - template - _Compatible<_Tp1, __weak_ptr&> - operator=(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - { - this->_Base_type::operator=(__r._M_get_base()); - return *this; - } - - template - _Compatible<_Tp1, __weak_ptr&> - operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - this->_Base_type::operator=(__r._M_get_base()); - return *this; - } - - __weak_ptr& - operator=(__weak_ptr&& __r) noexcept - { - this->_Base_type::operator=(std::move(__r)); - return *this; - } - - template - _Compatible<_Tp1, __weak_ptr&> - operator=(__weak_ptr<_Tp1, _Lp>&& __r) noexcept - { - this->_Base_type::operator=(std::move(__r._M_get_base())); - return *this; - } - - void - swap(__weak_ptr& __other) noexcept - { this->_Base_type::swap(__other); } - - template - bool - owner_before(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - template - bool - owner_before(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - __shared_ptr<__libfund_v1<_Tp>, _Lp> - lock() const noexcept // should not be element_type - { return __shared_ptr<__libfund_v1<_Tp>, _Lp>(*this, std::nothrow); } - - using _Base_type::use_count; - using _Base_type::expired; - using _Base_type::reset; - - private: - // Used by __enable_shared_from_this. - void - _M_assign(element_type* __ptr, - const __shared_count<_Lp>& __refcount) noexcept - { this->_Base_type::_M_assign(__ptr, __refcount); } - - template friend class __shared_ptr; - template friend class __weak_ptr; - friend class __enable_shared_from_this<_Tp, _Lp>; - friend class experimental::enable_shared_from_this<_Tp>; - friend class enable_shared_from_this<_Tp>; - }; - -_GLIBCXX_END_NAMESPACE_VERSION - -namespace experimental -{ -inline namespace fundamentals_v2 -{ -_GLIBCXX_BEGIN_NAMESPACE_VERSION - - // 8.2.1 - - template class shared_ptr; - template class weak_ptr; - - template - using __shared_ptr = std::__shared_ptr<__libfund_v1<_Tp>, _Lp>; - - template - using __weak_ptr = std::__weak_ptr<__libfund_v1<_Tp>, _Lp>; + = std::__sp_is_constructible<_Tp, _Yp>::value; template class shared_ptr : public __shared_ptr<_Tp> @@ -1128,16 +483,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { __a.swap(__b); } /// C++14 §20.8.2.2.10 - template + template inline _Del* - get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept + get_deleter(const shared_ptr<_Tp>& __p) noexcept { return std::get_deleter<_Del>(__p); } // C++14 §20.8.2.2.11 - template + template inline std::basic_ostream<_Ch, _Tr>& - operator<<(std::basic_ostream<_Ch, _Tr>& __os, - const __shared_ptr<_Tp, _Lp>& __p) + operator<<(std::basic_ostream<_Ch, _Tr>& __os, const shared_ptr<_Tp>& __p) { __os << __p.get(); return __os; diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/array.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/array.cc new file mode 100644 index 00000000000..d56dc6692e9 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/array.cc @@ -0,0 +1,273 @@ +// { dg-do run { target c++11 } } + +// Copyright (C) 2016 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +// C++1z 20.11.2.2.1 shared_ptr constructors [util.smartptr.shared.const] + +template +constexpr bool check() +{ + using std::shared_ptr; + using std::is_constructible; + return !is_constructible, shared_ptr>::value + && !is_constructible, shared_ptr&>::value; +} + +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); + +int count = 0; + +struct A { + A() { ++count; } + ~A() { --count; } +}; + +struct B : A { }; + +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); +static_assert( check() ); + +void +test01() +{ + std::shared_ptr p; + VERIFY( p.get() == nullptr ); + VERIFY( p.use_count() == 0 ); + p.reset(); + VERIFY( count == 0 ); +} + +void +test02() +{ + std::shared_ptr p; + VERIFY( p.get() == nullptr ); + VERIFY( p.use_count() == 0 ); + p.reset(); + VERIFY( count == 0 ); +} + +void +test03() +{ + std::shared_ptr p(nullptr); + VERIFY( p.get() == nullptr ); + VERIFY( p.use_count() == 0 ); + p.reset(); + VERIFY( count == 0 ); +} + +void +test04() +{ + std::shared_ptr p(nullptr); + VERIFY( p.get() == nullptr ); + VERIFY( p.use_count() == 0 ); + p.reset(); + VERIFY( count == 0 ); +} + +// Construction from pointer + +void +test05() +{ + A * const a = nullptr; + std::shared_ptr p(a); + VERIFY( p.get() == nullptr ); + VERIFY( p.use_count() == 1 ); + p.reset(); + VERIFY( count == 0 ); +} + +void +test06() +{ + A * const a = nullptr; + std::shared_ptr p(a); + VERIFY( p.get() == nullptr ); + VERIFY( p.use_count() == 1 ); + p.reset(); + VERIFY( count == 0 ); +} + +void +test07() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + VERIFY( p.get() == a ); + VERIFY( p.use_count() == 1 ); + p.reset(); + VERIFY( count == 0 ); +} + +void +test08() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + VERIFY( p.get() == a ); + VERIFY( p.use_count() == 1 ); + p.reset(); + VERIFY( count == 0 ); +} + +// Converting constrcutor + +void +test09() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + std::shared_ptr p2(p); + VERIFY( p2.get() == a ); + VERIFY( p.use_count() == 2 ); + VERIFY( p2.use_count() == 2 ); + p.reset(); + VERIFY( count != 0 ); + p2.reset(); + VERIFY( count == 0 ); +} + +void +test10() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + std::shared_ptr p2(p); + VERIFY( p2.get() == a ); + VERIFY( p.use_count() == 2 ); + VERIFY( p2.use_count() == 2 ); + p.reset(); + VERIFY( count != 0 ); + p2.reset(); + VERIFY( count == 0 ); +} + +void +test11() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + std::shared_ptr p2(p); + VERIFY( p2.get() == a ); + VERIFY( p.use_count() == 2 ); + VERIFY( p2.use_count() == 2 ); + p.reset(); + VERIFY( count != 0 ); + p2.reset(); + VERIFY( count == 0 ); +} + +// Copy construction + +void +test12() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + std::shared_ptr p2(p); + VERIFY( p2.get() == a ); + VERIFY( p.use_count() == 2 ); + VERIFY( p2.use_count() == 2 ); + p.reset(); + VERIFY( count != 0 ); + p2.reset(); + VERIFY( count == 0 ); +} + +void +test13() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + std::shared_ptr p2(p); + VERIFY( p2.get() == a ); + VERIFY( p.use_count() == 2 ); + VERIFY( p2.use_count() == 2 ); + p.reset(); + VERIFY( count != 0 ); + p2.reset(); + VERIFY( count == 0 ); +} + +// Move construction + +void +test14() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + std::shared_ptr p2(std::move(p)); + VERIFY( p.get() == nullptr ); + VERIFY( p2.get() == a ); + VERIFY( p.use_count() == 0 ); + VERIFY( p2.use_count() == 1 ); + p2.reset(); + VERIFY( count == 0 ); +} + +void +test15() +{ + A * const a = new A[2]; + std::shared_ptr p(a); + std::shared_ptr p2(std::move(p)); + VERIFY( p.get() == nullptr ); + VERIFY( p2.get() == a ); + VERIFY( p.use_count() == 0 ); + VERIFY( p2.use_count() == 1 ); + p2.reset(); + VERIFY( count == 0 ); +} + +int +main() +{ + test01(); + test02(); + test03(); + test04(); + test05(); + test06(); + test07(); + test08(); + test09(); + test10(); + test11(); + test12(); + test13(); + test14(); + test15(); +} diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc index 72eed477c8f..bc1fcf12225 100644 --- a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc @@ -22,6 +22,13 @@ #include #include +#if __cpp_lib_shared_ptr_arrays >= 201603 +# define SHARED_PTR_ARRAYS +#endif +#if __cpp_lib_enable_shared_from_this >= 201603 +# define WEAK_FROM_THIS +#endif + int destroyed = 0; struct A : std::enable_shared_from_this @@ -36,12 +43,22 @@ int test01() { std::unique_ptr up(new A[2]); +#ifdef SHARED_PTR_ARRAYS + std::shared_ptr sp(std::move(up)); +#else std::shared_ptr sp(std::move(up)); +#endif VERIFY( up.get() == 0 ); VERIFY( sp.get() != 0 ); VERIFY( sp.use_count() == 1 ); +#ifdef SHARED_PTR_ARRAYS +# ifdef WEAK_FROM_THIS + VERIFY( sp[0].weak_from_this().expired() ); +# endif +#else VERIFY( sp->shared_from_this() != nullptr ); +#endif sp.reset(); VERIFY( destroyed == 2 ); diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/observers/array.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/array.cc new file mode 100644 index 00000000000..c47859d659a --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/observers/array.cc @@ -0,0 +1,73 @@ +// { dg-do run { target c++11 } } + +// Copyright (C) 2016 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. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +struct A +{ + int i = 0; +}; + +// C++1z 20.11.2.2.5 shared_ptr observers [util.smartptr.shared.obs] + +// get +void +test01() +{ + A * const a = new A[2]; + const std::shared_ptr p(a); + VERIFY( p.get() == a ); +} + +// get +void +test02() +{ + A * const a = new A[2]; + const std::shared_ptr p(a); + VERIFY( p.get() == a ); +} + +// operator[] +void +test03() +{ + A * const a = new A[2]; + const std::shared_ptr p(a); + VERIFY( &p[0] == a ); +} + +// operator[] +void +test04() +{ + A * const a = new A[2]; + const std::shared_ptr p(a); + VERIFY( &p[0] == a ); +} + +int +main() +{ + test01(); + test02(); + test03(); + test04(); +}