Operatori `<valarray>`

Articolo
10/12/2023

`operator!=`

Verifica se gli elementi corrispondenti di due oggetti di dimensioni valarray uguali sono diversi o se tutti gli elementi di un oggetto valarray non sono uguali a un valore specificato.

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

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

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

Parametri

left
Oggetto valarray i cui elementi devono essere testati per verificare la disuguaglianza rispetto a un altro valarray oggetto o un valore di tipo elemento da confrontare con ogni elemento in un oggetto valarray.

right
Oggetto valarray i cui elementi devono essere testati per verificare la disuguaglianza rispetto a un altro valarray oggetto o un valore di tipo elemento da confrontare con ogni elemento in un oggetto valarray.

Valore restituito

Oggetto valarray di valori booleani, ognuno dei quali è:

true se gli elementi corrispondenti sono diversi.
false se gli elementi corrispondenti sono uguali.

Osservazioni:

Il primo operatore modello restituisce un oggetto della classe valarray<bool>, ognuno dei cui elementi I è left[I] != right[I].

Il secondo operatore modello archivia left[I] != right nell'elemento I.

Il terzo operatore modello archivia left != right[I] nell'elemento I.

Esempio

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

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

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

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

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

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

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

`operator%`

Ottiene il resto della divisione degli elementi corrispondenti di due oggetti di dimensioni valarray uguali o della divisione di un valarray oggetto per un valore specificato o della divisione di un valore specificato in base a un oggetto valarray.

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

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

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

Parametri

left
Valore o valarray che funge da dividendo in cui deve essere diviso un altro valore o valarray .

right
Valore o valarray che funge da divisore e che divide un altro valore o valarray.

Valore restituito

Oggetto valarray i cui elementi sono i rimanenti a livello di elemento di left diviso per right.

Esempio

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

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

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

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

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

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

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

`operator&`

Ottiene l'and bit per bit tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato del tipo di elemento.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'and bit per bit oppure un valore specificato del tipo di elemento da combinare in modo bit per bit con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con and bit per bit oppure un valore specificato del tipo di elemento da combinare in bit con AND bit per bit con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray i cui elementi sono la combinazione di elementi per elemento dell'operazione AND bit per bit di left e right.

Osservazioni:

Un'operazione bit per bit può essere usata solo per modificare i bit nei char tipi di dati e int le varianti e non in float, double, long double, void, bool o altri tipi di dati più complessi.

L'operatore AND bit per bit supporta la stessa tabella di verità dell'operatore AND logico, ma si applica al tipo di dati a livello dei singoli bit. Si operator&& applica a un livello di elemento, conteggiando tutti i valori diversi da zero come truee il risultato è un valarray di valori booleani. L'and operator&bit per bit, al contrario, può comportare valori valarray diversi da 0 o 1, a seconda del risultato dell'operazione bit per bit.

Esempio

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

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

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

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

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

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

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

`operator&&`

Ottiene l'AND logico tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato del valarray tipo di elemento.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'AND logico o un valore specificato del tipo di elemento da combinare con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'AND logico oppure un valore specificato del tipo di elemento da combinare con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray i cui elementi sono di tipo bool e sono la combinazione a livello di elemento dell'operazione AND logica di left e right.

Osservazioni:

L'AND operator&& logico si applica a un livello di elemento, conteggiando tutti i valori diversi da zero come truee il risultato è un valarray valore booleano. La versione bit per bit di AND, , operator&al contrario, può comportare valori valarray diversi da 0 o 1, a seconda del risultato dell'operazione bit per bit.

Esempio

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

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

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

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

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

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

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

`operator>`

Verifica se gli elementi di uno valarray sono maggiori degli elementi di un oggetto di dimensioni valarrayuguali o se tutti gli elementi di un valarray oggetto sono maggiori o minori di un valore specificato.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray di valori booleani, ognuno dei quali è:

true se l'elemento o il left valore è maggiore dell'elemento o del valore corrispondente right .
false se l'elemento o il left valore non è maggiore dell'elemento o del valore corrispondente right .

Osservazioni:

Se il numero di elementi nei due valarray oggetti non è uguale, il risultato non è definito.

Esempio

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

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

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

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

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

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

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

`operator>=`

Verifica se gli elementi di uno valarray sono maggiori o uguali agli elementi di un oggetto di dimensioni valarrayuguali o se tutti gli elementi di un valarray oggetto sono maggiori o uguali o minori o uguali a un valore specificato.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray di valori booleani, ognuno dei quali è:

true se l'elemento o il left valore è maggiore o uguale all'elemento o al valore corrispondente right .
false se l'elemento o il left valore è minore dell'elemento o del valore corrispondente right .

Osservazioni:

Se il numero di elementi in due valarray oggetti non è uguale, il risultato non è definito.

Esempio

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

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

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

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

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

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

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

`operator>>`

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

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

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

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

Parametri

left
Valore da spostare o i valarray cui elementi devono essere spostati.

right
Valore che indica la quantità di spostamento a destra o 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 dall'importo specificato.

Osservazioni:

Per i numeri con segno, i segni vengono mantenuti.

Esempio

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

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

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

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

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

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

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

`operator<`

Verifica se gli elementi di uno valarray sono minori degli elementi di un oggetto di dimensioni valarrayuguali o se tutti gli elementi di un valarray oggetto sono maggiori o minori di un valore specificato.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray di valori booleani, ognuno dei quali è:

true se l'elemento o il left valore è minore dell'elemento o del valore corrispondente right .
false se l'elemento o il left valore non è minore dell'elemento o del valore corrispondente right .

Osservazioni:

Se il numero di elementi in due valarray oggetti non è uguale, il risultato non è definito.

Esempio

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

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

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

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

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

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

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

`operator<=`

Verifica se gli elementi di uno valarray sono minori o uguali agli elementi di un oggetto di dimensioni valarrayuguali o se tutti gli elementi di un valarray oggetto sono maggiori o uguali o minori o uguali a un valore specificato.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui elementi devono essere confrontati o un valore specificato da confrontare con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray di valori booleani, ognuno dei quali è:

true se l'elemento o il left valore è minore o uguale all'elemento o al valore corrispondente right .
false se l'elemento o il left valore è maggiore dell'elemento o del valore corrispondente right .

Osservazioni:

Se il numero di elementi in due valarray oggetti non è uguale, il risultato non è definito.

Esempio

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

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

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

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

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

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

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

`operator<<`

A sinistra sposta i bit per ogni elemento di un valarray numero specificato di posizioni o per un importo per elemento specificato da un secondo valarray.

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

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

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

Parametri

left
Valore da spostare o i valarray cui elementi devono essere spostati.

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

Valore restituito

Oggetto valarray i cui elementi sono stati spostati a sinistra dall'importo specificato.

Osservazioni:

Per i numeri con segno, i segni vengono mantenuti.

Esempio

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

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

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

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

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

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

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

`operator*`

Ottiene il prodotto a livello di elemento tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui elementi devono essere moltiplicati o un valore specificato da moltiplicare con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui elementi devono essere moltiplicati o un valore specificato da moltiplicare con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray i cui elementi sono il prodotto a livello di elemento di left e right.

Esempio

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

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

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

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

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

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

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

`operator+`

Ottiene la somma a livello di elemento tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui elementi devono essere aggiunti o un valore specificato da aggiungere con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui elementi devono essere aggiunti o un valore specificato da aggiungere con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray i cui elementi sono la somma a livello di elemento di left e right.

Esempio

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

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

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

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

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

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

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

`operator-`

Ottiene la differenza per elemento tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato.

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

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

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

Parametri

left
Valore o valarray che funge da minuend, valore da cui devono essere sottratti altri valori o valarray oggetti nella forma della differenza.

right
Valore o valarray che funge da sottrazione, valore che deve essere sottratto da altri valori o valarray oggetti nella forma della differenza.

Valore restituito

Oggetto valarray i cui elementi sono la differenza a livello di elemento di left e right.

Osservazioni:

La terminologia aritmetica usata per descrivere una sottrazione è la seguente:

differenza = minuendo - sottraendo

Esempio

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

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

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

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

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

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

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

`operator/`

Ottiene il quoziente a livello di elemento tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato.

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

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

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

Parametri

left
Valore o valarray che funge da dividendo in cui un altro valore o valarray deve essere diviso in forma di quoziente.

right
Valore o valarray che funge da divisore e che divide un altro valore o valarray forma il quoziente.

Valore restituito

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

Osservazioni:

La terminologia aritmetica usata per descrivere una divisione è la seguente:

quoziente = dividendo / divisore

Esempio

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

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

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

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

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

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

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

`operator==`

Verifica se gli elementi corrispondenti di due oggetti di dimensioni valarray uguali sono uguali o se tutti gli elementi di un oggetto valarray sono uguali a un valore specificato.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui elementi devono essere testati per verificarne l'uguaglianza o un valore specificato da confrontare con ogni valarray elemento.

right
Secondo dei due valarray oggetti i cui elementi devono essere testati per verificarne l'uguaglianza o un valore specificato da confrontare con ogni valarray elemento.

Valore restituito

Oggetto valarray di valori booleani, ognuno dei quali è:

true se gli elementi corrispondenti sono uguali.
false se gli elementi corrispondenti non sono uguali.

Osservazioni:

Il primo operatore modello restituisce un oggetto della classe valarray<bool>, ognuno dei cui elementi I è left[I] == right[I]. Il secondo operatore modello archivia left[I] == right nell'elemento I. Il terzo operatore modello archivia left == right[I] nell'elemento I.

Esempio

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

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

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

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

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

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

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

`operator^`

Ottiene l'OR esclusivo bit per bit (XOR) tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato del tipo di elemento.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'XOR bit per bit o un valore specificato del tipo di elemento da combinare da un XOR bit per bit con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con XOR bit per bit o un valore specificato del tipo di elemento da combinare da un XOR bit per bit con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray i cui elementi sono la combinazione di elementi per elemento dell'operazione XOR bit per bit di left e right.

Osservazioni:

L'OR esclusivo bit per bit (XOR) ha la semantica seguente: i bit b 1 e b2, b1 XOR b2 sono 1 se esattamente uno dei bit è 1; 0 se entrambi i bit sono 0 o se entrambi i bit sono 1.

Esempio

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

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

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

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

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

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

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

`operator|`

Ottiene l'OR bit per bit tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato del tipo di elemento.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'OR bit per bit o un valore specificato del tipo di elemento da combinare tramite OR bit per bit con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'OR bit per bit o un valore specificato del tipo di elemento da combinare tramite OR bit per bit con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray i cui elementi sono la combinazione elemento-saggio dell'operazione OR bit per bit di left e right.

Osservazioni:

L'OR bit per bit ha la stessa tabella verità dell'OR logico, ma si applica al tipo di dati a livello dei singoli bit. I bit b1 e b2, b1 OR b2 sono 1 se almeno uno dei bit è 1 o 0 se entrambi i bit sono 0. L'OR operator|| logico si applica a un livello di elemento, conteggiando tutti i valori diversi da zero come truee il risultato è un valarray valore booleano. L'OR operator|bit per bit, al contrario, può comportare valori valarray diversi da 0 o 1, a seconda del risultato dell'operazione bit per bit.

Esempio

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

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

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

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

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

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

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

`operator||`

Ottiene l'OR logico tra gli elementi corrispondenti di due oggetti di dimensioni valarray uguali o tra un valarray oggetto e un valore specificato del valarray tipo di elemento.

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

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

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

Parametri

left
Primo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'OR logico o un valore specificato del tipo di elemento da combinare con ogni elemento di un oggetto valarray.

right
Secondo dei due valarray oggetti i cui rispettivi elementi devono essere combinati con l'OR logico o un valore specificato del tipo di elemento da combinare con ogni elemento di un oggetto valarray.

Valore restituito

Oggetto valarray i cui elementi sono di tipo bool e sono la combinazione a livello di elemento dell'operazione OR logica di left e right.

Osservazioni:

L'OR operator|| logico si applica a un livello di elemento, conteggiando tutti i valori diversi da zero come truee il risultato è un valarray valore booleano. La versione bit per bit di OR, , operator|al contrario, può comportare valori valarray diversi da 0 o 1, a seconda del risultato dell'operazione bit per bit.

Esempio

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

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

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

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

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

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

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

Condividi tramite

Operatori <valarray>

operator!=

Parametri

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

Osservazioni:

Esempio

operator>>

Parametri

Valore restituito

Osservazioni:

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+

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

Osservazioni:

Esempio

operator|

Operatori `<valarray>`

`operator!=`

`operator%`

`operator&`

`operator&&`

`operator>`

`operator>=`

`operator>>`

`operator<`

`operator<=`

`operator<<`

`operator*`

`operator+`

`operator-`

`operator/`

`operator==`

`operator^`

`operator|`

`operator||`