std::valarray::operator=(3)

NAME
std::valarray::operator= - std::valarray::operator=

Synopsis
   valarray<T>& operator=( const valarray<T>& other ); (1)
   valarray<T>& operator=( valarray<T>&& other ) noexcept; (2) (since C++11)
   valarray<T>& operator=( const T& val ); (3)
   valarray<T>& operator=( const std::slice_array<T>& other ); (4)
   valarray<T>& operator=( const std::gslice_array<T>& other ); (5)
   valarray<T>& operator=( const std::mask_array<T>& other ); (6)
   valarray<T>& operator=( const std::indirect_array<T>& other ); (7)
   valarray<T>& operator=( std::initializer_list<T> il ); (8) (since C++11)
   Replaces the contents of the numeric array.
   1) Copy assignment operator. If size() != other.size(), first resizes *this as if by
   resize(other.size()). Each element of *this is assigned the value of the
   corresponding element of other.
   2) Move assignment operator. Replaces the contents of *this with those of other. The
   value of other is unspecified after this operation. The complexity of this operation
   may be linear if T has non-trivial destructors, but is usually constant otherwise.
   3) Replaces each value in *this with a copy of val.
   4-7) Replaces the contents of *this with the result of a generalized subscripting
   operation. The behavior is undefined if size() does not equal the length of other or
   if any value on the left depends on the value on the right (e.g. v = v[v > 2]).
   8) Assigns the contents of initializer list il. Equivalent to *this = valarray(il).

Parameters
   other - another numeric array (or a mask) to assign
   val - the value to initialize each element with
   il - initializer list to assign

Return value
   *this

Exceptions
   1,3-8) May throw implementation-defined exceptions.

Example
// Run this code
 #include <iomanip>
 #include <iostream>
 #include <valarray>
 void print(const char* rem, const std::valarray<int>& v)
 {
     std::cout << std::left << std::setw(36) << rem << std::right;
     for (int n : v)
         std::cout << std::setw(3) << n;
     std::cout << '\n';
 }
 int main()
 {
     std::valarray<int> v1(3);
     v1 = -1; // (3) from a scalar
     print("assigned from scalar: ", v1);
     v1 = {1, 2, 3, 4, 5, 6}; // (8): from initializer list of different size
     print("assigned from initializer_list:", v1);
     std::valarray<int> v2(3);
     v2 = v1[std::slice(0, 3, 2)]; // (4): from slice array
     print("every 2nd element starting at pos 0:", v2);
     v2 = v1[v1 % 2 == 0]; // (6): from mask array
     print("values that are even:", v2);
     std::valarray<std::size_t> idx = {0, 1, 2, 4}; // index array
     v2.resize(4); // sizes must match when assigning from gen subscript
     v2 = v1[idx]; // (7): from indirect array
     print("values at positions 0, 1, 2, 4:", v2);
 }

Output:
 assigned from scalar: -1 -1 -1
 assigned from initializer_list: 1 2 3 4 5 6
 every 2nd element starting at pos 0: 1 3 5
 values that are even: 2 4 6
 values at positions 0, 1, 2, 4: 1 2 3 5
   Defect reports
   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.
      DR Applied to Behavior as published Correct behavior
                       the behaviors of overloads (4-7) were the behaviors are
   LWG 624 C++98 unclear if the length of other is not undefined in this case
                       size()
                       the behavior of the copy assignment resizes *this
   LWG 630 C++98 operator first in this case
                       was undefined if size() != other.size()
   LWG 2071 C++11 the move assignment operator resized not required to
                       *this if size() != other.size() resize in this case