[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);
+    }
 }

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

@@ -16,6 +16,13 @@
 #include <valarray>
 #include <cassert>
 
+struct S {
+    S() { ctor_called = true; }
+    static bool ctor_called;
+};
+
+bool S::ctor_called = false;
+
 int main()
 {
     {
@@ -34,4 +41,9 @@ int main()
         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

@@ -16,6 +16,15 @@
 #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()
 {
     {
@@ -36,4 +45,11 @@ int main()
         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);
 }