# std::valarray<T>::operator=

> C++ Atlas: `cppatlas.com/w/cpp/numeric/valarray/operator=` | Source: https://en.cppreference.com/w/cpp/numeric/valarray/operator= | Domain: Numerics | Standards: C++11

Replaces the contents of the numeric array.

## Official Specification Summary (cppreference)

```cpp
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

```cpp
#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:

```text
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 |

---
Attribution: content from https://en.cppreference.com/w/cpp/numeric/valarray/operator= (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.