Namespaces
Variants

    std::valarray<T>::operator+=,-=,*=,/=,%=,&=,|=,<<=,>>=

    Von de.cppreference.net
     
    C++
     
    Numerikbibliothek
     
    std::valarray
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Hilfsklassen
    Ableitungsleitfäden (C++17)
     
    valarray<T>& operator+=( const valarray<T>& v );
valarray<T>& operator-=( const valarray<T>& v );
valarray<T>& operator*=( const valarray<T>& v );
valarray<T>& operator/=( const valarray<T>& v );
valarray<T>& operator%=( const valarray<T>& v );
valarray<T>& operator&=( const valarray<T>& v );
valarray<T>& operator|=( const valarray<T>& v );
valarray<T>& operator^=( const valarray<T>& v );
valarray<T>& operator<<=( const valarray<T>& v );
valarray<T>& operator>>=( const valarray<T>& v );
    		(1) 
    valarray<T>& operator+=( const T& val );
valarray<T>& operator-=( const T& val );
valarray<T>& operator*=( const T& val );
valarray<T>& operator/=( const T& val );
valarray<T>& operator%=( const T& val );
valarray<T>& operator&=( const T& val );
valarray<T>& operator|=( const T& val );
valarray<T>& operator^=( const T& val );
valarray<T>& operator<<=( const T& val );
valarray<T>& operator>>=( const T& val );
    		(2)

    Wendet zusammengesetzte Zuweisungsoperatoren auf jedes Element im numerischen Array an.

    1) Jedem Element wird der Wert zugewiesen, der durch Anwenden des entsprechenden Operators auf den vorherigen Wert des Elements und das entsprechende Element von v erhalten wird.
    Das Verhalten ist undefiniert, wenn size() != v.size().
    Das Verhalten ist undefiniert, wenn einer der Werte in v während der Zuweisung berechnet wird und von einem der Werte in *this abhängt, das heißt, der Ausdruck auf der rechten Seite der Zuweisung bezieht sich auf eine Variable auf der linken Seite der Zuweisung.
    2) Jedem Element wird der Wert zugewiesen, der durch Anwenden des entsprechenden Operators auf den vorherigen Wert des Elements und den Wert von val erhalten wird.

    Parameter

    v - ein weiteres numerisches Array
    val - ein Wert

    Rückgabewert

    * this

    Exceptions

    Kann implementierungsdefinierte Ausnahmen auslösen.

    Hinweise

    Jeder der Operatoren kann nur instanziiert werden, wenn die folgenden Anforderungen erfüllt sind:

    • Der angegebene Operator kann auf den Typ T angewendet werden.
    • Der Ergebniswert kann eindeutig in T konvertiert werden.

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <string_view>
#include <type_traits>
#include <valarray>
void o(std::string_view rem, auto const& v, bool nl = false)
{
    if constexpr (std::is_scalar_v<std::decay_t<decltype(v)>>)
        std::cout << rem << " : " << v;
    else
    {
        for (std::cout << rem << " : { "; auto const e : v)
            std::cout << e << ' ';
        std::cout << '}';
    }
    std::cout << (nl ? "\n" : ";  ");
}
int main()
{
    std::valarray<int> x, y;
    o("x", x = {1, 2, 3, 4}), o("y", y = {4, 3, 2, 1}), o("x += y", x += y, 1);
    o("x", x = {4, 3, 2, 1}), o("y", y = {3, 2, 1, 0}), o("x -= y", x -= y, 1);
    o("x", x = {1, 2, 3, 4}), o("y", y = {5, 4, 3, 2}), o("x *= y", x *= y, 1);
    o("x", x = {1, 3, 4, 7}), o("y", y = {1, 1, 3, 5}), o("x &= y", x &= y, 1);
    o("x", x = {0, 1, 2, 4}), o("y", y = {4, 3, 2, 1}), o("x <<=y", x <<=y, 1);
    std::cout << '\n';
    o("x", x = {1, 2, 3, 4}), o("x += 5", x += 5, 1);
    o("x", x = {1, 2, 3, 4}), o("x *= 2", x *= 2, 1);
    o("x", x = {8, 6, 4, 2}), o("x /= 2", x /= 2, 1);
    o("x", x = {8, 4, 2, 1}), o("x >>=1", x >>=1, 1);
}

    Ausgabe: 

    x : { 1 2 3 4 };  y : { 4 3 2 1 };  x += y : { 5 5 5 5 }
x : { 4 3 2 1 };  y : { 3 2 1 0 };  x -= y : { 1 1 1 1 }
x : { 1 2 3 4 };  y : { 5 4 3 2 };  x *= y : { 5 8 9 8 }
x : { 1 3 4 7 };  y : { 1 1 3 5 };  x &= y : { 1 1 0 5 }
x : { 0 1 2 4 };  y : { 4 3 2 1 };  x <<=y : { 0 8 8 8 }
x : { 1 2 3 4 };  x += 5 : { 6 7 8 9 }
x : { 1 2 3 4 };  x *= 2 : { 2 4 6 8 }
x : { 8 6 4 2 };  x /= 2 : { 4 3 2 1 }
x : { 8 4 2 1 };  x >>=1 : { 4 2 1 0 }

    Siehe auch

    		wendet einen unären arithmetischen Operator auf jedes Element des valarray an
    (öffentliche Mitgliedsfunktion)
    		wendet binäre Operatoren auf jedes Element von zwei valarrays oder eines valarray und eines Wertes an
    (Funktions-Template)