[libcxx] Avoid spurious construction of valarray elements

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.


Reviewers: EricWF, mclow.lists

Reviewed By: mclow.lists

Subscribers: rogfer01, cfe-commits

Differential Revision: https://reviews.llvm.org/D41992

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@324596 91177308-0d34-0410-b5e6-96231b3b80d8

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

@@ -17,6 +17,21 @@
 #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()
 {
     {
@@ -56,4 +71,16 @@ int main()
                 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

@@ -19,6 +19,21 @@
 #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()
 {
     {
@@ -55,4 +70,15 @@ int main()
                 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);
+    }
 }