Constrain shared_ptr(Y*) - 2874

[zoecarver]

Summary

This patch fixes issue 2874 by constraining the constructor shared_ptr(Y*) . Keep in mind the type trait must be supported in C++03 (believe me; it used to look worse).

[zoecarver]

Didn't realize I already had a patch for this: D81417.

include/memory

private:
     struct __nat {int __for_bool_;};
 public:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT;
     template<class _Yp>
         explicit shared_ptr(_Yp* __p,
-                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat());
+                            typename enable_if<
+                                __compatible_with<_Yp, element_type>::value &&
+                                    conditional<is_array<_Tp>::value,
+                                                __is_array_deletable<_Yp*>,
+                                                __is_deletable<_Yp*>
+
+                                    >::type::value,
+                                __nat
+                            >::type = __nat());
     template<class _Yp, class _Dp>
         shared_ptr(_Yp* __p, _Dp __d,
                    typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat());
     template<class _Yp, class _Dp, class _Alloc>
         shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
                    typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat());
     template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
     template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);

 _LIBCPP_CONSTEXPR
 shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT
     : __ptr_(0),
       __cntrl_(0) {}
 
 template<class _Tp>
 template<class _Yp>
 shared_ptr<_Tp>::shared_ptr(_Yp* __p,
-                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
+                            typename enable_if<
+                                __compatible_with<_Yp, element_type>::value &&
+                                    conditional<is_array<_Tp>::value,
+                                                __is_array_deletable<_Yp*>,
+                                                __is_deletable<_Yp*>
+
+                                    >::type::value,
+                                __nat
+                            >::type)
     : __ptr_(__p),
       __cntrl_(__allocate_shared(__p))
 {
     __enable_weak_this(__p, __p);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp>

include/type_traits

 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr bool is_constant_evaluated() noexcept {
   return __builtin_is_constant_evaluated();
 }
 #endif
 
+// __is_deleteable
+
+template<class _Tp>
+struct __is_deletable
+{
+    template<class _Up>
+    static decltype(delete *(_Up*)(0)) test(int);
+
+    template<class>
+    static false_type test(...);
+
+    static const bool value = !is_same<false_type, decltype(test<_Tp>(0))>::value;
+};
+
+template<class _Tp>
+struct __is_array_deletable
+{
+    template<class _Up>
+    static decltype(delete[] *(_Up*)(0)) test(int);
+
+    template<class>
+    static false_type test(...);
+
+    static const bool value = !is_same<false_type, decltype(test<_Tp>(0))>::value;
+};
+
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 // std::byte
 namespace std  // purposefully not versioned
 {
 template <class _Integer>
   constexpr typename enable_if<is_integral_v<_Integer>, byte>::type &

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp

struct A
 
     A() {++count;}
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
+struct NoDelete
+{
+    void operator delete  (void*) = delete;
+    void operator delete[](void*) {}
+};
+
+struct NoArrayDelete
+{
+    void operator delete  (void*) {}
+    void operator delete[](void*) = delete;
+};
+
+struct Foo {};
+
+struct IntPtrConstructible
+{
+    IntPtrConstructible(int*) {}
+};
+
 int main(int, char**)
 {
     {
     A* ptr = new A;
     std::shared_ptr<A> p(ptr);
     assert(A::count == 1);
     assert(p.use_count() == 1);
     assert(p.get() == ptr);
#if TEST_STD_VER > 14
     {
         std::shared_ptr<A[]> pA(new A[8]);
         assert(pA.use_count() == 1);
         assert(A::count == 8);
     }
     assert(A::count == 0);
 #endif
 
+    // overload resolution
+    {
+        typedef std::shared_ptr<NoDelete> T;
+        static_assert((!std::is_constructible<T, NoDelete*>::value), "" );
+    }
+    {
+        typedef std::shared_ptr<NoArrayDelete> T;
+        static_assert((std::is_constructible<T, NoArrayDelete*>::value), "" );
+    }
+    {
+        typedef std::shared_ptr<int> T;
+        static_assert((!std::is_constructible<T, Foo*>::value), "" );
+    }
+
+#if TEST_STD_VER > 14
+    {
+        typedef std::shared_ptr<NoDelete[8]> T;
+        static_assert(std::is_constructible<T, NoDelete*>::value, "");
+    }
+    {
+        typedef std::shared_ptr<NoArrayDelete[8]> T;
+        static_assert(!std::is_constructible<T, NoArrayDelete*>::value, "");
+    }
+    {
+        typedef std::shared_ptr<IntPtrConstructible[8]> T;
+        static_assert(!std::is_constructible<T, int*>::value, "");
+    }
+#endif
+
   return 0;
 }