Clase `valarray`

Artículo
06/16/2023

La clase de plantilla valarray<Type> describe un objeto que controla una secuencia de elementos de tipo Type que se almacenan como una matriz, que se diseñan para operaciones matemáticas de alta velocidad y están optimizados para ofrecer un alto rendimiento a la hora de realizar cálculos.

Comentarios

La clase es una representación del concepto matemático de un conjunto ordenado de valores. Sus elementos se numeran secuencialmente desde cero. La clase se describe como un pseudocontenedor porque es compatible con algunas de las funciones que admiten los contenedores de secuencias de primera clase, como vector, pero no con todas ellas. Difiere del vector de clase de plantilla en dos aspectos importantes:

Define muchas operaciones aritméticas entre los elementos correspondientes de objetos valarray<Type> del mismo tipo y longitud, como varr_x* = cos(varr_y) + sin(varr_z).
Define varias formas interesantes de crear un subscript de un objeto valarray<Type> mediante la sobrecarga de operator[].

Un objeto de clase Type:

Tiene un constructor público predeterminado, un destructor, un constructor de copias y un operador de asignación, con un comportamiento convencional.
Define, en la medida que sean necesarios, los operadores aritméticos y las funciones matemáticas que se definen para los tipos de punto flotante con un comportamiento convencional.

En concreto, no pueden existir diferencias sutiles entre la construcción de la copia y la construcción predeterminada seguida por una asignación. Ninguna de las operaciones en objetos de clase Type puede iniciar excepciones.

Miembros

Constructores

Nombre	Descripción
`valarray`	Construye una `valarray` de un tamaño específico o con elementos de un valor determinado, o como una copia de otra `valarray` o un subconjunto de otra `valarray`.

Typedefs

Nombre	Descripción
`value_type`	Tipo que representa el tipo de elemento almacenado en una `valarray`.

Funciones

Nombre	Descripción
`apply`	Aplica una función especificada a cada elemento de una `valarray`.
`cshift`	Desplaza de forma cíclica todos los elementos de una `valarray` un número especificado de posiciones.
`free`	Libera la memoria usada por la `valarray`.
`max`	Busca el elemento más grande en una `valarray`.
`min`	Busca el elemento más pequeño en una `valarray`.
`resize`	Cambia el número de elementos de una `valarray` por un número especificado, agregando o quitando elementos según sea necesario.
`shift`	Desplaza todos los elementos de una `valarray` un número especificado de posiciones.
`size`	Busca el número de elementos de una `valarray`.
`sum`	Determina la suma de todos los elementos de una `valarray` de longitud distinta de cero.
`swap`

Operadores

Nombre	Descripción
`operator!`	Un operador unario que obtiene los valores NOT (`!`) lógicos de cada elemento de una `valarray`.
`operator%=`	Obtiene el resto de la división de los elementos de una matriz uno a uno por una `valarray` especificada o por un valor del tipo de elemento.
`operator&=`	Obtiene el valor AND (`&`) bit a bit de los elementos de una matriz con los elementos correspondientes de una `valarray` especificada o con un valor del tipo de elemento.
`operator>>=`	Desplaza hacia la derecha los bits de cada elemento de un operando `valarray` un número especificado de posiciones o una cantidad de elementos especificada por una segunda `valarray`.
`operator<<=`	Desplaza hacia la izquierda los bits de cada elemento de un operando `valarray` un número especificado de posiciones o una cantidad de elementos especificada por una segunda `valarray`.
`operator*=`	Multiplica los elementos de una `valarray` especificada o un valor del tipo de elemento, uno a uno, por un operando `valarray`.
`operator+`	Operador unario que aplica un signo más a cada elemento de una `valarray`. En los tipos aritméticos normales, este operador no tiene ningún efecto.
`operator+=`	Suma los elementos de una `valarray` especificada o un valor del tipo de elemento, uno a uno, a un operando `valarray`.
`operator-`	Operador unario que aplica una negación aritmética a cada elemento de una `valarray`.
`operator-=`	Resta los elementos de una `valarray` especificada o un valor del tipo de elemento, uno a uno, de un operando `valarray`.
`operator/=`	Divide un operando `valarray` elemento a elemento por los elementos de una `valarray` especificada o un valor del tipo de elemento.
`operator=`	Asigna los elementos a una `valarray` cuyos valores se especifican directamente o como parte de otra `valarray` o mediante una `slice_array`, `gslice_array`, `mask_array` o `indirect_array`.
`operator[]`	Devuelve una referencia a un elemento o su valor en el índice especificado o un subconjunto especificado.
`operator^=`	Obtiene el valor exclusivo bit a bit or (`^`) de una `valarray` con una `valarray` especificada o un valor del tipo de elemento.
`operator\|=`	Obtiene el valor OR (`\|`) bit a bit de los elementos de una matriz con los elementos correspondientes de una `valarray` especificada o con un valor del tipo de elemento.
`operator~`	Operador unario que obtiene el complemento (`~`) bit a bit de cada elemento de una `valarray`.

`apply`

Aplica una función especificada a cada elemento de una valarray.

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

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

Parámetros

function_object(Type)
El objeto de función que se va a aplicar a cada elemento de la valarray de operando.

function_object(const Type&)
El objeto de función para los elementos const que se va a aplicar a elemento de la valarray de operando.

Valor devuelto

Una valarray a cuyos elementos se ha aplicado function_object por elemento a los elementos de la valarray de operando.

Comentarios

La función miembro devuelve un objeto de la clase valarray<Type>, de longitud size, cuyos elementos elem son el resultado de function_object((*this)[elem]).

Ejemplo

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

Desplaza de forma cíclica todos los elementos de una valarray un número especificado de posiciones.

valarray<Type> cshift(int count) const;

Parámetros

count
El número de posiciones que se van a desplazar hacia adelante los elementos.

Valor devuelto

Una nueva valarray en la que todos los elementos se han movido cíclicamente count posiciones hacia la parte delantera de la valarray, a la izquierda con respecto a sus posiciones en la valarray de operando.

Comentarios

Un valor positivo de count desplaza los elementos cíclicamente a la izquierda count posiciones.

Un valor negativo de count desplaza los elementos cíclicamente a la derecha count posiciones.

Ejemplo

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

#include <valarray>
#include <iostream>

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

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

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

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

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

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

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

`free`

Libera la memoria usada por la valarray.

void free();

Comentarios

Esta función no estándar es equivalente a asignar una valarray vacía. Por ejemplo:

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

// equivalent to v.free()

`max`

Busca el elemento más grande en una valarray.

Type max() const;

Valor devuelto

El valor máximo de los elementos de la valarray de operando.

Comentarios

La función miembro compara valores al aplicar operator< u operator> entre los pares de elementos de la clase Type para lo que se deben proporcionar operadores para el elemento Type.

Ejemplo

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

Busca el elemento más pequeño en una valarray.

Type min() const;

Valor devuelto

El valor mínimo de los elementos de la valarray de operando.

Comentarios

La función miembro compara valores al aplicar operator< u operator> entre los pares de elementos de la clase Type para lo que se deben proporcionar operadores para el elemento Type.

Ejemplo

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

Un operador unario que obtiene los valores NOT (!) lógicos de cada elemento de una valarray.

valarray<bool> operator!() const;

Valor devuelto

La valarray de valores booleanos que son la negación de los valores de elemento de la valarray de operando.

Comentarios

La operación lógica NOT, indicada por !, niega lógicamente los elementos porque convierte todos los valores cero en true y todos los valores distintos de cero en false. La valarray devuelta de valores booleanos es del mismo tamaño que la valarray de operando.

Ejemplo

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

Obtiene el resto de la división de los elementos de una matriz uno a uno por una valarray especificada o por un valor del tipo de elemento.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a dividir, por elemento, por la valarray de operando.

Valor devuelto

Una valarray cuyos elementos son el resto de la división por elemento de la valarray de operando por right.

Ejemplo

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

Obtiene el valor AND (&) bit a bit de los elementos de una matriz con los elementos correspondientes de una valarray especificada o con un valor del tipo de elemento.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a combinar, por elemento, mediante el valor AND (&) bit a bit con la valarray de operando.

Valor devuelto

valarray cuyos elementos son el valor AND (&) bit a bit de la valarray de operando por right

Comentarios

Una operación bit a bit solo se puede usar para manipular bits en tipos de datos enteros, como char y int. No funciona en float, double, long double, void, bool o en otros tipos de datos más complejos.

El valor AND (&) bit a bit se aplica al tipo de datos en el nivel de los bits individuales. Dados los bits b1 y b2, b1 & b2 es 1 si ambos bits son 1; 0 si al menos un bit es 0.

Ejemplo

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

Desplaza hacia la derecha los bits de cada elemento de un operando valarray un número especificado de posiciones o una cantidad de elementos especificada por una segunda valarray.

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

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

Parámetros

right
El valor que indica la cantidad de desplazamiento a la derecha o la valarray cuyos elementos indican la cantidad de desplazamiento a la derecha por elemento.

Valor devuelto

Una valarray cuyos elementos se han desplazado a la derecha la cantidad especificada en right.

Comentarios

Los números con signo conservan sus signos.

Ejemplo

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

Desplaza hacia la izquierda los bits de cada elemento de un operando valarray un número especificado de posiciones o una cantidad de elementos especificada por una segunda valarray.

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

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

Parámetros

right
El valor que indica la cantidad de desplazamiento a la izquierda o la valarray cuyos elementos indican la cantidad de desplazamiento a la izquierda por elemento.

Valor devuelto

Una valarray cuyos elementos se han desplazado a la izquierda la cantidad especificada en right.

Comentarios

Los números con signo conservan sus signos.

Ejemplo

// 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 los elementos de una valarray especificada o un valor del tipo de elemento, uno a uno, por un operando valarray.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a multiplicar, por elemento, por la valarray de operando.

Valor devuelto

Una valarray cuyos elementos son el producto por elemento de los operandos valarray y right.

Ejemplo

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

Operador unario que aplica un signo más a cada elemento de una valarray. Para los valores aritméticos normales, esta operación no tiene ningún efecto.

valarray<Type> operator+() const;

Valor devuelto

Un valarray cuyos elementos son el valor unario más el resultado de la matriz de operandos.

Ejemplo

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

Suma los elementos de una valarray especificada o un valor del tipo de elemento, uno a uno, a un operando valarray.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a agregar, por elemento, a la valarray de operando.

Valor devuelto

Una valarray cuyos elementos son la suma por elemento de los operandos valarray y right.

Ejemplo

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

Operador unario que aplica una negación aritmética a cada elemento de una valarray.

valarray<Type> operator-() const;

Valor devuelto

Una valarray cuyos elementos se niegan aritméticamente por parte de los elementos de la valarray de operando.

Ejemplo

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

Resta los elementos de una valarray especificada o un valor del tipo de elemento, uno a uno, de un operando valarray.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a sustraer, por elemento, a la valarray de operando.

Valor devuelto

Una valarray cuyos elementos son la diferencia por elemento de la valarray de operando y right.

Ejemplo

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

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

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

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

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

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

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

`operator/=`

Divide un operando valarray elemento a elemento por los elementos de una valarray especificada o un valor del tipo de elemento.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a dividir, por elemento, por la valarray de operando.

Valor devuelto

Una valarray cuyos elementos son el cociente por elemento de la valarray de operando dividida por right.

Ejemplo

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

Asigna los elementos a una valarray cuyos valores se especifican directamente o como parte de otra valarray o mediante una slice_array, gslice_array, mask_array o indirect_array.

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

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

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

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

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

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

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

Parámetros

right
valarray que se va a copiar en la valarray de operando.

val
El valor que se va a asignar a los elementos de la valarray de operando.

slicearray
slice_array que se va a copiar en la valarray de operando.

gslicearray
gslice_array que se va a copiar en la valarray de operando.

maskarray
mask_array que se va a copiar en la valarray de operando.

indarray
indirect_array que se va a copiar en la valarray de operando.

Valor devuelto

El primer operador miembro reemplaza la secuencia controlada por una copia de la secuencia controlada mediante right.

El segundo operador miembro es igual que el primero, pero con un Declarador de referencia a un valor R: &&.

El tercer operador miembro reemplaza cada elemento de la secuencia controlada por una copia de val.

Los operadores miembro restantes reemplazan los elementos de la secuencia controlada seleccionados por sus argumentos, que se generan únicamente por operator[].

Si el valor de un miembro en la secuencia controlada de reemplazo depende de un miembro de la secuencia controlada inicial, el resultado es indefinido.

Comentarios

Si cambia la longitud de la secuencia controlada, el resultado suele ser indefinido. Pero en esta implementación, el efecto es simplemente invalidar los punteros o referencias a los elementos de la secuencia controlada.

Ejemplo

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

Devuelve una referencia a un elemento o su valor en el índice especificado o un 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
El índice del elemento al que se va a asignar un valor.

slicearray
Una slice_array de una valarray que especifica un subconjunto que se va a seleccionar o devolver a una nueva valarray.

gslicearray
Una gslice_array de una valarray que especifica un subconjunto que se va a seleccionar o devolver a una nueva valarray.

boolarray
Una bool_array de una valarray que especifica un subconjunto que se va a seleccionar o devolver a una nueva valarray.

indarray
Una indirect_array de una valarray que especifica un subconjunto que se va a seleccionar o devolver a una nueva valarray.

Valor devuelto

Una referencia a un elemento o su valor en el índice especificado o un subconjunto especificado.

Comentarios

El operador miembro se sobrecarga para proporcionar varias formas de seleccionar secuencias de elementos entre los controlados por *this. El primer grupo de cinco operadores miembro funcionan junto con varias sobrecargas de operator= (y otros operadores de asignación) para permitir el reemplazo selectivo (segmentación) de la secuencia controlada. Los elementos seleccionados deben existir.

Al compilar con _ITERATOR_DEBUG_LEVEL definido como 1 o 2, se produce un error de tiempo de ejecución si intenta tener acceso a un elemento fuera de los límites valarray. Para obtener más información, consulte Checked Iterators.

Ejemplo

Vea los ejemplos de slice::slice y gslice::gslice para obtener un ejemplo de cómo declarar y usar operator[].

`operator^=`

Obtiene el valor exclusivo bit a bit or (^) de una valarray con una valarray especificada o un valor del tipo de elemento.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a combinar mediante el operador or (XOR) exclusivo bit a bit (^) con la valarray de operando.

Valor devuelto

valarray cuyos elementos son el valor or (XOR) exclusivo bit a bit de la valarray y right.

Comentarios

El valor or exclusivo bit a bit, denominado XOR e indicado por el operador ^, tiene la siguiente semántica: dados los bits b1 y b2, b1 ^ b2 es 1 si exactamente uno de los elementos es 1 y 0 si ambos elementos son 0 o 1.

Ejemplo

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

Obtiene el valor OR (|) bit a bit de los elementos de una matriz con los elementos correspondientes de una valarray especificada o con un valor del tipo de elemento.

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

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

Parámetros

right
La valarray o el valor de un tipo de elemento idéntico al de la valarray de operando que se va a combinar, por elemento, mediante el valor OR (|) bit a bit con la valarray de operando.

Valor devuelto

Una valarray cuyos elementos son los valores OR (|) bit a bit y elemento a elemento de la valarray de operando por right.

Comentarios

El valor OR (|) bit a bit se aplica al tipo de datos en el nivel de los bits individuales. Dados los bits b1 y b2, b1 | b2 es 1 si al menos uno de los bits es 1; 0 si ambos bits son 0.

Ejemplo

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

Operador unario que obtiene el complemento bit a bit de cada elemento de una valarray.

valarray<Type> operator~() const;

Valor devuelto

La valarray de valores que son el complemento unario bit a bit de los valores de elemento de la valarray de operando.

Comentarios

Una operación bit a bit solo puede manipular bits en tipos de datos enteros, como char y int. No funciona en float, double, long double, void, bool o en otros tipos de datos más complejos.

El operador de complemento unario bit a bit ~ se aplica al tipo de datos en el nivel de los bits individuales. Dado el bit b, ~b es 1 si b es 0 y 0 si b es 1.

Ejemplo

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

Cambia el número de elementos de una valarray a un número especificado.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Parámetros

new_size
Número de elementos de la valarray cuyo tamaño se cambió.

val
Valor que se asignará a los elementos de la valarray cuyo tamaño se cambió.

Comentarios

La primera función miembro inicializa los elementos con su constructor predeterminado.

Se invalidan los punteros o referencias a elementos de la secuencia controlada.

Ejemplo

En el ejemplo siguiente se muestra el uso de la función miembro 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`

Desplaza todos los elementos de una valarray un número especificado de posiciones.

valarray<Type> shift(int count) const;

Parámetros

count
El número de posiciones que se van a desplazar hacia adelante los elementos.

Valor devuelto

Una nueva valarray en la que todos los elementos se han movido count posiciones hacia la parte delantera de la valarray, a la izquierda en comparación con sus posiciones en la valarray de operando.

Comentarios

Un valor positivo de count desplaza los elementos a la izquierda count posiciones, con relleno cero.

Un valor positivo de count desplaza los elementos a la derecha count posiciones, con relleno cero.

Ejemplo

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

Busca el número de elementos de una valarray.

size_t size() const;

Valor devuelto

Número de elementos de la valarray de operando.

Ejemplo

En el ejemplo siguiente se muestra el uso de la función miembro 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 la suma de todos los elementos de una valarray de longitud distinta de cero.

Type sum() const;

Valor devuelto

La suma de los elementos de la valarray de operando.

Comentarios

Si la longitud es mayor que uno, la función miembro agrega valores a la suma aplicando operator+= entre los pares de elementos de la clase Type. Significa que se debe proporcionar el operador para los elementos de tipo Type.

Ejemplo

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

Intercambia los elementos de dos objetos valarray.

void swap(valarray& right);

Parámetros

right
valarray que proporciona los elementos que se van a intercambiar.

Comentarios

La función miembro intercambia las secuencias controladas entre *this y right. Lo hace en tiempo constante, no inicia ninguna excepción y no invalida ninguna referencia, puntero o iterador a elementos en las dos secuencias controladas.

`valarray`

Construye una valarray de un tamaño específico o con elementos de un valor determinado, o como una copia de otra valarray o un subconjunto de otra 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
Número de elementos que estarán en la valarray.

val
Valor que se utilizará al inicializar los elementos de la valarray.

ptr
Puntero a los valores que se usarán para inicializar los elementos de la valarray.

right
valarray existente para inicializar la nueva valarray.

sliceArray
slice_array cuyos valores de elemento se van a utilizar al inicializar los elementos de la valarray que se va a construir.

gsliceArray
gslice_array cuyos valores de elemento se van a utilizar al inicializar los elementos de la valarray que se va a construir.

maskArray
mask_array cuyos valores de elemento se van a utilizar al inicializar los elementos de la valarray que se va a construir.

indArray
indirect_array cuyos valores de elemento se van a utilizar al inicializar los elementos de la valarray que se va a construir.

iList
initializer_list que contiene los elementos que se van a copiar.

Comentarios

El primer constructor (predeterminado) inicializa el objeto en una valarray vacía. Cada uno de los tres constructores siguientes inicializan el objeto en una count de elementos valarray de la manera siguiente:

En el caso de valarray(size_t count) explícito, cada elemento se inicializa con el constructor predeterminado.
En valarray(const Type& val, count), cada elemento se inicializa con val.
En valarray(const Type* ptr, count), el elemento situado en la posición I se inicializa con ptr[I].

Cada constructor restante inicializa el objeto en un objeto valarray<Type> determinado por el subconjunto especificado en el argumento.

El último constructor es igual que el penúltimo, pero con un Declarador de referencia a un valor R: &&.

Ejemplo

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

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

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

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

    slice Slice(2, 4, 3);

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

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

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

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

`value_type`

Tipo que representa el tipo de elemento almacenado en una valarray.

typedef Type value_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Type.

Ejemplo

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

Vea también

Seguridad de subprocesos en la biblioteca estándar de C++

Compartir vía

Clase valarray

Comentarios

Miembros

Constructores

Typedefs

Funciones

Operadores

apply

Parámetros

Valor devuelto

Comentarios

Ejemplo

cshift

Parámetros

Valor devuelto

Comentarios

Ejemplo

free

Comentarios

max

Valor devuelto

Comentarios

Ejemplo

min

Valor devuelto

Comentarios

Ejemplo

operator!

Valor devuelto

Comentarios

Ejemplo

operator%=

Parámetros

Valor devuelto

Ejemplo

operator&=

Parámetros

Valor devuelto

Comentarios

Ejemplo

operator>>=

Parámetros

Valor devuelto

Comentarios

Ejemplo

operator<<=

Parámetros

Valor devuelto

Comentarios

Ejemplo

operator*=

Parámetros

Valor devuelto

Ejemplo

operator+

Valor devuelto

Ejemplo

operator+=

Parámetros

Valor devuelto

Ejemplo

operator-

Valor devuelto

Ejemplo

operator-=

Parámetros

Valor devuelto

Ejemplo

operator/=

Parámetros

Valor devuelto

Ejemplo

operator=

Parámetros

Valor devuelto

Comentarios

Ejemplo

operator[]

Parámetros

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