Classe `valarray`

Artigo
08/04/2024

O modelo de classe valarray<Type>descreve um objeto que controla uma sequência de elementos do tipo Type que são classificados como uma matriz, projetada para operações matemáticas em alta velocidade e otimizada para o desempenho computacional.

Comentários

A classe é uma representação do conceito matemático de um conjunto ordenado de valores. Seus elementos são numerados sequencialmente de zero. A classe é descrita como um quase contêiner, pois dá suporte a alguns, mas não todos os recursos de primeira classe que contêineres de sequência oferecem suporte, como vector. Ela difere do modelo de classe vector de duas maneiras importantes:

Ela define muitas operações aritméticas entre elementos correspondentes de objetos valarray<Type> do mesmo tipo e comprimento, como varr_x* = cos(varr_y) + sin(varr_z).
Ela define várias formas interessantes de subscrever um objeto valarray<Type>, sobrecarregando operator[].

Um objeto de classe Type:

Tem um construtor padrão público, um destruidor, um construtor de cópia e um operador de atribuição com comportamento convencional.
Define os operadores aritméticos e funções matemáticas, conforme necessário, definidos para os tipos de ponto flutuante com comportamento convencional.

Em particular, talvez não exista nenhuma diferença sutil entre a construção da cópia e a construção padrão seguida pela atribuição. Nenhuma das operações em objetos da classe Type pode gerar exceções.

Membros

Construtores

Nome	Descrição
`valarray`	Constrói um `valarray` de um tamanho específico ou com elementos de um valor específico ou como uma cópia de outro `valarray` ou um subconjunto de outro `valarray`.

Typedefs

Nome	Descrição
`value_type`	Um tipo que representa o tipo de elemento armazenado em um `valarray`.

Funções

Nome	Descrição
`apply`	Aplica uma função especificada a cada elemento de um `valarray`.
`cshift`	De forma cíclica, desloca todos os elementos em um `valarray` por meio de um número especificado de posições.
`free`	Libera a memória usada pelo `valarray`.
`max`	Localiza o maior elemento em um `valarray`.
`min`	Localiza o menor elemento em um `valarray`.
`resize`	Altera o número de elementos em um `valarray` para um número especificado, adicionando ou removendo elementos conforme necessário.
`shift`	Desloca todos os elementos em um `valarray` por meio de um número especificado de posições.
`size`	Localiza o número de elementos em um `valarray`.
`sum`	Determina a soma de todos os elementos em um `valarray` de comprimento diferente de zero.
`swap`

Operadores

Nome	Descrição
`operator!`	Um operador unário que obtém os valores de expressão NOT lógica (`!`) de cada elemento em uma `valarray`.
`operator%=`	Obtém o resto da divisão dos elementos de uma matriz elemento a elemento por meio de um `valarray` especificado ou de um valor do tipo de elemento.
`operator&=`	Obtém o bit a bit AND (`&`) de elementos em uma matriz com os elementos correspondentes em um `valarray` especificado ou com um valor do tipo de elemento.
`operator>>=`	Desloca para a direita os bits de cada elemento de um operando `valarray` por um número especificado de posições ou por uma quantidade elemento a elemento especificada por um segundo `valarray`.
`operator<<=`	Desloca para a esquerda os bits de cada elemento de um operando `valarray` por um número especificado de posições ou por uma quantidade elemento a elemento especificada por um segundo `valarray`.
`operator*=`	Multiplica os elementos de um `valarray` especificado ou um valor do tipo de elemento, elemento a elemento, para um operando `valarray`.
`operator+`	Um operador unário que aplica a um sinal de adição a cada elemento em um `valarray`. Em tipos aritméticos normais, esse operador não tem efeito.
`operator+=`	Adiciona os elementos de um `valarray` especificado ou um valor do tipo de elemento, elemento a elemento, a um operando `valarray`.
`operator-`	Um operador unário que aplica uma negação aritmética a cada elemento em uma `valarray`.
`operator-=`	Subtrai os elementos de um `valarray` especificado ou um valor do tipo de elemento, elemento a elemento, de um operando `valarray`.
`operator/=`	Divide um operando `valarray`, elemento a elemento, pelos elementos de um `valarray` especificado ou um valor do tipo de elemento.
`operator=`	Atribui elementos a um `valarray` cujos valores são especificados diretamente ou como parte de algum outro `valarray` ou por um `slice_array`, `gslice_array`, `mask_array` ou `indirect_array`.
`operator[]`	Retorna uma referência a um elemento ou seu valor no índice ou subconjunto especificado.
`operator^=`	Obtém o bit a bit exclusivo ou (`^`) de um `valarray` com um valor especificado `valarray` ou um valor do tipo de elemento.
`operator\|=`	Obtém o bit a bit OR (`\|`) de elementos em uma matriz com os elementos correspondentes em um `valarray` especificado ou com um valor do tipo de elemento.
`operator~`	Um operador unário que obtém os valores de complemento bit a bit (`~`) de cada elemento em um `valarray`.

`apply`

Aplica uma função especificada a cada elemento de um valarray.

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

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

Parâmetros

function_object(Type)
O objeto de função a ser aplicado a cada elemento do operando valarray.

function_object(const Type&)
O objeto de função de elementos const a ser aplicado a cada elemento do operando valarray.

Valor retornado

Um valarray cujos elementos tiveram function_object aplicados elemento a elemento aos elementos do operando valarray.

Comentários

A função de membro retorna um objeto de classe valarray<Type>, de comprimento size, em que cada um dos elmentos elem é o resultado de function_object((*this)[elem]).

Exemplo

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

De forma cíclica, desloca todos os elementos em um valarray por meio de um número especificado de posições.

valarray<Type> cshift(int count) const;

Parâmetros

count
O número de locais para os quais os elementos serão deslocados para frente.

Valor retornado

Um novo valarray em que todos os elementos tenham sido movidos para posições count de forma cíclica em direção à parte frontal do valarray ou à esquerda em relação às suas posições no operando valarray.

Comentários

Um valor positivo de count desloca os elementos, de forma cíclica, para uma posição count à esquerda.

Um valor negativo de count desloca os elementos, de forma cíclica, para uma posição count à direita.

Exemplo

// 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 a memória usada pelo valarray.

void free();

Comentários

Essa função não padrão é equivalente a atribuir um valarray vazio. Por exemplo:

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

// equivalent to v.free()

`max`

Localiza o maior elemento em um valarray.

Type max() const;

Valor retornado

O valor máximo dos elementos na valarray operando valarray.

Comentários

A função de membro compara valores aplicando operator< ou operator> entre pares de elementos da classe Type, para a qual os operadores devem ser fornecidos para o elemento Type.

Exemplo

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

Localiza o menor elemento em um valarray.

Type min() const;

Valor retornado

O valor mínimo dos elementos no operando valarray.

Comentários

A função de membro compara valores aplicando operator< ou operator> entre pares de elementos da classe Type, para a qual os operadores devem ser fornecidos para o elemento Type.

Exemplo

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

Um operador unário que obtém os valores de expressão NOT lógica (!) de cada elemento em uma valarray.

valarray<bool> operator!() const;

Valor retornado

O valarray de valores boolianos que são a negação dos valores de elemento do operando valarray.

Comentários

A operação lógica NOT, denotada por !, nega logicamente os elementos porque converte todos os valores zero em true e todos os valores não zero em false. O valarray retornado de valores boolianos tem o mesmo tamanho que o operando valarray.

Exemplo

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

Obtém o resto da divisão dos elementos de uma matriz elemento a elemento por meio de um valarray especificado ou de um valor do tipo de elemento.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que dividirá, elemento a elemento, o operando valarray.

Valor retornado

Um valarray cujos elementos são o restante da divisão elemento a elemento do operando valarray por right.

Exemplo

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

Obtém o bit a bit AND (&) de elementos em uma matriz com os elementos correspondentes em um valarray especificado ou com um valor do tipo de elemento.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que será combinado, elemento a elemento, pelo AND (&) bit a bit com o operando valarray.

Valor retornado

Um valarray cujos elementos são o bit a bit AND (&) do operando valarray por right

Comentários

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

O bit a bit AND (&) á aplicado ao tipo de dados no nível dos bits individuais. Dados bits b1 e b2, b1 & b2 é 1 se ambos os bits forem 1; 0 se pelo menos um bit for 0.

Exemplo

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

Desloca para a direita os bits de cada elemento de um operando valarray por um número especificado de posições ou por uma quantidade elemento a elemento especificada por um segundo valarray.

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

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

Parâmetros

right
O valor que indica a quantidade de deslocamentos para a direita ou um valarray cujos elementos indicam a quantidade, elemento a elemento, dos deslocamentos para a direita.

Valor retornado

Um valarray cujos elementos foram deslocados para a direita conforme o valor especificado em right.

Comentários

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

Exemplo

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

Desloca para a esquerda os bits de cada elemento de um operando valarray por um número especificado de posições ou por uma quantidade elemento a elemento especificada por um segundo valarray.

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

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

Parâmetros

right
O valor que indica a quantidade de deslocamentos para a esquerda ou um valarray cujos elementos indicam a quantidade, elemento a elemento, dos deslocamentos para a esquerda.

Valor retornado

Um valarray cujos elementos foram deslocados para a esquerda conforme o valor especificado em right.

Comentários

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

Exemplo

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

Multiplica os elementos de um valarray especificado ou um valor do tipo de elemento, elemento a elemento, para um operando valarray.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que dividirá, elemento a elemento, o operando valarray.

Valor retornado

Um valarray cujos elementos são o produto, elemento a elemento, do operando valarray e right.

Exemplo

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

Um operador unário que aplica a um sinal de adição a cada elemento em um valarray. Para valores aritméticos normais, essa operação não tem efeito.

valarray<Type> operator+() const;

Valor retornado

Um valarray cujos elementos são o unário mais o resultado da matriz do operando.

Exemplo

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

Adiciona os elementos de um valarray especificado ou um valor do tipo de elemento, elemento a elemento, a um operando valarray.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que será adicionado, elemento a elemento, ao operando valarray.

Valor retornado

Um valarray cujos elementos são a soma relacionada elemento a elemento do operando valarray e right.

Exemplo

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

Um operador unário que aplica uma negação aritmética a cada elemento em uma valarray.

valarray<Type> operator-() const;

Valor retornado

Um valarray cujos elementos são aritmeticamente negados dos elementos do operando valarray.

Exemplo

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

Subtrai os elementos de um valarray especificado ou um valor do tipo de elemento, elemento a elemento, de um operando valarray.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que será subtraído, elemento a elemento, do operando valarray.

Valor retornado

Um valarray cujos elementos são a diferença, elemento a elemento, do operando valarray e right.

Exemplo

// 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 um operando valarray, elemento a elemento, pelos elementos de um valarray especificado ou um valor do tipo de elemento.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que será dividido, elemento a elemento, no operando valarray.

Valor retornado

Um valarray cujos elementos são o quociente, elemento a elemento, do operando valarray dividido por right.

Exemplo

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

Atribui elementos a um valarray cujos valores são especificados diretamente ou como parte de algum outro valarray ou por um slice_array, gslice_array, mask_array ou indirect_array.

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

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

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

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

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

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

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

Parâmetros

right
O valarray a ser copiado para o operando valarray.

val
O valor a ser atribuído aos elementos do operando valarray.

slicearray
O slice_array a ser copiado para o operando valarray.

gslicearray
O gslice_array a ser copiado para o operando valarray.

maskarray
O mask_array a ser copiado para o operando valarray.

indarray
O indirect_array a ser copiado para o operando valarray.

Valor retornado

O primeiro operador de membro substitui a sequência controlada por uma cópia da sequência controlada por right.

O segundo operador de membro é o mesmo que o primeiro, mas com um Declarador de referência Rvalue: &&.

O terceiro operador de membro substitui cada elemento da sequência controlada por uma cópia de val.

Os operadores de membro restantes substituem os elementos da sequência controlada selecionada por seus argumentos, que são gerados somente por operator[].

Se o valor de um membro na sequência controlada de substituição depender de um membro na sequência controlada inicial, o resultado será indefinido.

Comentários

Se o comprimento da sequência controlada for alterado, normalmente, o resultado será indefinido. Nessa implementação, no entanto, o efeito é simplesmente invalidar quaisquer ponteiros ou referências a elementos na sequência controlada.

Exemplo

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

Retorna uma referência a um elemento ou seu valor no índice ou subconjunto especificado.

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;

Parâmetros

index
O índice do elemento que terá um valor atribuído.

slicearray
Um slice_array de um valarray que especifica um subconjunto a ser selecionado ou retornado para um novo valarray.

gslicearray
Um gslice_array de um valarray que especifica um subconjunto a ser selecionado ou retornado para um novo valarray.

boolarray
Um bool_array de um valarray que especifica um subconjunto a ser selecionado ou retornado para um novo valarray.

indarray
Um indirect_array de um valarray que especifica um subconjunto a ser selecionado ou retornado para um novo valarray.

Valor retornado

Uma referência a um elemento ou seu valor no índice ou subconjunto especificado.

Comentários

O operador de membro será sobrecarregado para oferecer várias maneiras de selecionar sequências de elementos dentre os controlados por *this O primeiro grupo de cinco operadores de membro funciona em conjunto com várias sobrecargas de operator= (e outros operadores de atribuição) para permitir a substituição seletiva (slicing) da sequência controlada. Os elementos selecionados devem existir.

Quando compilado usando _ITERATOR_DEBUG_LEVEL definido como 1 ou 2, um erro de runtime ocorrerá se você tentar acessar um elemento fora dos limites do valarray. Para obter mais informações, confira Iteradores verificados.

Exemplo

Veja o exemplo de slice::slice e gslice::gslice que demonstra como declarar e usar operator[].

`operator^=`

Obtém o bit a bit exclusivo ou (^) de um valarray com um valor especificado valarray ou um valor do tipo de elemento.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que será combinado pelo operador exclusivo bit a bit ou (XOR) (^) com o operando valarray.

Valor retornado

Um valarray cujos elementos são o exclusivo bit a bit ou (XOR) do operando valarray e right.

Comentários

O bit a bit exclusivo ou, conhecido como XOR e indicado pelo operador ^, tem a seguinte semântica: Dado bits b1 e b2, b1 ^ b2 é 1 se exatamente um dos elementos for 1 e 0 se ambos os elementos forem 0 ou 1.

Exemplo

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

Obtém o bit a bit OR (|) de elementos em uma matriz com os elementos correspondentes em um valarray especificado ou com um valor do tipo de elemento.

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

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

Parâmetros

right
O valarray ou valor de um tipo de elemento idêntico ao do operando valarray que será combinado, elemento a elemento, pelo OR (|) bit a bit com o operando valarray.

Valor retornado

Um valarray cujos elementos são o OR (|) bit a bit, elemento a elemento do operando valarray por right.

Comentários

O OR (|) bit a bit aplicará ao tipo de dados no nível dos bits individuais. Dados bits b1 e b2, b1 | b2 é 1 se pelo menos um dos bits for 1; 0 se ambos forem 0.

Exemplo

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

Um operador unário que obtém o complemento bit a bit de valores de cada elemento em um valarray.

valarray<Type> operator~() const;

Valor retornado

O valarray de valores que são o complemento bit a bit unário dos valores de elemento do operando valarray.

Comentários

Uma operação bit a bit só pode manipular bits em tipos integrais, como char e int. Ele não funciona em float, double, long double, void, bool ou ou outros tipos de dados mais complexos.

O operador ~ de complemento bit a bit unário aplica-se ao tipo de dados no nível dos bits individuais. Dado o bit b, ~b é 1 se b for 0 e 0 se b for 1.

Exemplo

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

Altera o número de elementos em um valarray para um número especificado.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Parâmetros

new_size
O número de elementos no valarray redimensionado.

val
O valor a ser atribuído aos elementos do valarray redimensionado.

Comentários

A primeira função membro inicializa elementos com o construtor padrão.

Quaisquer ponteiros ou referências a elementos na sequência controlada serão invalidadas.

Exemplo

O exemplo a seguir demonstra o uso da função de membro valarray::resize.

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

Desloca todos os elementos em um valarray por meio de um número especificado de locais.

valarray<Type> shift(int count) const;

Parâmetros

count
O número de locais para os quais os elementos serão deslocados para frente.

Valor retornado

Um novo valarray em que todos os elementos tenham sido movidos para posições count em direção à parte frontal do valarray ou à esquerda em relação às suas posições no operando valarray.

Comentários

Um valor positivo de count desloca os elementos para as posições count à esquerda, com preenchimento zero.

Um valor negativo de count desloca os elementos para as posições count à direita, com preenchimento zero.

Exemplo

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

Localiza o número de elementos em um valarray.

size_t size() const;

Valor retornado

O número de elementos no operando valarray.

Exemplo

O exemplo a seguir demonstra o uso da função de membro valarray::size.

// 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 a soma de todos os elementos em um valarray de comprimento diferente de zero.

Type sum() const;

Valor retornado

A soma dos elementos do operando valarray.

Comentários

Se o comprimento for maior do que um, a função membro adicionará valores a soma aplicando operator+= entre pares de elementos da classe Type. Isso significa que o operador precisa ser fornecido para elementos do tipo Type.

Exemplo

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

Troca os elementos de dois objetos valarray.

void swap(valarray& right);

Parâmetros

right
Um valarray que fornece os elementos a serem trocados.

Comentários

A função membro troca as sequências controladas entre *this e right. Ela faz isso em tempo constante, não gera exceções e não invalida referências, ponteiros ou iteradores para elementos nas duas sequências controlados.

`valarray`

Constrói um valarray de um tamanho específico ou com elementos de um valor específico ou como uma cópia de outro valarray ou um subconjunto de outro 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);

Parâmetros

count
O número de elementos que estarão no valarray.

val
O valor a ser usado ao inicializar os elementos no valarray.

ptr
Ponteiro para os valores a serem usados ao inicializar os elementos no valarray.

right
Um valarray existente para inicializar o novo valarray.

sliceArray
Um slice_array cujos valores de elemento serão usados ao inicializar os elementos do valarray em construção.

gsliceArray
Um gslice_array cujos valores de elemento serão usados ao inicializar os elementos do valarray em construção.

maskArray
Um mask_array cujos valores de elemento serão usados ao inicializar os elementos do valarray em construção.

indArray
Um indirect_array cujos valores de elemento serão usados ao inicializar os elementos do valarray em construção.

iList
O initializer_list contendo os elementos a serem copiados.

Comentários

O primeiro construtor (padrão) inicializa o objeto em um valarray vazio. Cada um dos próximos três construtores inicializa o objeto em um valarray de elementos count da seguinte maneira:

Para o valarray(size_t count) explícito, cada elemento será inicializado com o construtor padrão.
Para valarray(const Type& val, count), cada elemento será inicializado com val.
Para valarray(const Type* ptr, count), o elemento na posição I será inicializado com ptr[I].

Cada construtor restante inicializará o objeto para um objeto valarray<Type> determinado pelo subconjunto especificado no argumento.

O último construtor é o mesmo que o próximo ou último, mas com um Declarador de Referência Rvalue: &&.

Exemplo

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

Um tipo que representa o tipo de elemento armazenado em um valarray.

typedef Type value_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloType.

Exemplo

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

Confira também

Segurança de thread na Biblioteca Padrão do C++

Compartilhar via

Classe valarray

Comentários

Membros

Construtores

Typedefs

Funções

Operadores

apply

Parâmetros

Valor retornado

Comentários

Exemplo

cshift

Parâmetros

Valor retornado

Comentários

Exemplo

free

Comentários

max

Valor retornado

Comentários

Exemplo

min

Valor retornado

Comentários

Exemplo

operator!

Valor retornado

Comentários

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 retornado

Comentários

Exemplo

operator*=

Parâmetros

Valor retornado

Exemplo

operator+

Valor retornado

Exemplo

operator+=

Parâmetros

Valor retornado

Exemplo

operator-

Valor retornado

Exemplo

operator-=

Parâmetros

Valor retornado

Exemplo

operator/=

Parâmetros

Valor retornado

Exemplo

operator=

Parâmetros

Valor retornado

Comentários

Exemplo

operator[]

Parâmetros

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`