`<valarray>`, opérateurs

Article
10/12/2023

`operator!=`

Teste si les éléments correspondants de deux objets de taille valarray égale sont inégaux ou si tous les éléments d’un valarray objet sont inégaux à une valeur spécifiée.

template <class Type>
valarray<bool>
operator!=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator!=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator!=(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Objet valarray dont les éléments doivent être testés pour l’inégalité par rapport à un autre valarray objet, ou une valeur de type d’élément à comparer à chaque élément d’un valarray.

right
Objet valarray dont les éléments doivent être testés pour l’inégalité par rapport à un autre valarray objet, ou une valeur de type d’élément à comparer à chaque élément d’un valarray.

Valeur retournée

Valeurs valarray booléennes, chacune d’elles étant :

true si les éléments correspondants sont inégaux.
false si les éléments correspondants sont égaux.

Notes

Le premier opérateur de modèle retourne un objet de classe valarray<bool>, chacun des éléments I dont il s’agit left[I] != right[I].

Le deuxième opérateur de modèle stocke left[I] != right dans l’élément I.

Le troisième opérateur de modèle stocke left != right[I] dans l’élément I.

Exemple

// valarray_op_ne.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL != vaR );
   cout << "The element-by-element result of "
        << "the not equal comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the not equal comparison test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator%`

Obtient le reste de la division des éléments correspondants de deux objets de taille valarray égale, ou de la division d’une valarray valeur spécifiée ou de la division d’une valeur spécifiée par un valarray.

template <class Type>
valarray<Type>
operator%(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator%(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator%(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Valeur ou valarray qui sert de dividende dans lequel une autre valeur ou valarray doit être divisée.

right
Valeur ou valarray qui sert de diviseur et qui divise une autre valeur ou valarray.

Valeur retournée

Dont valarray les éléments sont les restes des éléments divisés left par right.

Exemple

// valarray_op_rem.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 6 ), vaR ( 6 );
   valarray<int> vaREM ( 6 );
   for ( i = 0 ; i < 6 ; i += 2 )
      vaL [ i ] =  53;
   for ( i = 1 ; i < 6 ; i += 2 )
      vaL [ i ] =  -67;
   for ( i = 0 ; i < 6 ; i++ )
      vaR [ i ] =  3*i+1;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaREM = ( vaL % vaR );
   cout << "The remainders from the element-by-element "
        << "division is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaREM [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 53 -67 53 -67 53 -67 ).
The initial Right valarray is: ( 1 4 7 10 13 16 ).
The remainders from the element-by-element division is the
valarray: ( 0 -3 4 -7 1 -3 ).

`operator&`

Obtient l’AND au niveau du bit entre les éléments correspondants de deux objets de taille valarray égale, ou entre une valeur et une valarray valeur spécifiée du type d’élément.

template <class Type>
valarray<Type>
operator&(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator&(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator&(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments respectifs doivent être combinés avec l’and au niveau du bit, ou une valeur spécifiée du type d’élément à combiner par bit AND avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments respectifs doivent être combinés avec le bit AND, ou une valeur spécifiée du type d’élément à combiner par bit AND avec chaque élément d’un valarray.

Valeur de retour

Dont valarray les éléments sont la combinaison élément-sage de l’opération AND au niveau du bit de left et right.

Notes

Une opération au niveau du bit peut uniquement être utilisée pour manipuler des bits dans et des char types de données et des variantes, et non pas sur float, , double, long doubleou voidbool d’autres types de données plus complexes.int

L’opérateur de bits AND a la même table de vérité que l’opérateur logique AND, mais il s’applique au type de données au niveau des bits individuels. S’applique operator&& au niveau d’un élément, en comptant toutes les valeurs non nulles en tant que true, et le résultat est une valarray valeur booléenne. Le bit AND operator&, en revanche, peut entraîner une valarray valeur autre que 0 ou 1, en fonction du résultat de l’opération au niveau du bit.

Exemple

// valarray_op_bitand.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaBWA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i+1;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaBWA = ( vaL & vaR );
   cout << "The element-by-element result of "
        << "the bitwise operator & is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaBWA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 2 0 4 0 6 0 8 0 10 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the bitwise operator & is the
valarray: ( 0 0 0 0 0 4 0 0 0 8 ).

`operator&&`

Obtient l’AND logique entre les éléments correspondants de deux objets de taille valarray égale, ou entre une valeur et une valarray valeur spécifiée du valarray type d’élément.

template <class Type>
valarray<bool>
operator&&(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator&&(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator&&(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments respectifs doivent être combinés avec l’AND logique, ou une valeur spécifiée du type d’élément à combiner avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments respectifs doivent être combinés avec l’and logique ou une valeur spécifiée du type d’élément à combiner avec chaque élément d’un valarray.

Valeur retournée

Dont valarray les éléments sont de type bool et sont la combinaison à l’échelle de l’élément de l’opération AND logique de left et right.

Notes

L’AND operator&& logique s’applique au niveau d’un élément, en comptant toutes les valeurs non nulles en tant que true, et le résultat est une valarray valeur booléenne. La version au niveau du bit de AND, operator&en revanche, peut entraîner une valarray valeur autre que 0 ou 1, en fonction du résultat de l’opération au niveau du bit.

Exemple

// valarray_op_logand.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaLAA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is:  ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLAA = ( vaL && vaR );
   cout << "The element-by-element result of "
        << "the logical AND operator&& is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the logical AND operator&& is the
valarray: ( 0 0 0 1 0 1 0 1 0 1 ).

`operator>`

Teste si les éléments d’un valarray sont supérieurs aux éléments d’une taille valarrayégale ou si tous les éléments d’un valarray élément sont supérieurs ou inférieurs à une valeur spécifiée.

template <class Type>
valarray<bool>
operator>(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator>(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator>(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

Valeur retournée

Valeurs valarray booléennes, chacune d’elles étant :

true si l’élément ou la left valeur est supérieur à l’élément ou à la valeur correspondant right .
false si l’élément ou la left valeur n’est pas supérieur à l’élément ou à la valeur correspondant right .

Notes

Si le nombre d’éléments dans les deux valarray objets n’est pas égal, le résultat n’est pas défini.

Exemple

// valarray_op_gt.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i - 1;

   cout << "The initial Left valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL > vaR );
   cout << "The element-by-element result of "
        << "the greater than comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the greater than comparison test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator>=`

Teste si les éléments d’un valarray sont supérieurs ou égaux aux éléments d’une taille valarrayégale, ou si tous les éléments d’un valarray élément sont supérieurs ou inférieurs ou inférieurs à une valeur spécifiée.

template <class Type>
valarray<bool>
operator>=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator>=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator>=(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

Valeur retournée

Valeurs valarray booléennes, chacune d’elles étant :

true si l’élément ou la left valeur est supérieur ou égal à l’élément ou à la valeur correspondant right .
false si l’élément ou la left valeur est inférieur à l’élément ou à la valeur correspondant right .

Notes

Si le nombre d’éléments dans deux valarray objets n’est pas égal, le résultat n’est pas défini.

Exemple

// valarray_op_ge.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i - 1;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL >= vaR );
   cout << "The element-by-element result of "
        << "the greater than or equal test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the greater than or equal test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator>>`

Déplace à droite les bits pour chaque élément d’un valarray nombre spécifié de positions, ou par une quantité d’élément spécifiée par une seconde valarray.

template <class Type>
valarray<Type>
operator>>(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator>>(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator>>(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Valeur à déplacer, ou dont les valarray éléments doivent être décalés.

right
Valeur indiquant la quantité de décalage droit, ou dont valarray les éléments indiquent la quantité d’élément de décalage droit.

Valeur retournée

Dont valarray les éléments ont été décalés vers la droite par la quantité spécifiée.

Notes

Les signes des nombres signés sont préservés.

Exemple

// valarray_op_rs.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  64;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -64;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL >> vaR );
   cout << "The element-by-element result of "
        << "the right shift is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 64 -64 64 -64 64 -64 64 -64 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the right shift is the
valarray: ( 64 -32 16 -8 4 -2 1 -1 ).

`operator<`

Teste si les éléments d’un valarray sont inférieurs aux éléments d’une taille valarrayégale ou si tous les éléments d’un valarray élément sont supérieurs ou inférieurs à une valeur spécifiée.

template <class Type>
valarray<bool>
operator<(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator<(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator<(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

Valeur retournée

Valeurs valarray booléennes, chacune d’elles étant :

true si l’élément ou la left valeur est inférieur à l’élément ou à la valeur correspondant right .
false si l’élément ou la left valeur n’est pas inférieur à l’élément ou à la valeur correspondant right .

Notes

Si le nombre d’éléments dans deux valarray objets n’est pas égal, le résultat n’est pas défini.

Exemple

// valarray_op_lt.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL < vaR );
   cout << "The element-by-element result of "
        << "the less-than comparison test is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the less-than comparison test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator<=`

Teste si les éléments d’un valarray sont inférieurs ou égaux aux éléments d’une taille valarrayégale, ou si tous les éléments d’un valarray élément sont supérieurs ou inférieurs ou inférieurs à une valeur spécifiée.

template <class Type>
valarray<bool>
operator<=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator<=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator<=(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments doivent être comparés, ou une valeur spécifiée à comparer avec chaque élément d’un valarray.

Valeur retournée

Valeurs valarray booléennes, chacune d’elles étant :

true si l’élément ou la left valeur est inférieur ou égal à l’élément ou à la valeur correspondant right .
false si l’élément ou la left valeur est supérieur à l’élément ou à la valeur correspondant right .

Notes

Si le nombre d’éléments dans deux valarray objets n’est pas égal, le résultat n’est pas défini.

Exemple

// valarray_op_le.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i - 1;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL <= vaR );
   cout << "The element-by-element result of "
        << "the less than or equal test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the less than or equal test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator<<`

La gauche déplace les bits pour chaque élément d’un valarray nombre spécifié de positions, ou par une quantité d’élément spécifiée par une seconde valarray.

template <class Type>
valarray<Type>
operator<<(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator<<(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator<<(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Valeur à déplacer, ou dont les valarray éléments doivent être décalés.

right
Valeur indiquant la quantité de décalage gauche, ou dont valarray les éléments indiquent la quantité d’élément de décalage gauche.

Valeur retournée

Dont valarray les éléments ont été décalés vers la gauche par la quantité spécifiée.

Notes

Les signes des nombres signés sont préservés.

Exemple

// valarray_op_ls.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL << vaR );
   cout << "The element-by-element result of "
        << "the left shift is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 1 -1 1 -1 1 -1 1 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the left shift is the
valarray: ( 1 -2 4 -8 16 -32 64 -128 ).

`operator*`

Obtient le produit à l’échelle des éléments entre les éléments correspondants de deux objets de taille valarray égale ou entre une valarray valeur et une valeur spécifiée.

template <class Type>
valarray<Type>
operator*(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator*(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator*(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments doivent être multipliés, ou une valeur spécifiée à multiplier avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments doivent être multipliés, ou une valeur spécifiée à multiplier avec chaque élément d’un valarray.

Valeur retournée

Dont valarray les éléments sont le produit de l’élément et rightleft .

Exemple

// valarray_op_eprod.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  2;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL * vaR );
   cout << "The element-by-element result of "
        << "the multiplication is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 2 -1 2 -1 2 -1 2 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the multiplication is the
valarray: ( 0 -1 4 -3 8 -5 12 -7 ).

`operator+`

Obtient la somme d’éléments entre les éléments correspondants de deux objets de taille valarray égale ou entre une valarray valeur et une valeur spécifiée.

template <class Type>
valarray<Type>
operator+(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator+(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator+(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments doivent être ajoutés, ou une valeur spécifiée à ajouter avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments doivent être ajoutés, ou une valeur spécifiée à ajouter avec chaque élément d’un valarray.

Valeur retournée

Dont valarray les éléments sont la somme left rightdes éléments et .

Exemple

// valarray_op_esum.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  2;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL + vaR );
   cout << "The element-by-element result of "
        << "the sum is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 2 -1 2 -1 2 -1 2 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the sum is the
valarray: ( 2 0 4 2 6 4 8 6 ).

`operator-`

Obtient la différence entre les éléments correspondants de deux objets de taille valarray égale ou entre une valarray valeur et une valeur spécifiée.

template <class Type>
valarray<Type>
operator-(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator-(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator-(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Valeur ou valarray qui sert de minuend, valeur à partir de laquelle d’autres valeurs ou valarray objets doivent être soustraits dans la formation de la différence.

right
Valeur ou valarray qui sert de sous-trahend, valeur à soustraire d’autres valeurs ou valarray objets dans la formation de la différence.

Valeur retournée

Dont valarray les éléments sont la différence avec les éléments et left right.

Notes

Terminologie arithmétique utilisée pour décrire une soustraction :

différence = diminuende – diminuteur

Exemple

// valarray_op_ediff.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  10;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL - vaR );
   cout << "The element-by-element result of "
        << "the difference is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 10 0 10 0 10 0 10 0 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the difference is the
valarray: ( 10 -1 8 -3 6 -5 4 -7 ).

`operator/`

Obtient le quotient par élément entre les éléments correspondants de deux objets de taille valarray égale, ou entre une valarray valeur et une valeur spécifiée.

template <class Type>
valarray<Type>
operator/(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator/(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator/(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Valeur ou valarray qui sert de dividende dans lequel une autre valeur ou valarray doit être divisée en formant le quotient.

right
Valeur ou valarray qui sert de diviseur, et qui divise une autre valeur ou valarray en formant le quotient.

Valeur retournée

Dont valarray les éléments sont le quotient par élément divisé left par right.

Notes

Terminologie arithmétique utilisée pour décrire une division :

quotient = dividende / diviseur

Exemple

// valarray_op_equo.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<double> vaL ( 6 ), vaR ( 6 );
   valarray<double> vaNE ( 6 );
   for ( i = 0 ; i < 6 ; i += 2 )
      vaL [ i ] =  100;
   for ( i = 1 ; i < 6 ; i += 2 )
      vaL [ i ] =  -100;
   for ( i = 0 ; i < 6 ; i++ )
      vaR [ i ] =  2*i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL / vaR );
   cout << "The element-by-element result of "
        << "the quotient is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 100 -100 100 -100 100 -100 ).
The initial Right valarray is: ( 0 2 4 6 8 10 ).
The element-by-element result of the quotient is the
valarray: ( inf -50 25 -16.6667 12.5 -10 ).

`operator==`

Teste si les éléments correspondants de deux objets de taille valarray égale sont égaux ou si tous les éléments d’un valarray sont égaux à une valeur spécifiée.

template <class Type>
valarray<bool>
operator==(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator==(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator==(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments doivent être testés pour l’égalité ou une valeur spécifiée à comparer à chaque valarray élément.

right
Deuxième des deux valarray objets dont les éléments doivent être testés pour l’égalité, ou une valeur spécifiée à comparer à chaque valarray élément.

Valeur de retour

Valeurs valarray booléennes, chacune d’elles étant :

true si les éléments correspondants sont égaux.
false si les éléments correspondants ne sont pas égaux.

Notes

Le premier opérateur de modèle retourne un objet de classe valarray<bool>, chacun des éléments I dont il s’agit left[I] == right[I]. Le deuxième opérateur de modèle stocke left[I] == right dans l’élément I. Le troisième opérateur de modèle stocke left == right[I] dans l’élément I.

Exemple

// valarray_op_eq.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL == vaR );
   cout << "The element-by-element result of "
        << "the equality comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the equality comparison test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator^`

Obtient l’OR exclusif au niveau du bit (XOR) entre les éléments correspondants de deux objets de taille valarray égale, ou entre une valarray valeur et une valeur spécifiée du type d’élément.

template <class Type>
valarray<Type>
operator^(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator^(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator^(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments respectifs doivent être combinés avec le XOR au niveau du bit ou une valeur spécifiée du type d’élément à combiner par un XOR au niveau du bit avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments respectifs doivent être combinés avec le XOR au niveau du bit ou une valeur spécifiée du type d’élément à combiner par un XOR au niveau du bit avec chaque élément d’un valarray.

Valeur retournée

Dont valarray les éléments sont la combinaison élément-sage de l’opération XOR au niveau du bit de left et right.

Notes

L’or exclusif au niveau du bit (XOR) a la sémantique suivante : bits b1 et b2, b1 XOR b2 est 1 si exactement l’un des bits est 1 ; 0 si les deux bits sont 0 ou si les deux bits sont 1.

Exemple

// valarray_op_xor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaLAA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;

   cout << "The initial Left valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLAA = ( vaL ^ vaR );
   cout << "The element-by-element result of "
        << "the bitwise XOR operator^ is the\n"
        << "valarray: ( ";
           for ( i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The initial Right valarray is: ( 0 0 1 3 3 4 6 6 7 9 ).
The element-by-element result of the bitwise XOR operator^ is the
valarray: ( 1 0 0 3 2 4 7 6 6 9 ).

`operator|`

Obtient l’OR au niveau du bit entre les éléments correspondants de deux objets de taille valarray égale ou entre une valarray valeur et une valeur spécifiée du type d’élément.

template <class Type>
valarray<Type>
operator|(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator|(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator|(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments respectifs doivent être combinés avec l’or au niveau du bit ou une valeur spécifiée du type d’élément à combiner par or au niveau du bit avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments respectifs doivent être combinés avec l’or au niveau du bit, ou une valeur spécifiée du type d’élément à combiner par or au niveau du bit avec chaque élément d’un valarray.

Valeur retournée

Dont valarray les éléments sont la combinaison élément-sage de l’opération OR au niveau du bit de left et right.

Notes

L’or au niveau du bit a la même table de vérité que l’OR logique, mais s’applique au type de données au niveau des bits individuels. Les bits b1 et b2 donnés, b1 OR b2 est 1 si au moins un des bits est 1, ou 0 si les deux bits sont 0. L’OR operator|| logique s’applique au niveau d’un élément, en comptant toutes les valeurs non nulles en tant que true, et le résultat est une valarray valeur booléenne. En revanche, l’OR operator|au niveau du bit peut entraîner une valarray valeur autre que 0 ou 1, en fonction du résultat de l’opération au niveau du bit.

Exemple

// valarray_op_bitor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaLAA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;

   cout << "The initial Left valarray is:  ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLAA = ( vaL | vaR );
   cout << "The element-by-element result of "
        << "the bitwise OR operator| is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The initial Right valarray is: ( 0 0 1 3 3 4 6 6 7 9 ).
The element-by-element result of the bitwise OR operator| is the
valarray: ( 1 0 1 3 3 4 7 6 7 9 ).

`operator||`

Obtient l’OR logique entre les éléments correspondants de deux objets de taille valarray égale, ou entre une valeur et une valarray valeur spécifiée du type d’élément valarray .

template <class Type>
valarray<bool>
operator||(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator||(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator||(
    const Type& left,
    const valarray<Type>& right);

Paramètres

left
Premier des deux valarray objets dont les éléments respectifs doivent être combinés avec l’OR logique, ou une valeur spécifiée du type d’élément à combiner avec chaque élément d’un valarray.

right
Deuxième des deux valarray objets dont les éléments respectifs doivent être combinés avec l’OR logique, ou une valeur spécifiée du type d’élément à combiner avec chaque élément d’un valarray.

Valeur retournée

Dont valarray les éléments sont de type bool et sont la combinaison à l’échelle de l’élément de l’opération OR logique de left et right.

Notes

L’OR operator|| logique s’applique au niveau d’un élément, en comptant toutes les valeurs non nulles en tant que true, et le résultat est une valarray valeur booléenne. La version au niveau du bit de OR, operator|en revanche, peut entraîner une valarray valeur autre que 0 ou 1, en fonction du résultat de l’opération au niveau du bit.

Exemple

// valarray_op_logor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaLOR ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  0;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  0;

   cout << "The initial Left valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLOR = ( vaL || vaR );
   cout << "The element-by-element result of "
        << "the logical OR operator|| is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaLOR [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The initial Right valarray is: ( 0 0 0 3 0 0 6 0 0 9 ).
The element-by-element result of the logical OR operator|| is the
valarray: ( 0 0 0 1 0 1 1 1 0 1 ).

Partager via

<valarray>, opérateurs

operator!=

Paramètres

Valeur retournée

Notes

Exemple

operator%

Paramètres

Valeur retournée

Exemple

operator&

Paramètres

Valeur de retour

Notes

Exemple

operator&&

Paramètres

Valeur retournée

Notes

Exemple

operator>

Paramètres

Valeur retournée

Notes

Exemple

operator>=

Paramètres

Valeur retournée

Notes

Exemple

operator>>

Paramètres

Valeur retournée

Notes

Exemple

operator<

Paramètres

Valeur retournée

Notes

Exemple

operator<=

Paramètres

Valeur retournée

Notes

Exemple

operator<<

Paramètres

Valeur retournée

Notes

Exemple

operator*

Paramètres

Valeur retournée

Exemple

operator+

Paramètres

Valeur retournée

Exemple

operator-

Paramètres

Valeur retournée

Notes

Exemple

operator/

Paramètres

Valeur retournée

Notes

Exemple

operator==

Paramètres

Valeur de retour

Notes

Exemple

operator^

Paramètres

Valeur retournée

Notes

Exemple

operator|

`<valarray>`, opérateurs

`operator!=`

`operator%`

`operator&`

`operator&&`

`operator>`

`operator>=`

`operator>>`

`operator<`

`operator<=`

`operator<<`

`operator*`

`operator+`

`operator-`

`operator/`

`operator==`

`operator^`

`operator|`

`operator||`