[libcxx] Avoid spurious construction of valarray elements

[miyuki]

Summary

Currently libc++ implements some operations on valarray by using the
resize method. This method has a parameter with a default value.
Because of this, valarray may spuriously construct and destruct
objects of valarray's element type.

This patch fixes this issue and adds corresponding test cases.

[miyuki]

ping

[miyuki]

ping^2

[miyuki]

ping^3

[mclow.lists]

This LGTM.

include/valarray

3728

I thought that you had lost an exception guarantee here, but it turns out that there wasn't one before. If the allocation fails, you are left with an empty array instead of the old contents.

include/valarray

private:
     friend
     _Up*
     end(valarray<_Up>& __v);
 
     template <class _Up>
     friend
     const _Up*
     end(const valarray<_Up>& __v);
+
+    void __clear();
+    valarray& __assign_range(const value_type* __f, const value_type* __l);
 };
 
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t))
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray())
 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t))
 
 template <class _Op, class _Tp>
 struct _UnaryOp<_Op, valarray<_Tp> >

 // valarray
 
 template <class _Tp>
 inline
 valarray<_Tp>::valarray(size_t __n)
     : __begin_(0),
       __end_(0)
 {
-    resize(__n);
+    if (__n)
+    {
+        __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        try
+        {
+#endif  // _LIBCPP_NO_EXCEPTIONS
+            for (; __n; --__n, ++__end_)
+                ::new (__end_) value_type();
+#ifndef _LIBCPP_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+            __clear();
+            throw;
+        }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    }
 }
 
 template <class _Tp>
 inline
 valarray<_Tp>::valarray(const value_type& __x, size_t __n)
     : __begin_(0),
       __end_(0)
 {
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (; __n; ++__end_, ++__p, --__n)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp>
 valarray<_Tp>::valarray(const valarray& __v)
     : __begin_(0),
       __end_(0)
 {
     if (__v.size())
     {
         __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__v.size() * sizeof(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (const value_type* __p = __il.begin(); __n; ++__end_, ++__p, --__n)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
#ifndef _LIBCPP_NO_EXCEPTIONS
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (const value_type* __p = __sa.__vp_; __n; ++__end_, __p += __sa.__stride_, --__n)
                 ::new (__end_) value_type(*__p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp>
 valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
#endif  // _LIBCPP_NO_EXCEPTIONS
             const value_type* __s = __ga.__vp_;
             for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
                     __i != __e; ++__i, ++__end_)
                 ::new (__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp>
 valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
#endif  // _LIBCPP_NO_EXCEPTIONS
             const value_type* __s = __ma.__vp_;
             for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
                     __i != __e; ++__i, ++__end_)
                 ::new (__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp>
 valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
#endif  // _LIBCPP_NO_EXCEPTIONS
             const value_type* __s = __ia.__vp_;
             for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
                     __i != __e; ++__i, ++__end_)
                 ::new (__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp>
 inline
 valarray<_Tp>::~valarray()
 {
-    resize(0);
+    __clear();
 }
 
 template <class _Tp>
 valarray<_Tp>&
-valarray<_Tp>::operator=(const valarray& __v)
+valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l)
 {
-    if (this != &__v)
+    size_t __n = __l - __f;
+    if (size() != __n)
     {
-        if (size() != __v.size())
-            resize(__v.size());
-        _VSTD::copy(__v.__begin_, __v.__end_, __begin_);
+        __clear();
+        __begin_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));
+        __end_ = __begin_ + __n;
+        _VSTD::uninitialized_copy(__f, __l, __begin_);
+    } else {
+        _VSTD::copy(__f, __l, __begin_);
     }
     return *this;
 }
 
+template <class _Tp>
+valarray<_Tp>&
+valarray<_Tp>::operator=(const valarray& __v)
+{
+    if (this != &__v)
+        return __assign_range(__v.__begin_, __v.__end_);
+    return *this;
+}
+
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT
 {
-    resize(0);
+    __clear();
     __begin_ = __v.__begin_;
     __end_ = __v.__end_;
     __v.__begin_ = nullptr;
     __v.__end_ = nullptr;
     return *this;
 }
 
 template <class _Tp>
 inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(initializer_list<value_type> __il)
 {
-    if (size() != __il.size())
-        resize(__il.size());
-    _VSTD::copy(__il.begin(), __il.end(), __begin_);
-    return *this;
+    return __assign_range(__il.begin(), __il.end());
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
 inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const value_type& __x)
if (__n)
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) value_type(__f(*__p));
     }
     return __r;
 }
 
 template <class _Tp>
 void
-valarray<_Tp>::resize(size_t __n, value_type __x)
+valarray<_Tp>::__clear()
 {
     if (__begin_ != nullptr)
     {
         while (__end_ != __begin_)
             (--__end_)->~value_type();
         _VSTD::__libcpp_deallocate(__begin_);
         __begin_ = __end_ = nullptr;
     }
+}
+
+template <class _Tp>
+void
+valarray<_Tp>::resize(size_t __n, value_type __x)
+{
+    __clear();
     if (__n)
     {
         __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type)));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (; __n; --__n, ++__end_)
                 ::new (__end_) value_type(__x);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
-            resize(0);
+            __clear();
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY

test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp

 // template<class T> class valarray;
 
 // valarray& operator=(const valarray& v);
 
 #include <valarray>
 #include <cassert>
 #include <cstddef>
 
+struct S
+{
+    S() : x_(0) { default_ctor_called = true; }
+    S(int x) : x_(x) {}
+    int x_;
+    static bool default_ctor_called;
+};
+
+bool S::default_ctor_called = false;
+
+bool operator==(const S& lhs, const S& rhs)
+{
+    return lhs.x_ == rhs.x_;
+}
+
 int main()
 {
     {
         typedef int T;
         T a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v(a, N);
         std::valarray<T> v2;
int main()
         assert(v2.size() == v.size());
         for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == v[i].size());
             for (std::size_t j = 0; j < v[i].size(); ++j)
                 assert(v2[i][j] == v[i][j]);
         }
     }
+    {
+        typedef S T;
+        T a[] = {T(1), T(2), T(3), T(4), T(5)};
+        const unsigned N = sizeof(a)/sizeof(a[0]);
+        std::valarray<T> v(a, N);
+        std::valarray<T> v2;
+        v2 = v;
+        assert(v2.size() == v.size());
+        for (std::size_t i = 0; i < v2.size(); ++i)
+            assert(v2[i] == v[i]);
+        assert(!S::default_ctor_called);
+    }
 }

test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp

 // template<class T> class valarray;
 
 // valarray& operator=(initializer_list<value_type> il);
 
 #include <valarray>
 #include <cassert>
 #include <cstddef>
 
+struct S
+{
+    S() : x_(0) { default_ctor_called = true; }
+    S(int x) : x_(x) {}
+    int x_;
+    static bool default_ctor_called;
+};
+
+bool S::default_ctor_called = false;
+
+bool operator==(const S& lhs, const S& rhs)
+{
+    return lhs.x_ == rhs.x_;
+}
+
 int main()
 {
     {
         typedef int T;
         T a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v2;
         v2 = {1, 2, 3, 4, 5};
int main()
         assert(v2.size() == N);
         for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == a[i].size());
             for (std::size_t j = 0; j < a[i].size(); ++j)
                 assert(v2[i][j] == a[i][j]);
         }
     }
+    {
+        typedef S T;
+        T a[] = {T(1), T(2), T(3), T(4), T(5)};
+        const unsigned N = sizeof(a)/sizeof(a[0]);
+        std::valarray<T> v2;
+        v2 = {T(1), T(2), T(3), T(4), T(5)};
+        assert(v2.size() == N);
+        for (std::size_t i = 0; i < v2.size(); ++i)
+            assert(v2[i] == a[i]);
+        assert(!S::default_ctor_called);
+    }
 }

test/std/numerics/numarray/template.valarray/valarray.cons/default.pass.cpp

 
 // template<class T> class valarray;
 
 // valarray();
 
 #include <valarray>
 #include <cassert>
 
+struct S {
+    S() { ctor_called = true; }
+    static bool ctor_called;
+};
+
+bool S::ctor_called = false;
+
 int main()
 {
     {
         std::valarray<int> v;
         assert(v.size() == 0);
     }
     {
         std::valarray<float> v;
         assert(v.size() == 0);
     }
     {
         std::valarray<double> v;
         assert(v.size() == 0);
     }
     {
         std::valarray<std::valarray<double> > v;
         assert(v.size() == 0);
     }
+    {
+        std::valarray<S> v;
+        assert(v.size() == 0);
+        assert(!S::ctor_called);
+    }
 }

test/std/numerics/numarray/template.valarray/valarray.cons/size.pass.cpp

 
 // template<class T> class valarray;
 
 // explicit valarray(size_t);
 
 #include <valarray>
 #include <cassert>
 
+struct S {
+    S() : x(1) {}
+    ~S() { ++cnt_dtor; }
+    int x;
+    static size_t cnt_dtor;
+};
+
+size_t S::cnt_dtor = 0;
+
 int main()
 {
     {
         std::valarray<int> v(100);
         assert(v.size() == 100);
         for (int i = 0; i < 100; ++i)
             assert(v[i] == 0);
     }
     {
         std::valarray<double> v(100);
         assert(v.size() == 100);
         for (int i = 0; i < 100; ++i)
             assert(v[i] == 0);
     }
     {
         std::valarray<std::valarray<double> > v(100);
         assert(v.size() == 100);
         for (int i = 0; i < 100; ++i)
             assert(v[i].size() == 0);
     }
+    {
+        std::valarray<S> v(100);
+        assert(v.size() == 100);
+        for (int i = 0; i < 100; ++i)
+            assert(v[i].x == 1);
+    }
+    assert(S::cnt_dtor == 100);
 }