Classe `valarray`

Articolo
10/12/2023

Il modello valarray<Type> di classe descrive un oggetto che controlla una sequenza di elementi di tipo Type archiviati come matrice, progettati per operazioni matematiche ad alta velocità e ottimizzati per le prestazioni di calcolo.

Osservazioni:

La classe è una rappresentazione del concetto matematico di un set ordinato di valori. I relativi elementi sono numerati in sequenza da zero. La classe viene descritta come contenitore vicino perché supporta alcune funzionalità, ma non tutte, dei contenitori di sequenze di prima classe, ad esempio vector, supporto. Differisce dal modello vector di classe in due modi importanti:

Definisce molte operazioni aritmetiche tra gli elementi corrispondenti degli valarray<Type> oggetti dello stesso tipo e lunghezza, ad esempio varr_x* = cos(varr_y) + sin(varr_z).
Definisce vari modi interessanti per descrivere un valarray<Type> oggetto, eseguendo l'overload di operator[].

Oggetto della classe Type:

Ha un costruttore predefinito pubblico, un distruttore, un costruttore di copia e un operatore di assegnazione, con un comportamento convenzionale.
Definisce le funzioni matematiche e gli operatori aritmetici, come necessario, definiti per i tipi a virgola mobile, con un comportamento convenzionale.

In particolare, non possono esistere sottili differenze tra il costruttore di copia e la costruzione predefinita seguita dall'assegnazione. Nessuna delle operazioni sugli oggetti della classe Type può generare eccezioni.

Membri

Costruttori

Nome	Descrizione
`valarray`	Costruisce un oggetto `valarray` di una dimensione specifica o con elementi di un determinato valore oppure come copia di un altro oggetto `valarray` o subset di un altro oggetto `valarray`.

Typedef

Nome	Descrizione
`value_type`	Tipo che rappresenta il tipo di elemento archiviato in un oggetto `valarray`.

Funzioni

Nome	Descrizione
`apply`	Applica una funzione specificata a ogni elemento di un oggetto `valarray`.
`cshift`	Sposta ciclicamente tutti gli elementi in un oggetto `valarray` in base a un numero specificato di posizioni.
`free`	Libera la memoria usata da `valarray`.
`max`	Trova l'elemento più grande in un oggetto `valarray`.
`min`	Trova l'elemento più piccolo in un oggetto `valarray`.
`resize`	Modifica il numero di elementi in un oggetto `valarray` in base a un numero specificato, aggiungendo o rimuovendo elementi nel modo necessario.
`shift`	Sposta tutti gli elementi in un oggetto `valarray` in base a un numero specificato di posizioni.
`size`	Trova il numero di elementi in un oggetto `valarray`.
`sum`	Determina la somma di tutti gli elementi in un oggetto `valarray` di lunghezza diversa da zero.
`swap`

Operatori

Nome	Descrizione
`operator!`	Operatore unario che ottiene i valori NOT logici (`!`) di ogni elemento in un oggetto `valarray`.
`operator%=`	Ottiene il resto della divisione degli elementi di una matrice elemento per elemento per un oggetto `valarray` specificato o per un valore del tipo di elemento.
`operator&=`	Ottiene l'AND bit per bit (`&`) degli elementi in una matrice con gli elementi corrispondenti in un oggetto specificato `valarray` o con un valore del tipo di elemento.
`operator>>=`	Sposta verso destra i bit per ogni elemento di un operando `valarray` di un numero specificato di posizioni o in base a una quantità di elementi specificata da un secondo oggetto `valarray`.
`operator<<=`	Sposta verso sinistra i bit per ogni elemento di un operando `valarray` di un numero specificato di posizioni o in base a una quantità di elementi specificata da un secondo oggetto `valarray`.
`operator*=`	Moltiplica gli elementi di un oggetto `valarray` specificato o di un valore del tipo di elemento, elemento per elemento, per un operando `valarray`.
`operator+`	Operatore unario che applica un segno più a ogni elemento in un oggetto `valarray`. Nei tipi aritmetici normali, questo operatore non ha alcun effetto.
`operator+=`	Aggiunge gli elementi di un oggetto `valarray` specificato o di un valore del tipo di elemento, elemento per elemento, a un operando `valarray`.
`operator-`	Operatore unario che applica una negazione aritmetica a ogni elemento di un oggetto `valarray`.
`operator-=`	Sottrae gli elementi di un oggetto `valarray` specificato o di un valore del tipo di elemento, elemento per elemento, da un operando `valarray`.
`operator/=`	Divide un operando `valarray` elemento per elemento per gli elementi di un oggetto `valarray` specificato o di un valore del tipo di elemento.
`operator=`	Assegna elementi a un oggetto `valarray` i cui valori sono specificati direttamente o come parti di un altro oggetto `valarray` oppure da `slice_array`, `gslice_array`, `mask_array` o `indirect_array`.
`operator[]`	Restituisce un riferimento a un elemento o al relativo valore in corrispondenza di un indice o un subset specificato.
`operator^=`	Ottiene l'esclusivo bit per bit o (`^`) di un `valarray` oggetto con un valore specificato `valarray` o un valore del tipo di elemento.
`operator\|=`	Ottiene l'OR bit per bit (`\|`) degli elementi in una matrice con gli elementi corrispondenti in un oggetto specificato `valarray` o con un valore del tipo di elemento.
`operator~`	Operatore unario che ottiene i valori di complemento bit per bit (`~`) di ogni elemento in un oggetto `valarray`.

`apply`

Applica una funzione specificata a ogni elemento di un oggetto valarray.

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

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

Parametri

function_object(Type)
Oggetto funzione da applicare a ogni elemento dell'operando valarray.

function_object(const Type&)
Oggetto funzione per const gli elementi da applicare a ogni elemento dell'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono stati function_object applicati a livello di elemento agli elementi dell'operando valarray.

Osservazioni:

La funzione membro restituisce un oggetto della classe valarray<Type>, di lunghezza size, ognuno dei cui elementi elem è il risultato di function_object((*this)[elem]).

Esempio

// 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`

Sposta ciclicamente tutti gli elementi in un oggetto valarray in base a un numero specificato di posizioni.

valarray<Type> cshift(int count) const;

Parametri

count
Numero di posizioni in base al quale gli elementi devono essere spostati in avanti.

Valore restituito

valarray Nuovo oggetto in cui tutti gli elementi sono stati spostati count ciclicamente verso la parte anteriore di valarray, o verso sinistra rispetto alle rispettive posizioni nell'operando valarray.

Osservazioni:

Un valore positivo count sposta gli elementi ciclicamente verso sinistra di un numero di posizioni pari a count.

Un valore negativo count sposta gli elementi ciclicamente verso destra di un numero di posizioni pari a count.

Esempio

// 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`

Libera la memoria usata da valarray.

void free();

Osservazioni:

Questa funzione non standard equivale all'assegnazione di un oggetto vuoto valarray. Ad esempio:

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

// equivalent to v.free()

`max`

Trova l'elemento più grande in un oggetto valarray.

Type max() const;

Valore restituito

Valore massimo degli elementi nell'operando valarray.

Osservazioni:

La funzione membro confronta i valori applicando l'operatore o l'operatore>< tra coppie di elementi della classe Type, per i quali gli operatori devono essere forniti per l'elemento .Type

Esempio

// 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`

Trova l'elemento più piccolo in un oggetto valarray.

Type min() const;

Valore restituito

Valore minimo degli elementi nell'operando valarray.

Osservazioni:

La funzione membro confronta i valori applicando l'operatore o l'operatore>< tra coppie di elementi della classe Type, per i quali gli operatori devono essere forniti per l'elemento .Type

Esempio

// 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!`

Operatore unario che ottiene i valori NOT logici (!) di ogni elemento in un oggetto valarray.

valarray<bool> operator!() const;

Valore restituito

Oggetto valarray dei valori booleani che rappresentano la negazione logica dei valori dell'elemento dell'operando valarray.

Osservazioni:

L'operazione logica NOT, indicata da !, nega logicamente gli elementi perché converte tutti i valori zero in true e tutti i valori diversi da zero in false. Il valore restituito valarray di valori booleani corrisponde alla stessa dimensione dell'operando valarray.

Esempio

// 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%=`

Ottiene il resto della divisione degli elementi di una matrice elemento per elemento per un oggetto valarray specificato o per un valore del tipo di elemento.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray da dividere, elemento per elemento, l'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono il resto della divisione a livello di elemento dell'operando valarray da right.

Esempio

// 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&=`

Ottiene l'AND bit per bit (&) degli elementi in una matrice con gli elementi corrispondenti in un oggetto specificato valarray o con un valore del tipo di elemento.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray che deve essere combinato, elemento per elemento, dall'AND bit per bit (&) con l'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono l'AND bit per bit (&) dell'operando valarray da right

Osservazioni:

Un'operazione bit per bit può essere usata solo per modificare i bit nei tipi di dati integrali, ad esempio char e int. Non funziona in float, double, long double, void, boolo altri tipi di dati più complessi.

L'AND bit per bit (&) si applica al tipo di dati a livello dei singoli bit. I bit b1 specificati e b2, b1 & b2 è 1 se entrambi i bit sono 1; 0 se almeno un bit è 0.

Esempio

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

Sposta verso destra i bit per ogni elemento di un operando valarray di un numero specificato di posizioni o in base a una quantità di elementi specificata da un secondo oggetto valarray.

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

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

Parametri

right
Valore che indica la quantità di spostamento a destra o di un oggetto i valarray cui elementi indicano la quantità di spostamento a destra dell'elemento.

Valore restituito

Oggetto valarray i cui elementi sono stati spostati a destra della quantità specificata in right.

Osservazioni:

Per i numeri con segno, i segni vengono mantenuti.

Esempio

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

Sposta verso sinistra i bit per ogni elemento di un operando valarray di un numero specificato di posizioni o in base a una quantità di elementi specificata da un secondo oggetto valarray.

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

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

Parametri

right
Valore che indica la quantità di spostamento a sinistra o valarray i cui elementi indicano la quantità di spostamento a sinistra per elemento.

Valore restituito

Oggetto valarray i cui elementi sono stati spostati a sinistra dell'importo specificato in right.

Osservazioni:

Per i numeri con segno, i segni vengono mantenuti.

Esempio

// 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*=`

Moltiplica gli elementi di un oggetto valarray specificato o di un valore del tipo di elemento, elemento per elemento, per un operando valarray.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray da moltiplicare, elemento per elemento, l'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono il prodotto a livello di elemento dell'operando valarray e right.

Esempio

// 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+`

Operatore unario che applica un segno più a ogni elemento in un oggetto valarray. Per i valori aritmetici normali, questa operazione non ha alcun effetto.

valarray<Type> operator+() const;

Valore restituito

Oggetto valarray i cui elementi sono il risultato unario e il risultato della matrice dell'operando.

Esempio

// 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+=`

Aggiunge gli elementi di un oggetto valarray specificato o di un valore del tipo di elemento, elemento per elemento, a un operando valarray.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray da aggiungere, a livello di elemento, all'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono la somma a livello di elemento dell'operando valarray e right.

Esempio

// 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-`

Operatore unario che applica una negazione aritmetica a ogni elemento di un oggetto valarray.

valarray<Type> operator-() const;

Valore restituito

Oggetto valarray i cui elementi sono aritmeticamente negati dagli elementi dell'operando valarray.

Esempio

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

Sottrae gli elementi di un oggetto valarray specificato o di un valore del tipo di elemento, elemento per elemento, da un operando valarray.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray che deve essere sottratto, elemento per elemento, dall'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono la differenza a livello di elemento dell'operando valarray e right.

Esempio

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

Divide un operando valarray elemento per elemento per gli elementi di un oggetto valarray specificato o di un valore del tipo di elemento.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray da dividere, elemento per elemento, nell'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono il quoziente a livello di elemento dell'operando valarray diviso per right.

Esempio

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

Assegna elementi a un oggetto valarray i cui valori sono specificati direttamente o come parti di un altro oggetto valarray oppure da slice_array, gslice_array, mask_array o 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);

Parametri

right
Oggetto valarray da copiare nell'operando valarray.

val
Valore da assegnare agli elementi dell'operando valarray.

slicearray
Oggetto slice_array da copiare nell'operando valarray.

gslicearray
Oggetto gslice_array da copiare nell'operando valarray.

maskarray
Oggetto mask_array da copiare nell'operando valarray.

indarray
Oggetto indirect_array da copiare nell'operando valarray.

Valore restituito

Il primo operatore membro sostituisce la sequenza controllata con una copia della sequenza controllata da right.

Il secondo operatore membro è uguale al primo, ma con un dichiaratore di riferimento Rvalue: &&.

Il terzo operatore membro sostituisce ogni elemento della sequenza controllata con una copia di val.

Gli operatori membri rimanenti sostituiscono gli elementi della sequenza controllata selezionata dai relativi argomenti, generati solo da operator[].

Se il valore di un membro nella sequenza controllata di sostituzioni dipende da un membro nella sequenza controllata iniziale, il risultato è indefinito.

Osservazioni:

Se la lunghezza della sequenza controllata cambia, in genere il risultato non è definito. In questa implementazione tuttavia l'effetto è semplicemente quello di invalidare eventuali puntatori o riferimenti a elementi nella sequenza controllata.

Esempio

// 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[]`

Restituisce un riferimento a un elemento o al relativo valore in corrispondenza di un indice o un subset specificato.

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;

Parametri

index
Indice dell'elemento a cui deve essere assegnato un valore.

slicearray
Oggetto slice_array di un oggetto valarray che specifica un subset da selezionare o restituire a un nuovo valarrayoggetto .

gslicearray
Oggetto gslice_array di un oggetto valarray che specifica un subset da selezionare o restituire a un nuovo valarrayoggetto .

boolarray
Oggetto bool_array di un oggetto valarray che specifica un subset da selezionare o restituire a un nuovo valarrayoggetto .

indarray
Oggetto indirect_array di un oggetto valarray che specifica un subset da selezionare o restituire a un nuovo valarrayoggetto .

Valore restituito

Riferimento a un elemento o al relativo valore in corrispondenza di un indice o un subset specificato.

Osservazioni:

L'operatore membro è sottoposto a overload per fornire diversi modi per selezionare sequenze di elementi da quelle controllate da *this. Il primo gruppo di cinque operatori membro funziona insieme a vari overload di operator= (e altri operatori di assegnazione) per consentire la sostituzione selettiva (sezionamento) della sequenza controllata. Gli elementi selezionati devono esistere.

Quando viene compilato usando _ITERATOR_DEBUG_LEVEL definito come 1 o 2, si verifica un errore di runtime se si tenta di accedere a un elemento al di fuori dei limiti di valarray. Per altre informazioni, vedere Iteratori verificati.

Esempio

Vedere gli esempi per slice::slice e gslice::gslice per un esempio di come dichiarare e usare operator[].

`operator^=`

Ottiene l'esclusivo bit per bit o (^) di un valarray oggetto con un valore specificato valarray o un valore del tipo di elemento.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray che deve essere combinato dall'operatore esclusivo bit per bit o (XOR) (^) con l'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono esclusivi bit per bit o (XOR) dell'operando valarray e right.

Osservazioni:

L'esclusivo bit per bit o, definito XOR e indicato dall'operatore ^, ha la semantica seguente: i bit b1 specificati e b2, b1 ^ b2 è 1 se esattamente uno degli elementi è 1 e 0 se entrambi gli elementi sono 0 o 1.

Esempio

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

Ottiene l'OR bit per bit (|) degli elementi in una matrice con gli elementi corrispondenti in un oggetto specificato valarray o con un valore del tipo di elemento.

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

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

Parametri

right
Valore valarray o di un tipo di elemento identico a quello dell'operando valarray che deve essere combinato, elemento per elemento, dall'OR bit per bit (|) con l'operando valarray.

Valore restituito

Oggetto valarray i cui elementi sono l'OR| bit per bit bit per elemento () dell'operando valarray da right.

Osservazioni:

Un'operazione bit per bit può essere usata solo per modificare i bit nei tipi di dati integrali, ad char esempio e int. Non funziona in float, double, long double, void, boolo altri tipi di dati più complessi.

L'OR bit per bit (|) si applica al tipo di dati a livello dei singoli bit. I bit b1 specificati e b2, b1 | b2 è 1 se almeno uno dei bit è 1; 0 se entrambi i bit sono 0.

Esempio

// 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~`

Operatore unario che ottiene il complemento bit per bit dei valori di ogni elemento in un oggetto valarray.

valarray<Type> operator~() const;

Valore restituito

Oggetto valarray dei valori che rappresentano il complemento bit per bit unario dei valori di elemento dell'operando valarray.

Osservazioni:

Un'operazione bit per bit può modificare solo i bit nei tipi integrali, ad esempio char e int. Non funziona in float, double, long double, void, boolo altri tipi di dati più complessi.

L'operatore ~ di complemento bit per bit unario si applica al tipo di dati a livello dei singoli bit. Dato bit b, ~b è 1 se b è 0 e 0 se b è 1.

Esempio

// 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`

Modifica il numero di elementi in un valarray oggetto in un numero specificato.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Parametri

new_size
Numero di elementi nell'oggetto ridimensionato valarray.

val
Valore da assegnare agli elementi dell'oggetto ridimensionato valarray.

Osservazioni:

La prima funzione membro inizializza gli elementi con il costruttore predefinito.

Eventuali puntatori o riferimenti agli elementi nella sequenza controllata vengono invalidati.

Esempio

Nell'esempio seguente viene illustrato l'uso della valarray::resize funzione membro.

// 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`

Sposta tutti gli elementi in un valarray oggetto in base a un numero specificato di posizioni.

valarray<Type> shift(int count) const;

Parametri

count
Numero di posizioni in base al quale gli elementi devono essere spostati in avanti.

Valore restituito

valarray Nuovo oggetto in cui tutti gli elementi sono stati spostati count verso la parte anteriore di valarrayo verso sinistra rispetto alle rispettive posizioni nell'operando valarray.

Osservazioni:

Un valore positivo count sposta gli elementi verso sinistra di un numero di posizioni pari a count, con riempimento zero.

Un valore negativo count sposta gli elementi verso destra di un numero di posizioni pari a count, con riempimento zero.

Esempio

// 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`

Trova il numero di elementi in un oggetto valarray.

size_t size() const;

Valore restituito

Numero di elementi nell'operando valarray.

Esempio

Nell'esempio seguente viene illustrato l'uso della valarray::size funzione membro.

// 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`

Determina la somma di tutti gli elementi in un oggetto valarray di lunghezza diversa da zero.

Type sum() const;

Valore restituito

Somma degli elementi dell'operando valarray.

Osservazioni:

Se la lunghezza è maggiore di una, la funzione membro aggiunge valori alla somma applicando operator+= tra coppie di elementi della classe Type. Significa che l'operatore deve essere fornito per gli elementi di tipo Type.

Esempio

// 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`

Scambia gli elementi di due oggetti valarray.

void swap(valarray& right);

Parametri

right
Oggetto valarray che fornisce gli elementi da scambiare.

Osservazioni:

La funzione membro scambia le sequenze controllate tra *this e right. Lo fa in tempo costante, non genera eccezioni e non invalida riferimenti, puntatori o iteratori agli elementi nelle due sequenze controllate.

`valarray`

Costruisce un oggetto valarray di una dimensione specifica o con elementi di un determinato valore oppure come copia di un altro oggetto valarray o subset di un altro oggetto 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);

Parametri

count
Numero di elementi da inserire nell'oggetto valarray.

val
Valore da utilizzare per inizializzare gli elementi nell'oggetto valarray.

ptr
Puntatore ai valori da utilizzare per inizializzare gli elementi in valarray.

right
Oggetto esistente valarray per inizializzare il nuovo valarrayoggetto .

sliceArray
Oggetto slice_array i cui valori di elemento devono essere utilizzati per inizializzare gli elementi dell'oggetto valarray costruito.

gsliceArray
Oggetto gslice_array i cui valori di elemento devono essere utilizzati per inizializzare gli elementi dell'oggetto valarray costruito.

maskArray
Oggetto mask_array i cui valori di elemento devono essere utilizzati per inizializzare gli elementi dell'oggetto valarray costruito.

indArray
Oggetto indirect_array i cui valori di elemento devono essere utilizzati per inizializzare gli elementi dell'oggetto valarray costruito.

iList
Oggetto initializer_list contenente gli elementi da copiare.

Osservazioni:

Il primo costruttore (predefinito) inizializza l'oggetto in un oggetto vuoto valarray. I tre costruttori successivi inizializzano l'oggetto in un valarray di count elementi come indicato di seguito:

Per un oggetto valarray(size_t count) esplicito, ogni elemento viene inizializzato con un costruttore predefinito.
Per valarray(const Type& val, count), ogni elemento viene inizializzato con val.
Per valarray(const Type* ptr, count), l'elemento in corrispondenza della posizione I viene inizializzato con ptr[I].

Ogni costruttore rimanente inizializza l'oggetto in un valarray<Type> oggetto determinato dal subset specificato nell'argomento .

L'ultimo costruttore è uguale all'ultimo, ma con un dichiaratore di riferimento Rvalue: &&.

Esempio

// 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`

Tipo che rappresenta il tipo di elemento archiviato in un oggetto valarray.

typedef Type value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Type.

Esempio

// 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 ).

Vedi anche

Thread safety nella libreria standard C++

Condividi tramite

Classe valarray

Osservazioni:

Membri

Costruttori

Typedef

Funzioni

Operatori

apply

Parametri

Valore restituito

Osservazioni:

Esempio

cshift

Parametri

Valore restituito

Osservazioni:

Esempio

free

Osservazioni:

max

Valore restituito

Osservazioni:

Esempio

min

Valore restituito

Osservazioni:

Esempio

operator!

Valore restituito

Osservazioni:

Esempio

operator%=

Parametri

Valore restituito

Esempio

operator&=

Parametri

Valore restituito

Osservazioni:

Esempio

operator>>=

Parametri

Valore restituito

Osservazioni:

Esempio

operator<<=

Parametri

Valore restituito

Osservazioni:

Esempio

operator*=

Parametri

Valore restituito

Esempio

operator+

Valore restituito

Esempio

operator+=

Parametri

Valore restituito

Esempio

operator-

Valore restituito

Esempio

operator-=

Parametri

Valore restituito

Esempio

operator/=

Parametri

Valore restituito

Esempio

operator=

Parametri

Valore restituito

Osservazioni:

Esempio

operator[]

Parametri

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`