Classe `valarray`

Article
10/12/2023

Le modèle valarray<Type> de classe décrit un objet qui contrôle une séquence d’éléments de type Type stockés sous forme de tableau, conçu pour les opérations mathématiques à grande vitesse et optimisé pour les performances de calcul.

Notes

La classe est une représentation du concept mathématique d’un ensemble ordonné de valeurs. Ses éléments sont numérotés séquentiellement de zéro. La classe est décrite comme un conteneur proche, car elle prend en charge certaines fonctionnalités, mais pas toutes, des fonctionnalités que les conteneurs de séquence de première classe, tels que vector, prennent en charge. Il diffère du modèle vector de classe de deux façons importantes :

Il définit de nombreuses opérations arithmétiques entre les éléments correspondants des valarray<Type> objets du même type et de la même longueur, comme varr_x* = cos(varr_y) + sin(varr_z).
Il définit différentes façons intéressantes d’subscripteur d’un valarray<Type> objet, en surchargeant operator[].

Objet de classe Type:

a un constructeur public par défaut, un destructeur, un constructeur de copie et un opérateur d'affectation, avec un comportement conventionnel.
définit selon les besoins les opérateurs arithmétiques et les fonctions mathématiques qui sont définies pour les types à virgule flottante, avec un comportement conventionnel.

En particulier, aucune différence même minime ne peut exister entre la construction de copie et la construction par défaut suivie de l'affectation. Aucune des opérations sur les objets de classe Type ne peut lever d’exceptions.

Membres

Constructeurs

Nom	Description
`valarray`	Construit un `valarray` de taille spécifique ou avec des éléments d'une valeur spécifique, ou comme copie d'un autre `valarray` ou comme sous-ensemble d'un autre `valarray`.

Typedefs

Nom	Description
`value_type`	Type qui représente le type des éléments stockés dans un `valarray`.

Functions

Nom	Description
`apply`	Applique une fonction spécifiée à chaque élément d'un `valarray`.
`cshift`	Déplace de façon cyclique tous les éléments d'un `valarray` d'un nombre spécifié de positions.
`free`	Libère la mémoire utilisée par le `valarray`.
`max`	Recherche l'élément le plus grand dans un `valarray`.
`min`	Recherche l'élément le plus petit dans un `valarray`.
`resize`	Change le nombre d'éléments d'un `valarray` pour un nouveau nombre spécifié, en ajoutant ou en supprimant des éléments selon les besoins.
`shift`	Déplace tous les éléments d'un `valarray` d'un nombre spécifié de positions.
`size`	Trouve le nombre d'éléments d'un `valarray`.
`sum`	Détermine la somme de tous les éléments d'un `valarray` d'une longueur différente de zéro.
`swap`

Opérateurs

Nom	Description
`operator!`	Opérateur unaire qui obtient les valeurs NOT (`!`) logiques de chaque élément d’un `valarray`.
`operator%=`	Obtient le reste de la division (élément par élément) des éléments d'un tableau par un `valarray` spécifié ou par une valeur du type d'élément.
`operator&=`	Obtient le bit AND (`&`) d’éléments d’un tableau avec les éléments correspondants dans un élément spécifié `valarray` ou avec une valeur du type d’élément.
`operator>>=`	Décale vers la droite les bits pour chaque élément d'un opérande `valarray` d'un nombre spécifié de positions ou d'une quantité élément par élément spécifiée par un second `valarray`.
`operator<<=`	Décale vers la gauche les bits pour chaque élément d'un opérande `valarray` d'un nombre spécifié de positions ou d'une quantité élément par élément spécifiée par un second `valarray`.
`operator*=`	Multiplie les éléments d'un `valarray` spécifié ou une valeur du type d'élément, élément par élément, avec un `valarray` opérande.
`operator+`	Un opérateur unaire qui applique un plus à chaque élément d'un `valarray`. Sur les types arithmétiques normaux, cet opérateur n’a aucun effet.
`operator+=`	Ajoute les éléments d'un `valarray` spécifié ou une valeur du type d'élément, élément par élément, à un `valarray` opérande.
`operator-`	Opérateur unaire qui applique une négation arithmétique à chaque élément d’un `valarray`.
`operator-=`	Soustrait les éléments d'un `valarray` spécifié ou une valeur du type d'élément, élément par élément, d'un `valarray` opérande.
`operator/=`	Divise un `valarray` opérande, élément par élément, par les éléments d'un `valarray` spécifié ou par une valeur du type d'élément.
`operator=`	Affecte des éléments à un `valarray` dont les valeurs sont spécifiées directement ou comme une partie d'un autre `valarray`, ou par un `slice_array`, `gslice_array`, `mask_array` ou `indirect_array`.
`operator[]`	Retourne une référence à un élément ou sa valeur à l'index spécifié, ou un sous-ensemble spécifié.
`operator^=`	Obtient l’exclusivité au niveau du bit ou (`^`) d’un `valarray` avec une valeur spécifiée `valarray` ou une valeur du type d’élément.
`operator\|=`	Obtient l’OR au niveau du bit (`\|`) d’éléments d’un tableau avec les éléments correspondants dans un élément spécifié `valarray` ou avec une valeur du type d’élément.
`operator~`	Opérateur unaire qui obtient les valeurs de complément au niveau du bit (`~`) de chaque élément d’un `valarray`.

`apply`

Applique une fonction spécifiée à chaque élément d'un valarray.

valarray<Type> apply(Type function_object(Type)) const;

valarray<Type> apply(Type function_object(const Type&)) const;

Paramètres

function_object(Type)
Objet de fonction à appliquer à chaque élément de l’opérande valarray.

function_object(const Type&)
Objet de fonction pour const les éléments à appliquer à chaque élément de l’opérande valarray.

Valeur retournée

Dont valarray les éléments ont appliqué function_object les éléments de manière élémentaire aux éléments de l’opérande valarray.

Notes

La fonction membre retourne un objet de classe valarray<Type>, de longueur size, chacun des éléments elem dont le résultat function_object((*this)[elem])est .

Exemple

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

using namespace std;

int __cdecl MyApplyFunc( int n )
{
   return n*2;
}

int main( int argc, char* argv[] )
{
   valarray<int> vaR(10), vaApplied(10);
   int i;

   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] = -i;

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

   vaApplied = vaR.apply( MyApplyFunc );

   cout << "The element-by-element result of "
       << "applying MyApplyFunc to vaR is the\nvalarray: ( ";
   for ( i = 0; i < 10; ++i )
      cout << " " << vaApplied[i];
   cout << " )" << endl;
}

The initial Right valarray is: ( 0 0 -2 3 0 -5 6 0 -8 9 )
The element-by-element result of applying MyApplyFunc to vaR is the
valarray: (  0 0 -4 6 0 -10 12 0 -16 18 )

`cshift`

Déplace de façon cyclique tous les éléments d'un valarray d'un nombre spécifié de positions.

valarray<Type> cshift(int count) const;

Paramètres

count
Le nombre d’emplacements qui servira à décaler les éléments vers l’avant.

Valeur retournée

valarray Nouvelle dans laquelle tous les éléments ont été déplacés count de manière cyclique vers l’avant du , ou vers la valarraygauche par rapport à leurs positions dans l’opérande valarray.

Notes

Une valeur positive de count décale les éléments de façon cyclique vers la gauche de count emplacements.

Une valeur négative de count décale les éléments de façon cyclique vers la droite de count emplacements.

Exemple

// valarray_cshift.cpp
// compile with: /EHsc

#include <valarray>
#include <iostream>

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

    valarray<int> va1(10), va2(10);
    for (i = 0; i < 10; i+=1)
        va1[i] = i;
    for (i = 0; i < 10; i+=1)
        va2[i] = 10 - i;

    cout << "The operand valarray va1 is: (";
    for (i = 0; i < 10; i++)
        cout << " " << va1[i];
    cout << ")" << endl;

    // A positive parameter shifts elements right
    va1 = va1.cshift(4);
    cout << "The cyclically shifted valarray va1 is:\nva1.cshift (4) = (";
    for (i = 0; i < 10; i++)
        cout << " " << va1[i];
    cout << ")" << endl;

    cout << "The operand valarray va2 is: (";
    for (i = 0; i < 10; i++)
        cout << " " << va2[i];
    cout << ")" << endl;

    // A negative parameter shifts elements left
    va2 = va2.cshift(-4);
    cout << "The cyclically shifted valarray va2 is:\nva2.shift (-4) = (";
    for (i = 0; i < 10; i++)
        cout << " " << va2[i];
    cout << ")" << endl;
}

The operand valarray va1 is: ( 0 1 2 3 4 5 6 7 8 9)
The cyclically shifted valarray va1 is:
va1.cshift (4) = ( 4 5 6 7 8 9 0 1 2 3)
The operand valarray va2 is: ( 10 9 8 7 6 5 4 3 2 1)
The cyclically shifted valarray va2 is:
va2.shift (-4) = ( 4 3 2 1 10 9 8 7 6 5)

`free`

Libère la mémoire utilisée par le valarray.

void free();

Notes

Cette fonction non standard est équivalente à l’affectation d’une fonction vide valarray. Par exemple :

valarray<T> v;
v = valarray<T>();

// equivalent to v.free()

`max`

Recherche l'élément le plus grand dans un valarray.

Type max() const;

Valeur retournée

Valeur maximale des éléments dans l’opérande valarray.

Notes

La fonction membre compare les valeurs en appliquant un opérateur ou un opérateur>< entre des paires d’éléments de classe Type, pour lesquels les opérateurs doivent être fournis pour l’élément .Type

Exemple

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

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

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

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

   MaxValue = vaR.max (  );
   cout << "The largest element in the valarray is: "
        << MaxValue  << "." << endl;
}

The operand valarray is: ( 0 1 8 3 7 5 6 13 2 9 ).
The largest element in the valarray is: 13.

`min`

Recherche l'élément le plus petit dans un valarray.

Type min() const;

Valeur retournée

Valeur minimale des éléments dans l’opérande valarray.

Notes

Exemple

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

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

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

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

   MinValue = vaR.min ( );
   cout << "The smallest element in the valarray is: "
        << MinValue  << "." << endl;
}
/* Output:
The operand valarray is: ( 0 2 3 -3 8 0 -6 14 -3 -9 ).
The smallest element in the valarray is: -9.
*/

`operator!`

Opérateur unaire qui obtient les valeurs NOT (!) logiques de chaque élément d’un valarray.

valarray<bool> operator!() const;

Valeur retournée

Valeurs valarray booléennes qui sont la négation logique des valeurs d’élément de l’opérande valarray.

Notes

L’opération logique NOT, indiquée par !, annule logiquement les éléments, car elle convertit toutes les valeurs nulles en true et toutes les valeurs non nulles en false. Le retour valarray de valeurs booléennes est de la même taille que l’opérande valarray.

Exemple

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

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

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

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

   vaNOT = !vaL;
   cout << "The element-by-element result of "
        << "the logical NOT operator! is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNOT [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The element-by-element result of the logical NOT operator! is the
valarray: ( 1 1 1 0 1 0 1 0 1 0 ).

`operator%=`

Obtient le reste de la division (élément par élément) des éléments d'un tableau par un valarray spécifié ou par une valeur du type d'élément.

valarray<Type>& operator%=(const valarray<Type>& right);

valarray<Type>& operator%=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celui de l’opérande valarray à diviser, à l’échelle de l’élément, à l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont le reste de la division élément-sage de l’opérande valarray par right.

Exemple

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

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

   valarray<int> vaL ( 6 ), vaR ( 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 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;

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

The initial 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 le bit AND (&) d’éléments d’un tableau avec les éléments correspondants dans un élément spécifié valarray ou avec une valeur du type d’élément.

valarray<Type>& operator&=(const valarray<Type>& right);

valarray<Type>& operator&=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celle de l’opérande valarray qui doit être combinée, à l’échelle de l’élément, par le bit AND (&) avec l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont le bit AND (&) de l’opérande valarray par right

Notes

Une opération au niveau du bit ne peut être utilisée que pour manipuler des bits dans des types de données intégraux, tels que char et int. Il ne fonctionne pas sur float, , double, long doublevoid, , boolou d’autres types de données plus complexes.

Le bit AND (&) s’applique au type de données au niveau des bits individuels. Les bits donnés b1 et b2, b1 & b2 est 1 si les deux bits sont 1 ; 0 si au moins un bit est 0.

Exemple

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

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

   valarray<int> vaL ( 10 ), vaR ( 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 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;

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

The initial 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 bitwise AND operator&= is the
valarray: ( 0 0 0 2 0 4 0 6 0 8 ).

`operator>>=`

Décale vers la droite les bits pour chaque élément d'un opérande valarray d'un nombre spécifié de positions ou d'une quantité élément par élément spécifiée par un second valarray.

valarray<Type>& operator>>=(const valarray<Type>& right);

valarray<Type>& operator>>=(const Type& right);

Paramètres

right
Valeur indiquant la quantité de décalage droit ou une valarray valeur dont 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 la quantité spécifiée dans right.

Notes

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

Exemple

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

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

   valarray<int> vaL ( 8 ), vaR ( 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 operand valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

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

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

The initial operand valarray is: ( 64 -64 64 -64 64 -64 64 -64 ).
The  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<<=`

Décale vers la gauche les bits pour chaque élément d'un opérande valarray d'un nombre spécifié de positions ou d'une quantité élément par élément spécifiée par un second valarray.

valarray<Type>& operator<<=(const valarray<Type>& right);

valarray<Type>& operator<<=(const Type& right);

Paramètres

right
Valeur indiquant la quantité de décalage gauche ou valarray dont 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 de la quantité spécifiée dans right.

Notes

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

Exemple

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

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

   valarray<int> vaL ( 8 ), vaR ( 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 operand valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

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

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

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

`operator*=`

Multiplie les éléments d'un valarray spécifié ou une valeur du type d'élément, élément par élément, avec un valarray opérande.

valarray<Type>& operator*=(const valarray<Type>& right);

valarray<Type>& operator*=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celui de l’opérande valarray qui consiste à multiplier, à l’échelle de l’élément, l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont le produit par élément de l’opérande valarray et right.

Exemple

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

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

   valarray<int> vaL ( 8 ), vaR ( 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 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;

   vaL *= vaR;
   cout << "The element-by-element result of "
        << "the multiplication is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}
/* Output:
The initial 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+`

Un opérateur unaire qui applique un plus à chaque élément d'un valarray. Pour les valeurs arithmétiques normales, cette opération n’a aucun effet.

valarray<Type> operator+() const;

Valeur retournée

Dont valarray les éléments sont le résultat unaire plus du tableau d’opérandes.

Exemple

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

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

   valarray<int> vaL ( 10 );
   valarray<int> vaPLUS ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;

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

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

The initial valarray is:  ( 0 0 -2 2 -4 4 -6 6 -8 8 ).
The element-by-element result of the operator+ is the
valarray: ( 0 0 -2 2 -4 4 -6 6 -8 8 ).

`operator+=`

Ajoute les éléments d'un valarray spécifié ou une valeur du type d'élément, élément par élément, à un valarray opérande.

valarray<Type>& operator+=(const valarray<Type>& right);

valarray<Type>& operator+=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celui de l’opérande valarray à ajouter, à l’élément, à l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont la somme des éléments de l’opérande valarray et right.

Exemple

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

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

   valarray<int> vaL ( 8 ), vaR ( 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 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;

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

The initial 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-`

Opérateur unaire qui applique une négation arithmétique à chaque élément d’un valarray.

valarray<Type> operator-() const;

Valeur retournée

Dont valarray les éléments sont arithmétiquement négations des éléments de l’opérande valarray.

Exemple

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

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

   valarray<int> vaL ( 10 );
   valarray<int> vaMINUS ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;

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

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

The initial valarray is:  ( 0 0 -2 2 -4 4 -6 6 -8 8 ).
The element-by-element result of the operator- is the
valarray: ( 0 0 2 -2 4 -4 6 -6 8 -8 ).

`operator-=`

Soustrait les éléments d'un valarray spécifié ou une valeur du type d'élément, élément par élément, d'un valarray opérande.

valarray<Type>& operator-=(const valarray<Type>& right);

valarray<Type>& operator-=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celui de l’opérande valarray qui doit être soustrait, à l’échelle de l’élément, de l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont la différence par élément de l’opérande valarray et right.

Exemple

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

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

   valarray<int> vaL ( 8 ), vaR ( 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 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;

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

The initial 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/=`

Divise un valarray opérande, élément par élément, par les éléments d'un valarray spécifié ou par une valeur du type d'élément.

valarray<Type>& operator/=(const valarray<Type>& right);

valarray<Type>& operator/=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celle de l’opérande valarray qui doit être divisée, à l’échelle de l’élément, dans l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont le quotient par élément de l’opérande valarray divisé par right.

Exemple

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

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

   valarray<double> vaL ( 6 ), vaR ( 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 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;

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

The initial 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=`

Affecte des éléments à un valarray dont les valeurs sont spécifiées directement ou comme une partie d'un autre valarray, ou par un slice_array, gslice_array, mask_array ou indirect_array.

valarray<Type>& operator=(const valarray<Type>& right);

valarray<Type>& operator=(valarray<Type>&& right);

valarray<Type>& operator=(const Type& val);

valarray<Type>& operator=(const slice_array<Type>& slicearray);

valarray<Type>& operator=(const gslice_array<Type>& gslicearray);

valarray<Type>& operator=(const mask_array<Type>& maskarray);

valarray<Type>& operator=(const indirect_array<Type>& indarray);

Paramètres

right
À valarray copier dans l’opérande valarray.

val
Valeur à affecter aux éléments de l’opérande valarray.

slicearray
À slice_array copier dans l’opérande valarray.

gslicearray
À gslice_array copier dans l’opérande valarray.

maskarray
À mask_array copier dans l’opérande valarray.

indarray
À indirect_array copier dans l’opérande valarray.

Valeur retournée

Le premier opérateur membre remplace la séquence contrôlée par une copie de la séquence contrôlée par right.

Le deuxième opérateur membre est le même que le premier, mais avec un déclarateur de référence Rvalue : &&.

Le troisième opérateur membre remplace chaque élément de la séquence contrôlée par une copie de val.

Les opérateurs membres restants remplacent ces éléments de la séquence contrôlée sélectionnée par leurs arguments, qui sont générés uniquement par operator[].

Si la valeur d’un membre dans la séquence contrôlée de remplacement dépend d’un membre dans la séquence contrôlée initiale, le résultat est indéfini.

Notes

Si la longueur de la séquence contrôlée change, normalement le résultat n’est pas défini. Dans cette implémentation, toutefois, l’effet est simplement d’invalider tous les pointeurs ou références aux éléments dans la séquence contrôlée.

Exemple

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

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

   valarray<int> va ( 10 ), vaR ( 10 );
   for ( i = 0 ; i < 10 ; i += 1 )
      va [ i ] = i;
   for ( i = 0 ; i < 10 ; i+=1 )
      vaR [ i ] = 10 -  i;

   cout << "The operand valarray va is:";
   for ( i = 0 ; i < 10 ; i++ )
      cout << " " << va [ i ];
   cout << endl;

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

   // Assigning vaR to va with the first member function
   va = vaR;
   cout << "The reassigned valarray va is:";
   for ( i = 0 ; i < 10 ; i++ )
      cout << " " << va [ i ];
   cout << endl;

   // Assigning elements of value 10 to va
   // with the second member function
   va = 10;
   cout << "The reassigned valarray va is:";
      for ( i = 0 ; i < 10 ; i++ )
         cout << " " << va [ i ];
   cout << endl;
}

The operand valarray va is: 0 1 2 3 4 5 6 7 8 9
The operand valarray vaR is: 10 9 8 7 6 5 4 3 2 1
The reassigned valarray va is: 10 9 8 7 6 5 4 3 2 1
The reassigned valarray va is: 10 10 10 10 10 10 10 10 10 10

`operator[]`

Retourne une référence à un élément ou sa valeur à l'index spécifié, ou un sous-ensemble spécifié.

Type& operator[](size_t index);

slice_array<Type> operator[](slice slicearray);

gslice_array<Type> operator[](const gslice& gslicearray);

mask_array<Type> operator[](const valarray<bool>& boolarray);

indirect_array<Type> operator[](const valarray<size_t>& indarray);

Type operator[](size_t index) const;

valarray<Type> operator[](slice slicearray) const;

valarray<Type> operator[](const gslice& gslicearray) const;

valarray<Type> operator[](const valarray<bool>& boolarray) const;

valarray<Type> operator[](const valarray<size_t>& indarray) const;

Paramètres

index
L’index de l’élément auquel une valeur doit être affectée.

slicearray
D’un slice_array valarray sous-ensemble qui spécifie qu’un sous-ensemble doit être sélectionné ou retourné à un nouveau valarray.

gslicearray
D’un gslice_array valarray sous-ensemble qui spécifie qu’un sous-ensemble doit être sélectionné ou retourné à un nouveau valarray.

boolarray
D’un bool_array valarray sous-ensemble qui spécifie qu’un sous-ensemble doit être sélectionné ou retourné à un nouveau valarray.

indarray
Un indirect_array élément valarray qui spécifie un sous-ensemble à sélectionner ou à retourner à un nouveau valarray.

Valeur retournée

Une référence à un élément ou sa valeur à l’index spécifié, ou un sous-ensemble spécifié.

Notes

L’opérateur membre est surchargé pour fournir plusieurs façons de sélectionner des séquences d’éléments parmi celles contrôlées par *this. Le premier groupe de cinq opérateurs membres fonctionne avec différentes surcharges de operator= (et d’autres opérateurs affectés) pour permettre le remplacement sélectif (découpage) de la séquence contrôlée. Les éléments sélectionnés doivent exister.

Lorsqu’elle est compilée à l’aide de _ITERATOR_DEBUG_LEVEL la valeur 1 ou 2, une erreur d’exécution se produit si vous tentez d’accéder à un élément en dehors des limites du valarray. Pour plus d’informations, consultez Itérateurs vérifiés.

Exemple

Consultez les exemples pour slice::slice et gslice::gslice pour obtenir un exemple de déclaration et d’utilisation operator[].

`operator^=`

Obtient l’exclusivité au niveau du bit ou (^) d’un valarray avec une valeur spécifiée valarray ou une valeur du type d’élément.

valarray<Type>& operator^=(const valarray<Type>& right);

valarray<Type>& operator^=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celle de l’opérande valarray à combiner par l’opérateur exclusif ou (XOR) au niveau du bit (^) avec l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont les éléments exclusifs au niveau du bit ou (XOR) de l’opérande valarray et right.

Notes

Le bit exclusif ou, appelé XOR et désigné par l’opérateur ^, a la sémantique suivante : Bits donnés b1 et b2, b1 ^ b2 est 1 si exactement l’un des éléments est 1, et 0 si les deux éléments sont 0 ou 1.

Exemple

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

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

    valarray<int> vaL ( 10 ), vaR ( 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 operand valarray is:  ( ";
        for (i = 0 ; i < 10 ; i++ )
            cout << vaL [ i ] << " ";
    cout << ")." << endl;

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

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

The initial operand valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The  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 (|) d’éléments d’un tableau avec les éléments correspondants dans un élément spécifié valarray ou avec une valeur du type d’élément.

valarray<Type>& operator|=(const valarray<Type>& right);

valarray<Type>& operator|=(const Type& right);

Paramètres

right
Valeur valarray ou valeur d’un type d’élément identique à celle de l’opérande valarray qui doit être combinée, à l’échelle de l’élément, par l’OR au niveau du bit (|) avec l’opérande valarray.

Valeur retournée

Dont valarray les éléments sont l’OR au niveau des éléments (|ou) de l’opérande valarray par right.

Notes

Une opération au niveau du bit ne peut être utilisée que pour manipuler des bits dans des types de données intégraux tels que char et int. Il ne fonctionne pas sur float, , double, long doublevoid, , boolou d’autres types de données plus complexes.

L’OR au niveau du bit (|) s’applique au type de données au niveau des bits individuels. Les bits donnés b1 et b2, b1 | b2 est 1 si au moins un des bits est 1 ; 0 si les deux bits sont 0.

Exemple

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

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

   valarray<int> vaL ( 10 ), vaR ( 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 operand valarray is:"
        << endl << "( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

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

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

The initial operand valarray is:
( 1 0 1 0 1 0 1 0 1 0 ).
The  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~`

Opérateur unaire qui obtient le complément au niveau du bit des valeurs de chaque élément d’un valarray.

valarray<Type> operator~() const;

Valeur retournée

Valeurs valarray qui sont le complément binaire unaire des valeurs d’élément de l’opérande valarray.

Notes

Une opération au niveau du bit ne peut manipuler que des bits dans des types intégraux, tels que char et int. Il ne fonctionne pas sur float, , double, long doublevoid, , boolou d’autres types de données plus complexes.

L’opérateur ~ de complément au niveau du bit unaire s’applique au type de données au niveau des bits individuels. Le bit bdonné est ~b 1 s’il b est 0 et 0 s’il b est 1.

Exemple

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

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

    valarray<unsigned short int> vaL1 ( 10 );
    valarray<unsigned short int> vaNOT1 ( 10 );
    for ( i = 0 ; i < 10 ; i += 2 )
        vaL1 [ i ] =  i;
    for ( i = 1 ; i < 10 ; i += 2 )
        vaL1 [ i ] =  5*i;

    cout << "The initial valarray <unsigned short int> is:  ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaL1 [ i ] << " ";
    cout << ")." << endl;

    vaNOT1 = ~vaL1;
    cout << "The element-by-element result of "
        << "the bitwise NOT operator~ is the"
        << endl << "valarray: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaNOT1 [ i ] << " ";
    cout << ")." << endl << endl;

    valarray<int> vaL2 ( 10 );
    valarray<int> vaNOT2 ( 10 );
    for ( i = 0 ; i < 10 ; i += 2 )
        vaL2 [ i ] =  i;
    for ( i = 1 ; i < 10 ; i += 2 )
        vaL2 [ i ] =  -2 * i;

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

    vaNOT2 = ~vaL2;
    cout << "The element-by-element result of "
        << "the bitwise NOT operator~ is the"
        << endl << "valarray: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaNOT2 [ i ] << " ";
    cout << ")." << endl;

    // The negative numbers are represented using
    // the two's complement approach, so adding one
    // to the flipped bits returns the negative elements
    vaNOT2 = vaNOT2 + 1;
    cout << "The element-by-element result of "
        << "adding one"
        << endl << "is the negative of the "
        << "original elements the"
        << endl << "valarray: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaNOT2 [ i ] << " ";
    cout << ")." << endl;
}

The initial valarray <unsigned short int> is:  ( 0 5 2 15 4 25 6 35 8 45 ).
The element-by-element result of the bitwise NOT operator~ is the
valarray: ( 65535 65530 65533 65520 65531 65510 65529 65500 65527 65490 ).

The initial valarray <int> is:  ( 0 -2 2 -6 4 -10 6 -14 8 -18 ).
The element-by-element result of the bitwise NOT operator~ is the
valarray: ( -1 1 -3 5 -5 9 -7 13 -9 17 ).
The element-by-element result of adding one
is the negative of the original elements the
valarray: ( 0 2 -2 6 -4 10 -6 14 -8 18 ).

`resize`

Modifie le nombre d’éléments d’un valarray nombre spécifié.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Paramètres

new_size
Nombre d’éléments dans le redimensionnement valarray.

val
Valeur à attribuer aux éléments du redimensionnement valarray.

Notes

La première fonction membre initialise les éléments avec leur constructeur par défaut.

Tous les pointeurs ou références aux éléments dans la séquence contrôlée sont invalidés.

Exemple

L’exemple suivant illustre l’utilisation de la valarray::resize fonction membre.

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

int main()
{
    using namespace std;
    int i;
    size_t size1, sizeNew;

    valarray<int> va1(10);
    for (i = 0; i < 10; i+=1)
        va1[i] = i;

    cout << "The valarray contains ( ";
        for (i = 0; i < 10; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;

    size1 = va1.size();
    cout << "The number of elements in the valarray is: "
         << size1  << "." <<endl << endl;

    va1.resize(15, 10);

    cout << "The valarray contains ( ";
        for (i = 0; i < 15; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;
    sizeNew = va1.size();
    cout << "The number of elements in the resized valarray is: "
         << sizeNew  << "." <<endl << endl;
}

The valarray contains ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray is: 10.

The valarray contains ( 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 ).
The number of elements in the resized valarray is: 15.

`shift`

Déplace tous les éléments d’un valarray nombre spécifié d’emplacements.

valarray<Type> shift(int count) const;

Paramètres

count
Le nombre d’emplacements qui servira à décaler les éléments vers l’avant.

Valeur retournée

valarray Nouvelle dans laquelle tous les éléments ont été déplacés count vers l’avant du , ou vers la valarraygauche par rapport à leurs positions dans l’opérande valarray.

Notes

Une valeur positive de count décale les éléments vers la gauche de count emplacements, en complétant avec des zéros.

Une valeur négative de count décale les éléments vers la droite de count emplacements, en complétant avec des zéros.

Exemple

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

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

   valarray<int> va1 ( 10 ), va2 ( 10 );
   for ( i = 0 ; i < 10 ; i += 1 )
      va1 [ i ] =  i;
   for ( i = 0 ; i < 10 ; i += 1 )
      va2 [ i ] = 10 -  i;

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

   // A positive parameter shifts elements left
   va1 = va1.shift ( 4 );
   cout << "The shifted valarray va1 is: va1.shift (4) = ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << va1 [ i ] << " ";
   cout << ")." << endl;

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

   // A negative parameter shifts elements right
   va2 = va2.shift ( - 4 );
   cout << "The shifted valarray va2 is: va2.shift (-4) = ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << va2 [ i ] << " ";
   cout << ")." << endl;
}

The operand valarray va1(10) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The shifted valarray va1 is: va1.shift (4) = ( 4 5 6 7 8 9 0 0 0 0 ).
The operand valarray va2(10) is: ( 10 9 8 7 6 5 4 3 2 1 ).
The shifted valarray va2 is: va2.shift (-4) = ( 0 0 0 0 10 9 8 7 6 5 ).

`size`

Trouve le nombre d'éléments d'un valarray.

size_t size() const;

Valeur retournée

Nombre d’éléments dans l’opérande valarray.

Exemple

L’exemple suivant illustre l’utilisation de la valarray::size fonction membre.

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

int main()
{
    using namespace std;
    int i;
    size_t size1, size2;

    valarray<int> va1(10), va2(12);
    for (i = 0; i < 10; i += 1)
        va1[i] =  i;
    for (i = 0; i < 10; i += 1)
        va2[i] =  i;

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

    size1 = va1.size();
    cout << "The number of elements in the valarray va1 is: va1.size = "
         << size1  << "." <<endl << endl;

    cout << "The operand valarray va2(12) is: ( ";
        for (i = 0; i < 10; i++)
            cout << va2[i] << " ";
    cout << ")." << endl;

    size2 = va2.size();
    cout << "The number of elements in the valarray va2 is: va2.size = "
         << size2  << "." << endl << endl;

    // Initializing two more elements to va2
    va2[10] = 10;
    va2[11] = 11;
    cout << "After initializing two more elements,\n"
         << "the operand valarray va2(12) is now: ( ";
        for (i = 0; i < 12; i++)
            cout << va2[i] << " ";
    cout << ")." << endl;
    cout << "The number of elements in the valarray va2 is still: "
         << size2  << "." << endl;
}

The operand valarray va1(10) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray va1 is: va1.size = 10.

The operand valarray va2(12) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray va2 is: va2.size = 12.

After initializing two more elements,
the operand valarray va2(12) is now: ( 0 1 2 3 4 5 6 7 8 9 10 11 ).
The number of elements in the valarray va2 is still: 12.

`sum`

Détermine la somme de tous les éléments d'un valarray d'une longueur différente de zéro.

Type sum() const;

Valeur retournée

Somme des éléments de l’opérande valarray.

Notes

Si la longueur est supérieure à une, la fonction membre ajoute des valeurs à la somme en appliquant operator+= entre des paires d’éléments de classe Type. Cela signifie que l’opérateur doit être fourni pour les éléments de type Type.

Exemple

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

int main( )
{
    using namespace std;
    int i;
    int sumva = 0;

    valarray<int> va ( 10 );
    for ( i = 0 ; i < 10 ; i+=1 )
        va [ i ] =  i;

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

    sumva = va.sum ( );
    cout << "The sum of elements in the valarray is: "
        << sumva  << "." <<endl;
}

The operand valarray va (10) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The sum of elements in the valarray is: 45.

`swap`

Échange les éléments de deux objets valarray.

void swap(valarray& right);

Paramètres

right
valarray qui fournit les éléments à échanger.

Notes

La fonction membre échange les séquences contrôlées entre *this et right. Il le fait dans le temps constant, il ne lève aucune exception, et il invalide aucune référence, pointeur ou itérateur vers des éléments dans les deux séquences contrôlées.

`valarray`

Construit un valarray de taille spécifique ou avec des éléments d'une valeur spécifique, ou comme copie d'un autre valarray ou comme sous-ensemble d'un autre valarray.

valarray();

explicit valarray(
    size_t count);

valarray(
    const Type& val,
    size_t count);

valarray(
    const Type* ptr,
    size_t count);

valarray(
    const valarray<Type>& right);

valarray(
    const slice_array<Type>& sliceArray);

valarray(
    const gslice_array<Type>& gsliceArray);

valarray(
    const mask_array<Type>& maskArray);

valarray(
    const indirect_array<Type>& indArray);

valarray(
    valarray<Type>&& tight);

valarray(
    initializer_list<Type> iList);

Paramètres

count
Nombre d’éléments à trouver dans le valarray.

val
Valeur à utiliser pour initialiser les éléments dans le valarray.

ptr
Pointeur vers les valeurs à utiliser pour initialiser les éléments dans le valarray.

right
Existant valarray pour initialiser le nouveau valarray.

sliceArray
Dont slice_array les valeurs d’élément doivent être utilisées pour initialiser les éléments de la valarray construction.

gsliceArray
Dont gslice_array les valeurs d’élément doivent être utilisées pour initialiser les éléments de la valarray construction.

maskArray
Dont mask_array les valeurs d’élément doivent être utilisées pour initialiser les éléments de la valarray construction.

indArray
Dont indirect_array les valeurs d’élément doivent être utilisées pour initialiser les éléments de la valarray construction.

iList
initializer_list Contenant les éléments à copier.

Notes

Le premier constructeur (par défaut) initialise l’objet sur un objet vide valarray. Les trois constructeurs suivants initialisent l’objet sur un valarray élément count comme suit :

Pour le valarray(size_t count) explicite, chaque élément est initialisé avec le constructeur par défaut.
Pour valarray(const Type& val, count), chaque élément est initialisé avec val.
Pour valarray(const Type* ptr, count), l’élément à la position I est initialisé avec ptr[I].

Chaque constructeur restant initialise l’objet sur un valarray<Type> objet déterminé par le sous-ensemble spécifié dans l’argument.

Le dernier constructeur est le même que le prochain, mais avec un déclarateur de référence Rvalue : &&.

Exemple

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

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

    // The second member function
    valarray<int> va(10);
    for (auto i : va){
        va[i] = 2 * (i + 1);
    }

    cout << "The operand valarray va is:\n(";
    for (auto i : va) {
        cout << " " << va[i];
    }
    cout << " )" << endl;

    slice Slice(2, 4, 3);

    // The fifth member function
    valarray<int> vaSlice = va[Slice];

    cout << "The new valarray initialized from the slice is vaSlice =\n"
        << "va[slice( 2, 4, 3)] = (";
    for (int i = 0; i < 3; i++) {
        cout << " " << vaSlice[i];
    }
    cout << " )" << endl;

    valarray<int> va2{{ 1, 2, 3, 4 }};
    for (auto& v : va2) {
        cout << v << " ";
    }
    cout << endl;
}

The operand valarray va is:
( 0 2 2 2 2 2 2 2 2 2 )
The new valarray initialized from the slice is vaSlice =
va[slice( 2, 4, 3)] = ( 0 0 0 )
1 2 3 4

`value_type`

Type qui représente le type des éléments stockés dans un valarray.

typedef Type value_type;

Notes

Le type est un synonyme du paramètre de modèle Type.

Exemple

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

int main( )
{
    using namespace std;
    int i;
    valarray<int> va ( 10 );
    for ( i = 0 ; i < 10 ; i += 2 )
        va [ i ] =  i;
    for ( i = 1 ; i < 10 ; i += 2 )
        va [ i ] =  -1;

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

    // value_type declaration and initialization:
    valarray<int>::value_type Right = 10;

    cout << "The declared value_type Right is: "
            << Right << endl;
    va *= Right;
    cout << "The resulting valarray is:  ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << va [ i ] << " ";
    cout << ")." << endl;
}

The initial operand valarray is:  ( 0 -1 2 -1 4 -1 6 -1 8 -1 ).
The declared value_type Right is: 10
The resulting valarray is:  ( 0 -10 20 -10 40 -10 60 -10 80 -10 ).

Voir aussi

Sécurité des threads dans la bibliothèque standard C++

Partager via

Classe valarray

Notes

Membres

Constructeurs

Typedefs

Functions

Opérateurs

apply

Paramètres

Valeur retournée

Notes

Exemple

cshift

Paramètres

Valeur retournée

Notes

Exemple

free

Notes

max

Valeur retournée

Notes

Exemple

min

Valeur retournée

Notes

Exemple

operator!

Valeur retournée

Notes

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 retournée

Notes

Exemple

operator*=

Paramètres

Valeur retournée

Exemple

operator+

Valeur retournée

Exemple

operator+=

Paramètres

Valeur retournée

Exemple

operator-

Valeur retournée

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

Classe `valarray`

`apply`

`cshift`

`free`

`max`

`min`

`operator!`

`operator%=`

`operator&=`

`operator>>=`

`operator<<=`

`operator*=`

`operator+`

`operator+=`

`operator-`

`operator-=`

`operator/=`

`operator=`

`operator[]`

`operator^=`

`operator|=`

`operator~`

`resize`

`shift`

`size`

`sum`

`swap`

`valarray`

`value_type`