std::valarray<T>::operator=

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
LWG 624	C++98	the behaviors of overloads (4-7) were unclear if the length of other is not `size()`	the behaviors are undefined in this case
LWG 630	C++98	the behavior of the copy assignment operator was undefined if size() != other.size()	resizes *this first in this case
LWG 2071	C++11	the move assignment operator resized *this if size() != other.size()	not required to resize in this case

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries