Namespaces
Variants

operator+,-,*,/,%,&,|,^,<<,>>,&&,|| (std::valarray)

From cppreference.net
C++
Numerics library
std::valarray
Member functions
Non-member functions
operator* operator/ operator% operator+ operator- operator^ operator& operator| operator<< operator>> operator&& operator||

Helper classes
Deduction guides (C++17)
Défini dans l'en-tête <valarray>
template < class T >

std:: valarray **Note:** Le texte a été laissé en anglais car : - `std::valarray` est un terme spécifique au C++ qui ne doit pas être traduit - La structure HTML et les attributs ont été préservés comme demandé - Le formatage original a été maintenu < T > operator + ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator - ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator * ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator / ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator % ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator & ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator | ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator ^ ( const std:: valarray < T > & lhs, const std:: valarray **Note:** Le texte a été laissé en anglais car : - `std::valarray` est un terme spécifique au C++ qui ne doit pas être traduit - La structure HTML et les attributs ont été préservés comme demandé - Le formatage original a été maintenu < T > & rhs ) ;
template < class T >
std:: valarray < T > operator << ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator >> ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < bool > operator && ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
template < class T >

std:: valarray < bool > operator || ( const std:: valarray < T > & lhs, const std:: valarray < T > & rhs ) ;
(1)
template < class T >

std:: valarray < T > operator + ( const typename std:: valarray **Note:** Le texte a été laissé en anglais car : - `std::valarray` est un terme spécifique au C++ qui ne doit pas être traduit - La structure HTML et les attributs ont été préservés comme demandé - Le formatage original a été maintenu < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator - ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator * ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator / ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator % ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator & ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator | ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator ^ ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator << ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < T > operator >> ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < bool > operator && ( const typename std:: valarray < T > :: value_type & val,
const std:: valarray < T > & rhs ) ;
template < class T >
std:: valarray < bool > operator || ( const typename std:: valarray < T > :: value_type & val,

const std:: valarray < T > & rhs ) ;
(2)
template < class T >

std:: valarray < T > operator + ( const std:: valarray < T > & lhs,
const typename std:: valarray **Note:** Le texte a été laissé en anglais car : - `std::valarray` est un terme spécifique au C++ qui ne doit pas être traduit - La structure HTML et les attributs ont été préservés comme demandé - Le formatage original a été maintenu < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator - ( const std:: valarray **Note:** Le texte a été laissé en anglais car : - `std::valarray` est un terme spécifique au C++ qui ne doit pas être traduit - La structure HTML et les attributs ont été préservés comme demandé - Le formatage original a été maintenu < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator * ( const std:: valarray < T > & lhs,
const typename std:: valarray **Note:** Le texte a été laissé en anglais car : - `std::valarray` est un terme spécifique au C++ qui ne doit pas être traduit - La structure HTML et les attributs ont été préservés comme demandé - Le formatage original a été maintenu < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator / ( const std:: valarray < T > & lhs,
const typename std:: valarray **Explication :** - Les balises HTML (` `, ` `) et leurs attributs (`href`, `class`) sont conservés intacts - Le terme C++ `std::valarray` n'est pas traduit conformément aux consignes - La structure et la mise en forme originales sont préservées - Aucun texte supplémentaire ne nécessitait une traduction en français dans cet exemple < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator % ( const std:: valarray < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator & ( const std:: valarray < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator | ( const std:: valarray < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator ^ ( const std:: valarray < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray < T > operator << ( const std:: valarray < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray **Note:** Le texte à traduire était uniquement "Do not translate any HTML tags or attributes. Preserve the original formatting.Do not translate text within , 

,  tags.Don't translate C++ specific terms. Requires precision and professionalism." qui sont les instructions, et le contenu HTML fourni ne contient que des termes C++ (`std::valarray`) qui ne doivent pas être traduits selon les consignes.
< T > operator >> ( const std:: valarray < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray < bool > operator && ( const std:: valarray < T > & lhs,
const typename std:: valarray < T > :: value_type & val ) ;
template < class T >
std:: valarray < bool > operator || ( const std:: valarray < T > & lhs,

const typename std:: valarray < T > :: value_type & val ) ;
(3)

Applique des opérateurs binaires à chaque élément de deux valarrays, ou d'un valarray et d'une valeur.

1) Les opérateurs fonctionnent sur des valarrays de même taille et retournent un valarray de même taille que les paramètres avec l'opération appliquée à chaque élément des deux arguments.
2,3) Applique l'opérateur entre chaque élément du valarray et le scalaire.

Table des matières

Paramètres

rhs - un tableau numérique
lhs - un tableau numérique
val - une valeur de type T

Valeur de retour

Un valarray de même taille que le paramètre.

Note

Le comportement n'est pas défini lorsque les deux arguments sont des valarrays de tailles différentes.

La fonction peut être implémentée avec un type de retour différent de std::valarray . Dans ce cas, le type de remplacement possède les propriétés suivantes :

Exemple

Trouve les racines réelles de plusieurs équations quadratiques .

Exécuter ce code 
#include <cstddef>
#include <iostream>
#include <valarray>
int main()
{
    std::valarray<double> a(1, 8);
    std::valarray<double> b{1, 2, 3, 4, 5, 6, 7, 8};
    std::valarray<double> c = -b;
    // literals must also be of type T until LWG3074 (double in this case)
    std::valarray<double> d = std::sqrt(b * b - 4.0 * a * c);
    std::valarray<double> x1 = 2.0 * c / (-b + d);
    std::valarray<double> x2 = 2.0 * c / (-b - d);
    std::cout << "quadratic equation:  root 1:    root 2:   b: c:\n";
    for (std::size_t i = 0; i < a.size(); ++i)
        std::cout << a[i] << "\u00B7x\u00B2 + " << b[i] << "\u00B7x + "
                  << c[i] << " = 0  " << std::fixed << x1[i]
                  << "  " << x2[i] << std::defaultfloat
                  << "  " << -x1[i] - x2[i]
                  << "  " << x1[i] * x2[i] << '\n';
}

Sortie : 

quadratic equation:  root 1:    root 2:   b: c:
1·x² + 1·x + -1 = 0  -1.618034  0.618034  1  -1
1·x² + 2·x + -2 = 0  -2.732051  0.732051  2  -2
1·x² + 3·x + -3 = 0  -3.791288  0.791288  3  -3
1·x² + 4·x + -4 = 0  -4.828427  0.828427  4  -4
1·x² + 5·x + -5 = 0  -5.854102  0.854102  5  -5
1·x² + 6·x + -6 = 0  -6.872983  0.872983  6  -6
1·x² + 7·x + -7 = 0  -7.887482  0.887482  7  -7
1·x² + 8·x + -8 = 0  -8.898979  0.898979  8  -8

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR S'applique à Comportement tel que publié Comportement correct
LWG 3074 C++98 T est déduit à la fois du scalaire et du valarray pour (2,3) , empêchant les appels de types mixtes déduire uniquement T à partir du valarray

Voir aussi

applique un opérateur arithmétique unaire à chaque élément du valarray
(fonction membre publique)
applique un opérateur d'affectation composée à chaque élément du valarray
(fonction membre publique)