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. Each element of *this is assigned the value of the
   corresponding element of other. If the length of other does not equal the length of
   *this,
   the behavior is undefined
   (until C++11)
   first resizes as if by resize(other.size())
   (since C++11).
   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 the length of the argument does not equal
   the length of *this 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