Operadores `<valarray>`

Artigo
06/16/2023

`operator!=`

Testa se os elementos correspondentes de dois objetos valarray de tamanhos iguais são diferentes ou se todos os elementos de um valarray são diferentes de um valor especificado.

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);

Parâmetros

left
Um objeto valarray cujos elementos devem ser testados quanto à desigualdade em relação a outro objeto valarray ou um valor do tipo de elemento para comparar com cada elemento em um valarray.

right
Um objeto valarray cujos elementos devem ser testados quanto à desigualdade em relação a outro objeto valarray ou um valor do tipo de elemento para comparar com cada elemento em um valarray.

Valor retornado

Um valarray de valores boolianos, sendo cada um deles:

true se os elementos correspondentes forem diferentes.
false se os elementos correspondentes forem iguais.

Comentários

O primeiro operador de modelo retorna um objeto da classe valarray<bool>, cada um dos elementos I é left[I] != right[I].

O segundo operador de modelo armazena left[I] != right no elemento I.

O terceiro operador de modelo armazena left != right[I] no elemento I.

Exemplo

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

Obtém o restante da divisão dos elementos correspondentes de dois objetos valarray de tamanho igual, da divisão de um valarray por um valor especificado ou da divisão de um valor especificado por um 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);

Parâmetros

left
Um valor ou valarray que serve como dividendo no qual outro valor ou valarray deve ser dividido.

right
Um valor ou valarray que serve como divisor e que divide outro valor ou valarray.

Valor retornado

Um valarray cujos elementos são os restos elementares de left divididos por right.

Exemplo

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

Obtém o AND bit a bit entre os elementos correspondentes de dois objetos valarray de tamanho igual ou entre um valarray e um valor especificado do tipo de 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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos respectivos elementos devem ser combinados com o AND bit a bit ou um valor especificado do tipo de elemento a ser combinado pelo AND bit a bit com cada elemento de um valarray.

right
O segundo dos dois objetos valarray, cujos respectivos elementos deverão ser combinados com o AND bit a bit ou um valor especificado do tipo de elemento que deverá ser combinado bit a bit com cada elemento de uma valarray.

Valor de retorno

Uma valarray cujos elementos são a combinação elemento a elemento da operação AND bit a bit de left e right.

Comentários

Uma operação bit a bit só pode ser usada para manipular bits em tipos de dados e variantes char e int, e não em float, double, long double, void, bool ou outros tipos dados mais complexos.

O AND bit a bit tem a mesma tabela de verdade que o AND lógico, mas se aplica ao tipo de dados em nível de bits individuais. O operator&& se aplica no nível de elemento contando todos os valores diferentes de zero como true e o resultado é uma valarray de valores boolianos. O AND bit a bit operator&, por outro lado, pode resultar em um valarray de valores diferentes de 0 ou 1, dependendo do resultado da operação bit a bit.

Exemplo

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

Obtém o AND lógico entre os elementos correspondentes de dois objetos valarray de tamanhos iguais ou entre um valarray e um valor especificado do tipo de elemento valarray.

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

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

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

Parâmetros

left
O primeiro dos dois objetos valarray cujos respectivos elementos deverão ser combinados com o AND lógico ou um valor especificado do tipo de elemento que deverá ser combinado com cada elemento de um valarray.

direita
O segundo dos dois objetos valarray cujos respectivos elementos deverão ser combinados com o AND lógico ou um valor especificado do tipo de elemento que deverá ser combinado com cada elemento de um valarray.

Valor retornado

Um valarray cujos elementos são do tipo bool e são a combinação de elementos da operação lógica AND de left e right.

Comentários

O AND lógico operator&& se aplica em um nível de elemento, contando todos os valores diferentes de zero como true, e o resultado é um valarray de valores booleanos. A versão bit a bit de AND, operator&, por outro lado, pode resultar em um valarray de valores diferentes de 0 ou 1, dependendo do resultado da operação bit a bit.

Exemplo

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

Testa se os elementos de um valarray são maiores que os elementos de um valarray de tamanho igual ou se todos os elementos de um valarray são maiores ou menores que um valor especificado.

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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado a ser comparado com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado que deve ser comparado com cada elemento de um valarray.

Valor retornado

Um valarray de valores boolianos, sendo cada um deles:

true se o elemento ou valor left for maior que o elemento ou valor right correspondente.
false se o elemento ou valor left não for maior que o elemento ou valor right correspondente.

Comentários

Se o número de elementos nos dois objetos valarray não for igual, o resultado será indefinido.

Exemplo

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

Testa se os elementos de um valarray são maiores ou iguais aos elementos de um valarray de tamanho igual, ou se todos os elementos de um valarray são maiores ou iguais, ou menores ou iguais a um valor especificado.

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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado a ser comparado com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado que deve ser comparado com cada elemento de um valarray.

Valor retornado

Um valarray de valores boolianos, sendo cada um deles:

true se o valor ou o elemento left for maior ou igual ao valor ou ao elemento right correspondente.
false se o valor ou o elemento left for menor que o valor ou o elemento right correspondente.

Comentários

Se o número de elementos em dois objetos valarray não for igual, o resultado será indefinido.

Exemplo

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

Desloca os bits para a direita um número especificado de posições para cada elemento de um valarray ou para uma quantidade de elemento especificada por um segundo 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);

Parâmetros

left
O valor a ser deslocado ou o valarray cujos elementos devem ser deslocados.

right
O valor que indica a quantidade de deslocamento à direita ou um valarray cujos elementos indicam a quantidade de deslocamento à direita em relação ao elemento.

Valor retornado

Um valarray cujos elementos foram deslocados para a direita pelo valor especificado.

Comentários

Os números com sinais têm seus sinais preservados.

Exemplo

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

Testa se os elementos de um valarray são menores que os elementos de um valarray de tamanho igual ou se todos os elementos de um valarray são maiores ou menores que um valor especificado.

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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado a ser comparado com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado que deve ser comparado com cada elemento de um valarray.

Valor retornado

Um valarray de valores boolianos, sendo cada um deles:

true se o valor ou o elemento left for menor que o valor ou o elemento right correspondente.
false se o valor ou o elemento left não for menor que o valor ou o elemento right correspondente.

Comentários

Se o número de elementos em dois objetos valarray não for igual, o resultado será indefinido.

Exemplo

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

Testa se os elementos de um valarray são menores ou iguais aos elementos de um valarray de tamanho igual, ou se todos os elementos de um valarray são maiores ou iguais, ou menores ou iguais a um valor especificado.

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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado a ser comparado com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos elementos devem ser comparados ou um valor especificado que deve ser comparado com cada elemento de um valarray.

Valor retornado

Um valarray de valores boolianos, sendo cada um deles:

true se o elemento ou valor left for menor ou igual ao elemento ou valor right correspondente.
false se o elemento ou valor left for maior que o elemento ou valor right correspondente.

Comentários

Se o número de elementos em dois objetos valarray não for igual, o resultado será indefinido.

Exemplo

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

Desloca os bits para a esquerda para cada elemento de um valarray um número especificado de posições, ou por uma quantidade elemento-a-elemento especificada por um segundo 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);

Parâmetros

left
O valor a ser deslocado ou o valarray cujos elementos devem ser deslocados.

right
O valor que indica a quantidade de deslocamento à esquerda ou um valarray cujos elementos indicam a quantidade de deslocamento à esquerda por elemento.

Valor retornado

Um valarray cujos elementos foram deslocados para a esquerda pelo valor especificado.

Comentários

Os números com sinais têm seus sinais preservados.

Exemplo

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

Obtém o produto por elemento entre os elementos correspondentes de dois objetos valarray de tamanho igual ou entre um valarray e um valor especificado.

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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos elementos devem ser multiplicados ou um valor especificado a ser multiplicado por cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos elementos devem ser multiplicados ou um valor especificado a ser multiplicado por cada elemento de um valarray.

Valor retornado

Um valarray cujos elementos são o produto elemento a elemento de left e right.

Exemplo

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

Obtém a soma de elementos entre os elementos correspondentes de dois objetos valarray de tamanho igual ou entre um valarray e um valor especificado.

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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos elementos devem ser adicionados ou um valor especificado a ser adicionado com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos elementos devem ser adicionados ou um valor especificado a ser adicionado com cada elemento de um valarray.

Valor retornado

Um valarray cujos elementos são a soma de elementos de left e right.

Exemplo

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

Obtém a diferença de elemento entre os elementos correspondentes de dois objetos valarray de tamanho igual ou entre um valarray e um valor especificado.

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);

Parâmetros

left
Um valor ou valarray que serve como o minuendo, o valor do qual outros valores ou objetos valarray devem ser subtraídos na formação da diferença.

right
Um valor ou valarray que serve como o subtraendo, o valor que deve ser subtraído de outros valores ou objetos valarray na formação da diferença.

Valor retornado

Um valarray cujos elementos são a diferença de elemento a elemento de left e right.

Comentários

A terminologia aritmética usada na descrição de uma subtração:

diferença = diminuendo – subtraendo

Exemplo

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

Obtém o quociente de elemento entre os elementos correspondentes de dois objetos valarray de tamanho igual ou entre um valarray e um valor especificado.

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);

Parâmetros

left
Um valor ou valarray que serve como o dividendo no qual outro valor ou valarray deve ser dividido na formação do quociente.

right
Um valor ou valarray que serve como divisor e que divide outro valor ou valarray na formação do quociente.

Valor retornado

Um valarray cujos elementos são o quociente elemento a elemento de left dividido por right.

Comentários

A terminologia aritmética usada na descrição de uma divisão:

quociente = dividendo/divisor

Exemplo

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

Testa se os elementos correspondentes de dois objetos valarray de tamanho igual são iguais ou se todos os elementos de um valarray são iguais a um valor especificado.

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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos elementos devem ser testados quanto à igualdade ou um valor especificado para comparar com cada elemento valarray.

right
O segundo dos dois objetos valarray cujos elementos devem ser testados quanto à igualdade ou um valor especificado para comparar com cada elemento valarray.

Valor de retorno

Um valarray de valores boolianos, sendo cada um deles:

true se os elementos correspondentes forem iguais.
false se os elementos correspondentes não forem iguais.

Comentários

O primeiro operador de modelo retorna um objeto da classe valarray<bool>, cada um dos elementos I é left[I] == right[I]. O segundo operador de modelo armazena left[I] == right no elemento I. O terceiro operador de modelo armazena left == right[I] no elemento I.

Exemplo

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

Obtém o OR exclusivo (XOR) bit a bit entre os elementos correspondentes de dois objetos valarray de tamanhos iguais ou entre um valarray e um valor especificado do tipo de 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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos respectivos elementos devem ser combinados com o XOR bit a bit ou um valor especificado do tipo de elemento a ser combinado por um XOR bit a bit com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos respectivos elementos devem ser combinados com o XOR bit a bit ou um valor especificado do tipo de elemento a ser combinado por um XOR bit a bit com cada elemento de um valarray.

Valor retornado

Um valarray cujos elementos são a combinação elemento a elemento da operação XOR bit a bit de left e right.

Comentários

O OR exclusivo bit a bit (XOR) tem a seguinte semântica: Dados os bits b1 e b2, b1 XOR b2 é 1 se exatamente um dos bits for 1; 0 se ambos os bits forem 0 ou se ambos os bits forem 1.

Exemplo

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

Obtém o OR bit a bit entre os elementos correspondentes de dois objetos valarray de tamanhos iguais ou entre uma valarray e um valor especificado do tipo de 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);

Parâmetros

left
O primeiro dos dois objetos valarray cujos respectivos elementos devem ser combinados com o OR bit a bit, ou um valor especificado do tipo de elemento a ser combinado por OR bit a bit com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos respectivos elementos devem ser combinados com o OR bit a bit, ou um valor especificado do tipo de elemento a ser combinado por OR bit a bit com cada elemento de um valarray.

Valor retornado

Um valarray cujos elementos são a combinação elemento a elemento da operação OR bit a bit de left e right.

Comentários

O OR bit a bit tem a mesma tabela verdade que o OR lógico, mas se aplica ao tipo de dados no nível dos bits individuais. Dados os bits b1 e b2, b1 OR b2 é 1 se pelo menos um dos bits for 1, ou 0 se ambos os bits forem 0. O OR lógico operator|| se aplica em um nível de elemento, contando todos os valores diferentes de zero como true, e o resultado é um valarray de valores booleanos. O OR bit a bit operator|, por outro lado, pode resultar em um valarray de valores diferentes de 0 ou 1, dependendo do resultado da operação bit a bit.

Exemplo

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

Obtém o OR lógico entre os elementos correspondentes de dois objetos valarray de tamanho igual ou entre um valarray e um valor especificado do tipo de elemento valarray.

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

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

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

Parâmetros

left
O primeiro dos dois objetos valarray cujos respectivos elementos devem ser combinados com o OR lógico, ou um valor especificado do tipo de elemento a ser combinado com cada elemento de um valarray.

right
O segundo dos dois objetos valarray cujos respectivos elementos devem ser combinados com o OR lógico, ou um valor especificado do tipo de elemento a ser combinado com cada elemento de um valarray.

Valor retornado

Um valarray cujos elementos são do tipo bool e são a combinação de elementos da operação OR lógica de left e right.

Comentários

O OR lógico operator|| se aplica em um nível de elemento, contando todos os valores diferentes de zero como true, e o resultado é um valarray de valores booleanos. A versão bit a bit de OR, operator|, por outro lado, pode resultar em um valarray de valores diferentes de 0 ou 1, dependendo do resultado da operação bit a bit.

Exemplo

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

Compartilhar via

Operadores <valarray>

operator!=

Parâmetros

Valor retornado

Comentários

Exemplo

operator%

Parâmetros

Valor retornado

Exemplo

operator&

Parâmetros

Valor de retorno

Comentários

Exemplo

operator&&

Parâmetros

Valor retornado

Comentários

Exemplo

operator>

Parâmetros

Valor retornado

Comentários

Exemplo

operator>=

Parâmetros

Valor retornado

Comentários

Exemplo

operator>>

Parâmetros

Valor retornado

Comentários

Exemplo

operator<

Parâmetros

Valor retornado

Comentários

Exemplo

operator<=

Parâmetros

Valor retornado

Comentários

Exemplo

operator<<

Parâmetros

Valor retornado

Comentários

Exemplo

operator*

Parâmetros

Valor retornado

Exemplo

operator+

Parâmetros

Valor retornado

Exemplo

operator-

Parâmetros

Valor retornado

Comentários

Exemplo

operator/

Parâmetros

Valor retornado

Comentários

Exemplo

operator==

Parâmetros

Valor de retorno

Comentários

Exemplo

operator^

Parâmetros

Valor retornado

Comentários

Exemplo

operator|

Operadores `<valarray>`

`operator!=`

`operator%`

`operator&`

`operator&&`

`operator>`

`operator>=`

`operator>>`

`operator<`

`operator<=`

`operator<<`

`operator*`

`operator+`

`operator-`

`operator/`

`operator==`

`operator^`

`operator|`

`operator||`