Klasa `valarray`

Artykuł
10/12/2023

Szablon klasy valarray<Type> opisuje obiekt, który kontroluje sekwencję elementów typu Type , które są przechowywane jako tablica, zaprojektowane pod kątem szybkich operacji matematycznych i zoptymalizowane pod kątem wydajności obliczeniowej.

Uwagi

Klasa jest reprezentacją matematycznej koncepcji uporządkowanego zestawu wartości. Jego elementy są numerowane sekwencyjnie od zera. Klasa jest opisana jako blisko kontenera , ponieważ obsługuje niektóre, ale nie wszystkie funkcje, które kontenery sekwencji pierwszej klasy, takie jak vector, obsługują. Różni się on od szablonu vector klasy na dwa ważne sposoby:

Definiuje wiele operacji arytmetycznych między odpowiednimi elementami valarray<Type> obiektów tego samego typu i długości, takimi jak varr_x* = cos(varr_y) + sin(varr_z).
Definiuje on różne interesujące sposoby podskrypcji valarray<Type> obiektu przez przeciążenie elementu operator[].

Obiekt klasy Type:

Ma publiczny konstruktor domyślny, destruktor, konstruktor kopiowania i operator przypisania z konwencjonalnym zachowaniem.
Definiuje operatory arytmetyczne i funkcje matematyczne zdefiniowane zgodnie z potrzebami dla typów zmiennoprzecinkowych z konwencjonalnym zachowaniem.

W szczególności nie mogą istnieć subtelne różnice między konstrukcją kopii a domyślną konstrukcją, po której następuje przypisanie. Żadne operacje na obiektach klasy Type nie mogą zgłaszać wyjątków.

Członkowie

Konstruktory

Nazwa/nazwisko	opis
`valarray`	`valarray` Tworzy określony rozmiar lub elementy określonej wartości lub jako kopię innego `valarray` lub podzestawu innego `valarray`.

Typedefs

Nazwa/nazwisko	opis
`value_type`	Typ reprezentujący typ elementu przechowywanego w obiekcie `valarray`.

Funkcje

Nazwa/nazwisko	opis
`apply`	Stosuje określoną funkcję do każdego elementu elementu `valarray`.
`cshift`	Cyklicznie przesuwa wszystkie elementy w obiekcie `valarray` o określoną liczbę pozycji.
`free`	Zwalnia pamięć używaną przez element `valarray`.
`max`	Znajduje największy element w obiekcie `valarray`.
`min`	Znajduje najmniejszy element w obiekcie `valarray`.
`resize`	Zmienia liczbę elementów w `valarray` liczbie na określoną liczbę, dodając lub usuwając elementy zgodnie z potrzebami.
`shift`	Przesuwa wszystkie elementy w obiekcie `valarray` o określoną liczbę pozycji.
`size`	Znajduje liczbę elementów w obiekcie `valarray`.
`sum`	Określa sumę wszystkich elementów o `valarray` długości niezerowej.
`swap`

Operatory

Nazwa/nazwisko	opis
`operator!`	Operator jednoargumentowy, który uzyskuje logiczne wartości NOT (`!`) każdego elementu w obiekcie `valarray`.
`operator%=`	Uzyskuje pozostałą część dzielenia elementów tablicy według określonej `valarray` lub przez wartość typu elementu.
`operator&=`	Uzyskuje bitowe AND (`&`) elementów w tablicy z odpowiednimi elementami w określonym `valarray` lub z wartością typu elementu.
`operator>>=`	Przesuwa bity w prawo dla każdego elementu `valarray` operandu określoną liczbę pozycji lub przez liczbę elementów mądry określoną przez sekundę `valarray`.
`operator<<=`	Przesuwa bity w lewo dla każdego elementu `valarray` operandu określoną liczbę pozycji lub przez liczbę elementów mądry określoną przez sekundę `valarray`.
`operator*=`	Mnoży elementy określonego `valarray` elementu lub wartość typu elementu, element-wise, do operandu `valarray`.
`operator+`	Operator jednoargumentowy, który stosuje znak plus do każdego elementu w obiekcie `valarray`. W normalnych typach arytmetycznych ten operator nie ma wpływu.
`operator+=`	Dodaje elementy określonego `valarray` elementu lub wartość typu elementu, element-wise, do operandu `valarray`.
`operator-`	Operator jednoargumentowy, który stosuje negację arytmetyczną do każdego elementu w obiekcie `valarray`.
`operator-=`	Odejmuje elementy określonego `valarray` elementu lub wartość typu elementu, element-wise, z operandu `valarray`.
`operator/=`	Dzieli element operand `valarray` mądry przez elementy określonego `valarray` lub wartości typu elementu.
`operator=`	Przypisuje elementy do obiektu `valarray` , którego wartości są określane bezpośrednio lub w ramach innych `valarray` lub przez `slice_array`element , `gslice_array`, `mask_array`lub `indirect_array`.
`operator[]`	Zwraca odwołanie do elementu lub jego wartości w określonym indeksie lub określonym podzestawie.
`operator^=`	Uzyskuje bitową wyłączność lub (`^`) `valarray` elementu z określoną `valarray` lub wartością typu elementu.
`operator\|=`	Uzyskuje bitowe OR (`\|`) elementów w tablicy z odpowiednimi elementami w określonym `valarray` lub z wartością typu elementu.
`operator~`	Operator jednoargumentowy, który uzyskuje wartości uzupełniania bitowego (`~`) każdego elementu w obiekcie `valarray`.

`apply`

Stosuje określoną funkcję do każdego elementu elementu valarray.

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

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

Parametry

function_object(Type)
Obiekt funkcji, który ma zostać zastosowany do każdego elementu operandu valarray.

function_object(const Type&)
Obiekt funkcji dla const elementów, które mają być stosowane do każdego elementu operandu valarray.

Wartość zwracana

Element valarray , którego elementy zastosowały function_object element mądry do elementów operandu valarray.

Uwagi

Funkcja składowa zwraca obiekt klasy valarray<Type>, o długości size, każdy z których elementy elem są wynikiem function_object((*this)[elem]).

Przykład

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

Cyklicznie przesuwa wszystkie elementy w obiekcie valarray o określoną liczbę pozycji.

valarray<Type> cshift(int count) const;

Parametry

count
Liczba miejsc, w których elementy mają być przesunięte do przodu.

Wartość zwracana

Nowy valarray , w którym wszystkie elementy zostały przeniesione count pozycje cyklicznie w kierunku przodu , lub lewej valarrayw porównaniu do ich pozycji w operand valarray.

Uwagi

Dodatnia count wartość przesuwa cyklicznie lewe count miejsca elementów.

Ujemna wartość count zmienia cyklicznie prawe count miejsca elementów.

Przykład

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

Zwalnia pamięć używaną przez element valarray.

void free();

Uwagi

Ta niestandardowa funkcja jest równoważna przypisaniu pustego valarrayelementu . Przykład:

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

// equivalent to v.free()

`max`

Znajduje największy element w obiekcie valarray.

Type max() const;

Wartość zwracana

Maksymalna wartość elementów w operandzie valarray.

Uwagi

Funkcja składowa porównuje wartości, stosując operator lub operator>< między parami elementów klasy Type, dla których operatory muszą być podane dla elementu .Type

Przykład

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

Znajduje najmniejszy element w obiekcie valarray.

Type min() const;

Wartość zwracana

Minimalna wartość elementów w operand valarray.

Uwagi

Funkcja składowa porównuje wartości, stosując operator lub operator>< między parami elementów klasy Type, dla których operatory muszą być podane dla elementu .Type

Przykład

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

Operator jednoargumentowy, który uzyskuje logiczne wartości NOT (!) każdego elementu w obiekcie valarray.

valarray<bool> operator!() const;

Wartość zwracana

Wartości valarray logiczne, które są logicznym negacją wartości elementów operandu valarray.

Uwagi

Operacja logiczna NOT, oznaczona przez !, logicznie neguje elementy, ponieważ konwertuje wszystkie wartości zerowe na true i wszystkie wartości inne niż zero na false. Zwracane valarray wartości logiczne mają taki sam rozmiar jak operand valarray.

Przykład

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

Uzyskuje pozostałą część dzielenia elementów tablicy według określonej valarray lub przez wartość typu elementu.

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

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

Parametry

right
Wartość valarray lub typu elementu identyczna z argumentem operandu valarray , który ma być podzielony, mądry element, operand valarray.

Wartość zwracana

A valarray , których elementy są resztą z podziałów elementów operandu valarray przez right.

Przykład

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

Uzyskuje bitowe AND (&) elementów w tablicy z odpowiednimi elementami w określonym valarray lub z wartością typu elementu.

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

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

Parametry

right
Wartość valarray lub typu elementu identycznego z argumentem operandu valarray , który ma być połączony, element-mądry, przez bitowe AND (&) z operandem valarray.

Wartość zwracana

Element valarray , którego elementy są bitowe AND (&) operandu valarray przez right

Uwagi

Operację bitową można używać tylko do manipulowania bitami w całkowitych typach danych, takich jak char i int. Nie działa w przypadku floatbardziej złożonych typów danych , , voiddoublelong double, , boollub innych.

Bitowe AND (&) ma zastosowanie do typu danych na poziomie poszczególnych bitów. Podane bity b1 i b2, b1 & b2 jest 1, jeśli oba bity mają wartość 1; 0, jeśli co najmniej jeden bit to 0.

Przykład

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

Przesuwa bity w prawo dla każdego elementu valarray operandu określoną liczbę pozycji lub przez liczbę elementów mądry określoną przez sekundę valarray.

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

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

Parametry

right
Wartość wskazująca ilość przesunięcia w prawo lub valarray , których elementy wskazują mądry poziom przesunięcia w prawo.

Wartość zwracana

Elementvalarray, którego elementy zostały przesunięte w prawo, kwota określona w .right

Uwagi

Podpisane numery mają swoje znaki zachowane.

Przykład

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

Przesuwa bity w lewo dla każdego elementu valarray operandu określoną liczbę pozycji lub przez liczbę elementów mądry określoną przez sekundę valarray.

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

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

Parametry

right
Wartość wskazująca ilość przesunięcia w lewo lub valarray których elementy wskazują mądry element przesunięcia w lewo.

Wartość zwracana

Element valarray , którego elementy zostały przesunięte, pozostawiono kwotę określoną w elem right.

Uwagi

Podpisane numery mają swoje znaki zachowane.

Przykład

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

Mnoży elementy określonego valarray elementu lub wartość typu elementu, element-wise, do operandu valarray.

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

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

Parametry

right
Wartość valarray lub typu elementu identycznego z argumentem operandu valarray , który ma być mnożący, mądry element, operand valarray.

Wartość zwracana

Element valarray , którego elementy są elementami mądry produkt operandu valarray i right.

Przykład

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

Operator jednoargumentowy, który stosuje znak plus do każdego elementu w obiekcie valarray. W przypadku normalnych wartości arytmetycznych ta operacja nie ma efektu.

valarray<Type> operator+() const;

Wartość zwracana

Element valarray , którego elementy są jednoargumentowym plus wynikiem tablicy operandu.

Przykład

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

Dodaje elementy określonego valarray elementu lub wartość typu elementu, element-wise, do operandu valarray.

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

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

Parametry

right
Wartość valarray lub typu elementu identycznego z argumentem operandu valarray , który ma zostać dodany, element mądry, do operandu valarray.

Wartość zwracana

Element valarray , którego elementy są mądrą sumą operandu valarray i right.

Przykład

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

Operator jednoargumentowy, który stosuje negację arytmetyczną do każdego elementu w obiekcie valarray.

valarray<Type> operator-() const;

Wartość zwracana

A valarray którego elementy są arytmetycznie negowane z elementów operandu valarray.

Przykład

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

Odejmuje elementy określonego valarray elementu lub wartość typu elementu, element-wise, z operandu valarray.

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

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

Parametry

right
Wartość valarray lub typu elementu identycznego z argumentem operandu valarray , który ma być odejmowany, element-mądry, z operandu valarray.

Wartość zwracana

Element, valarray którego elementy są mądrą różnicą operandu valarray i right.

Przykład

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

Dzieli element operand valarray mądry przez elementy określonego valarray lub wartości typu elementu.

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

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

Parametry

right
Wartość valarray lub typu elementu identycznego z argumentem operandu valarray , który ma być podzielony, element-mądry, na operand valarray.

Wartość zwracana

A valarray , których elementy są elementami mądry iloraz operandu valarray podzielonego przez right.

Przykład

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

Przypisuje elementy do obiektu valarray , którego wartości są określane bezpośrednio lub w ramach innych valarray lub przez slice_arrayelement , gslice_array, mask_arraylub 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);

Parametry

right
Element valarray do skopiowania do operandu valarray.

val
Wartość, która ma zostać przypisana do elementów operandu valarray.

slicearray
Element slice_array do skopiowania do operandu valarray.

gslicearray
Element gslice_array do skopiowania do operandu valarray.

maskarray
Element mask_array do skopiowania do operandu valarray.

indarray
Element indirect_array do skopiowania do operandu valarray.

Wartość zwracana

Pierwszy operator elementu członkowskiego zastępuje kontrolowaną sekwencję kopią sekwencji kontrolowanej przez rightelement .

Drugi operator elementu członkowskiego jest taki sam jak pierwszy, ale z deklaratorem odwołania Rvalue: &&.

Trzeci operator elementu członkowskiego zastępuje każdy element kontrolowanej sekwencji kopią wartości.

Pozostałe operatory składowe zastępują te elementy kontrolowanej sekwencji wybranej przez ich argumenty, które są generowane tylko przez operator[]element .

Jeśli wartość elementu członkowskiego w kontrolowanej sekwencji zastępczej zależy od elementu członkowskiego w początkowej kontrolowanej sekwencji, wynik jest niezdefiniowany.

Uwagi

Jeśli długość kontrolowanej sekwencji zmienia się, zwykle wynik jest niezdefiniowany. Jednak w tej implementacji efekt polega jedynie na unieważnieniu wszelkich wskaźników lub odwołań do elementów w kontrolowanej sekwencji.

Przykład

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

Zwraca odwołanie do elementu lub jego wartości w określonym indeksie lub określonym podzestawie.

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;

Parametry

index
Indeks elementu, który ma zostać przypisany do wartości.

slicearray
valarray Elementslice_array, który określa podzbiór do wybrania lub zwrócony do nowego valarrayelementu .

gslicearray
valarray Elementgslice_array, który określa podzbiór do wybrania lub zwrócony do nowego valarrayelementu .

boolarray
valarray Elementbool_array, który określa podzbiór do wybrania lub zwrócony do nowego valarrayelementu .

indarray
valarray Element indirect_array określający podzbiór do wybrania lub zwrócony do nowego valarrayelementu .

Wartość zwracana

Odwołanie do elementu lub jego wartości w określonym indeksie lub określonym podzestawie.

Uwagi

Operator elementu członkowskiego jest przeciążony, aby zapewnić kilka sposobów wybierania sekwencji elementów spośród tych kontrolowanych przez *this. Pierwsza grupa pięciu operatorów składowych współpracuje z różnymi przeciążeniami (i innymi operatorami operator= przypisywania), aby umożliwić selektywne zastępowanie (fragmentowanie) kontrolowanej sekwencji. Wybrane elementy muszą istnieć.

W przypadku kompilacji przy użyciu _ITERATOR_DEBUG_LEVEL zdefiniowanej jako 1 lub 2 błąd środowiska uruchomieniowego występuje, jeśli próbujesz uzyskać dostęp do elementu poza granicami valarray. Aby uzyskać więcej informacji, zobacz Sprawdzono iteratory.

Przykład

Zapoznaj się z przykładami i slice::slicegslice::gslice przykładami sposobu deklarowania i używania elementu operator[].

`operator^=`

Uzyskuje bitową wyłączność lub (^) valarray elementu z określoną valarray lub wartością typu elementu.

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

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

Parametry

right
Wartość valarray lub typu elementu identycznego z argumentem operandu valarray , który ma być połączony przez operator bitowy wyłączny lub (XOR) (^) z operandem valarray.

Wartość zwracana

Element valarray , którego elementy są bitowo wykluczające lub (XOR) operandu valarray i right.

Uwagi

Bitowe wyłączne lub, określane jako XOR i oznaczone przez operator ^, ma następujące semantyki: Podane bity b1 i b2, b1 ^ b2 jest 1, jeśli dokładnie jeden z elementów wynosi 1, i 0, jeśli oba elementy są 0 lub 1.

Przykład

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

Uzyskuje bitowe OR (|) elementów w tablicy z odpowiednimi elementami w określonym valarray lub z wartością typu elementu.

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

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

Parametry

right
Wartość valarray lub typu elementu identycznego z argumentem operandu valarray , który ma być połączony, element-mądry, przez bitowy OR (|) z operandem valarray.

Wartość zwracana

Element valarray , którego elementy są elementami bitowe OR (|) operandu valarray przez right.

Uwagi

Bitowe OR (|) dotyczy typu danych na poziomie poszczególnych bitów. Podane bity b1 i b2, b1 | b2 jest 1, jeśli co najmniej jeden z bitów wynosi 1; 0, jeśli oba bity mają wartość 0.

Przykład

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

Operator jednoargumentowy, który uzyskuje bitowe uzupełnienie wartości każdego elementu w obiekcie valarray.

valarray<Type> operator~() const;

Wartość zwracana

Wartości valarray , które są jednoargumentowym uzupełnieniem bitowych wartości elementów operandu valarray.

Uwagi

Operacja bitowa może manipulować tylko bitami w typach całkowitych, takich jak char i int. Nie działa w przypadku floatbardziej złożonych typów danych , , voiddoublelong double, , boollub innych.

Jednoargumentowy operator ~ uzupełniania bitowego ma zastosowanie do typu danych na poziomie poszczególnych bitów. Podana wartość bitowa bwynosi 1, ~b jeśli b ma wartość 0 i 0, jeśli b ma wartość 1.

Przykład

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

Zmienia liczbę elementów w valarray liczbie na określoną liczbę.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Parametry

new_size
Liczba elementów w zmienionym valarrayrozmiarze .

val
Wartość, która ma zostać nadana elementom o zmienionym valarrayrozmiarze .

Uwagi

Pierwsza funkcja składowa inicjuje elementy za pomocą ich konstruktora domyślnego.

Wszelkie wskaźniki lub odwołania do elementów w kontrolowanej sekwencji są unieważniane.

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej 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`

Przesuwa wszystkie elementy w obiekcie valarray o określoną liczbę miejsc.

valarray<Type> shift(int count) const;

Parametry

count
Liczba miejsc, w których elementy mają być przesunięte do przodu.

Wartość zwracana

Nowy valarray element, w którym wszystkie elementy zostały przeniesione count pozycje w kierunku przodu valarray, lub lewej, w porównaniu do ich pozycji w operand valarray.

Uwagi

Dodatnia count wartość przesunięcia elementów w pozostałych count miejscach z zerowym wypełnieniem.

Ujemna count wartość przesunięcia elementów w odpowiednich count miejscach z zerowym wypełnieniem.

Przykład

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

Znajduje liczbę elementów w obiekcie valarray.

size_t size() const;

Wartość zwracana

Liczba elementów w operandzie valarray.

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej 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`

Określa sumę wszystkich elementów o valarray długości niezerowej.

Type sum() const;

Wartość zwracana

Suma elementów operandu valarray.

Uwagi

Jeśli długość jest większa niż jedna, funkcja składowa dodaje wartości do sumy, stosując operator+= między parami elementów klasy Type. Oznacza to, że operator musi być dostarczony dla elementów typu Type.

Przykład

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

Wymienia elementy dwóch valarray obiektów.

void swap(valarray& right);

Parametry

right
Element valarray dostarczający elementy do zamiany.

Uwagi

Funkcja składowa zamienia kontrolowane sekwencje między *this i right. Robi to w stałym czasie, nie zgłasza żadnych wyjątków i unieważnia żadnych odwołań, wskaźników lub iteratorów do elementów w dwóch kontrolowanych sekwencjach.

`valarray`

valarray Tworzy określony rozmiar lub elementy określonej wartości lub jako kopię innego valarray lub podzestawu innego 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);

Parametry

count
Liczba elementów, które mają być w elemecie valarray.

val
Wartość, która ma być używana podczas inicjowania elementów w obiekcie valarray.

ptr
Wskaźnik do wartości, które mają być używane do inicjowania elementów w obiekcie valarray.

right
valarray Istniejący do zainicjowania nowego valarrayelementu .

sliceArray
Element slice_array , którego wartości elementów mają być używane podczas inicjowania elementów valarray konstruowanych.

gsliceArray
Element gslice_array , którego wartości elementów mają być używane podczas inicjowania elementów valarray konstruowanych.

maskArray
Element mask_array , którego wartości elementów mają być używane podczas inicjowania elementów valarray konstruowanych.

indArray
Element indirect_array , którego wartości elementów mają być używane podczas inicjowania elementów valarray konstruowanych.

iList
Element initializer_list zawierający elementy do skopiowania.

Uwagi

Pierwszy (domyślny) konstruktor inicjuje obiekt do pustego valarrayobiektu . Następne trzy konstruktory inicjują obiekt do elementu valarraycount w następujący sposób:

Dla jawnego valarray(size_t count), każdy element jest inicjowany przy użyciu konstruktora domyślnego.
Dla valarray(const Type& val, count)elementu każdy element jest inicjowany za pomocą valpolecenia .
W przypadku valarray(const Type* ptr, count)elementu na pozycji I element jest inicjowany za pomocą ptr[I]polecenia .

Każdy pozostały konstruktor inicjuje valarray<Type> obiekt do obiektu określonego w podzestawie określonym w argumencie.

Ostatni konstruktor jest taki sam jak obok ostatniego, ale z deklaratorem odwołania Rvalue: &&.

Przykład

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

Typ reprezentujący typ elementu przechowywanego w obiekcie valarray.

typedef Type value_type;

Uwagi

Typ jest synonimem parametru Typeszablonu .

Przykład

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

Zobacz też

Bezpieczeństwo wątków w standardowej bibliotece języka C++

Udostępnij przez

Klasa valarray

Uwagi

Członkowie

Konstruktory

Typedefs

Funkcje

Operatory

apply

Parametry

Wartość zwracana

Uwagi

Przykład

cshift

Parametry

Wartość zwracana

Uwagi

Przykład

free

Uwagi

max

Wartość zwracana

Uwagi

Przykład

min

Wartość zwracana

Uwagi

Przykład

operator!

Wartość zwracana

Uwagi

Przykład

operator%=

Parametry

Wartość zwracana

Przykład

operator&=

Parametry

Wartość zwracana

Uwagi

Przykład

operator>>=

Parametry

Wartość zwracana

Uwagi

Przykład

operator<<=

Parametry

Wartość zwracana

Uwagi

Przykład

operator*=

Parametry

Wartość zwracana

Przykład

operator+

Wartość zwracana

Przykład

operator+=

Parametry

Wartość zwracana

Przykład

operator-

Wartość zwracana

Przykład

operator-=

Parametry

Wartość zwracana

Przykład

operator/=

Parametry

Wartość zwracana

Przykład

operator=

Parametry

Wartość zwracana

Uwagi

Przykład

operator[]

Parametry

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