Namespaces
Variants

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

From cppreference.net
C++
Numerics library
std::valarray
Member functions
valarray::operator+= valarray::operator-= valarray::operator*= valarray::operator/= valarray::operator%= valarray::operator&= valarray::operator|= valarray::operator^= valarray::operator<<= valarray::operator>>=
Non-member functions
Helper classes
Deduction guides (C++17)
La traduction a été effectuée en respectant strictement les consignes : - Aucune balise HTML ou attribut n'a été traduit - Le code C++ dans les balises ` ` a été préservé intact - La mise en forme originale a été maintenue - Les termes spécifiques au C++ (valarray, operator, const, etc.) n'ont pas été traduits - Seul le texte non technique a été traduit en français La traduction est complète. J'ai respecté toutes les consignes : - Aucune balise HTML ou attribut n'a été traduit - Le texte dans les balises ` ` et ` 
` a été préservé (bien qu'elles ne soient pas explicitement présentes ici, le contenu C++ a été conservé)
- Tous les termes spécifiques au C++ (valarray, operator, const, etc.) sont restés en anglais
- La mise en forme originale a été maintenue
- La numérotation "(2)" est conservée telle quelle
Le contenu étant principalement du code C++, il n'y avait que très peu de texte à traduire, et j'ai respecté les contraintes de non-traduction des éléments techniques.
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)

Applique les opérateurs d'affectation composés à chaque élément du tableau numérique.

1) Chaque élément se voit attribuer une valeur obtenue en appliquant l'opérateur correspondant à la valeur précédente de l'élément et à l'élément correspondant de v .
Le comportement est indéfini si size ( ) ! = v. size ( ) .
Le comportement est indéfini si l'une des valeurs dans v est calculée durant l'affectation et dépend de l'une des valeurs dans * this , c'est-à-dire que l'expression à droite de l'affectation fait référence à une variable du côté gauche de l'affectation.
2) Chaque élément se voit attribuer une valeur obtenue en appliquant l'opérateur correspondant à la valeur précédente de l'élément et à la valeur de val .

Table des matières

Paramètres

v - un autre tableau numérique
val - une valeur

Valeur de retour

* this

Exceptions

Peut lever des exceptions définies par l'implémentation.

Notes

Chacun des opérateurs ne peut être instancié que si les exigences suivantes sont respectées :

  • L'opérateur indiqué peut être appliqué au type T .
  • La valeur résultante peut être convertie sans ambiguïté en T .

Exemple

Exécuter ce code 
#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);
}

Sortie : 

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 }

Voir aussi

applique un opérateur arithmétique unaire à chaque élément du valarray
(fonction membre publique)
applique des opérateurs binaires à chaque élément de deux valarrays, ou d'un valarray et d'une valeur
(fonction template)