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. 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
#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
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/numeric/valarray/operator%3D
