Sdílet prostřednictvím

Třída valarray

Šablona valarray<Type> třídy popisuje objekt, který řídí posloupnost prvků typu Type , které jsou uloženy jako pole, navržené pro vysokorychlostní matematické operace a optimalizované pro výpočetní výkon.

Poznámky

Třída představuje matematický koncept seřazené sady hodnot. Jeho prvky jsou očíslovány postupně od nuly. Třída je popsaná jako blízko kontejner, protože podporuje některé, ale ne všechny možnosti, které kontejnery sekvence první třídy, například vector, podporují. Liší se od šablony vector třídy dvěma důležitými způsoby:

  • Definuje mnoho aritmetických operací mezi odpovídajícími valarray<Type> prvky objektů stejného typu a délkou, například varr_x* = cos(varr_y) + sin(varr_z).

  • Definuje různé zajímavé způsoby, jak dolní index valarray<Type> objekt přetížit operator[].

Objekt třídy Type:

  • Má veřejný výchozí konstruktor, destruktor, konstruktor kopírování a operátor přiřazení s konvenčním chováním.

  • Definuje aritmetické operátory a matematické funkce podle potřeby definované pro typy s plovoucí desetinou čárkou s konvenčním chováním.

Konkrétně neexistují žádné drobné rozdíly mezi kopírovací konstrukcí a výchozí konstrukcí následovanou přiřazením. Žádná operace s objekty třídy Type nemůže vyvolat výjimky.

Členové

Konstruktory

Název Popis
valarray valarray Vytvoří určitou velikost nebo s prvky určité hodnoty nebo jako kopii jiné valarray nebo podmnožinu jiného valarray.

Typedefs

Název Popis
value_type Typ, který představuje typ prvku uloženého v objektu valarray.

Funkce

Název Popis
apply Použije zadanou funkci na každý prvek objektu valarray.
cshift Cyklicky se posune všechny prvky v sadě o valarray zadaný počet pozic.
free Uvolní paměť, kterou valarraypoužívá .
max Najde největší prvek v objektu valarray.
min Najde nejmenší prvek v objektu valarray.
resize Změní počet prvků v zadaném valarray čísle a podle potřeby přidá nebo odebere prvky.
shift Posune všechny prvky v zadaném valarray počtu pozic.
size Najde počet prvků v prvku valarray.
sum Určuje součet všech prvků v valarray nenulové délce.
swap

Operátory

Název Popis
operator! Unární operátor, který získá logické HODNOTY NOT (!) každého prvku v objektu valarray.
operator%= Získá zbytek dělení prvků prvku pole moudrý buď zadaným valarray , nebo hodnotou typu prvku.
operator&= Získá bitové AND (&) prvků v matici buď s odpovídajícími prvky v zadaném valarray nebo s hodnotou typu prvku.
operator>>= Posune bity pro každý prvek valarray operandu zadaný počet pozic nebo o množství moudrého prvku určeného sekundou valarray.
operator<<= Levý posune bity pro každý prvek valarray operandu zadaný počet pozic nebo podle množství prvku určeného sekundou valarray.
operator*= Vynásobí prvky zadaného valarray nebo hodnoty typu prvku, element-moudrý, na operand valarray.
operator+ Unární operátor, který aplikuje plus na každý prvek v objektu valarray. U normálních aritmetických typů nemá tento operátor žádný vliv.
operator+= Přidá prvky zadaného valarray nebo hodnoty typu prvku, element-moudrý, do operandu valarray.
operator- Unární operátor, který aplikuje aritmetické negace na každý prvek v objektu valarray.
operator-= Odečte prvky zadaného valarray nebo hodnoty typu prvku, prvek-moudrý, od operandu valarray.
operator/= Vydělí prvek operandu valarray prvky zadaného valarray nebo hodnoty typu prvku.
operator= Přiřadí prvky k hodnotě valarray , jejíž hodnoty jsou zadány buď přímo, nebo jako součást některé valarray jiné, nebo pomocí slice_array, gslice_array, mask_arraynebo indirect_array.
operator[] Vrátí odkaz na prvek nebo jeho hodnotu v zadaném indexu nebo zadané podmnožině.
operator^= Získá bitové výhradní nebo (^) ze zadaného valarray valarray typu prvku nebo hodnotu typu prvku.
operator|= Získá bitové OR (|) prvků v matici buď s odpovídajícími prvky v zadaném valarray nebo s hodnotou typu prvku.
operator~ Unární operátor, který získá bitové doplňky (~) hodnoty každého prvku v objektu valarray.

apply

Použije zadanou funkci na každý prvek objektu valarray.

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

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

Parametry

function_object(Type)
Objekt funkce, který má být použit pro každý prvek operandu valarray.

function_object(const Type&)
Objekt funkce pro const prvky, které mají být použity pro každý prvek operandu valarray.

Vrácená hodnota

A valarray jehož prvky byly function_object použity element-moudrý na prvky operandu valarray.

Poznámky

Členová funkce vrátí objekt třídy valarray<Type>, o délce size, každý z jehož prvků elem je výsledkem function_object((*this)[elem]).

Příklad

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

Cyklicky se posune všechny prvky v sadě o valarray zadaný počet pozic.

valarray<Type> cshift(int count) const;

Parametry

count
Počet míst, kde mají být prvky posunuty dopředu.

Vrácená hodnota

Nové valarray , ve kterém byly všechny prvky posunuty count cyklicky směrem k přední straně valarray, nebo vlevo ve srovnání s jejich pozicemi v operandu valarray.

Poznámky

Kladná count hodnota posune prvky cyklicky doleva count .

Záporná count hodnota posune prvky cyklicky doprava count .

Příklad

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

Uvolní paměť, kterou valarraypoužívá .

void free();

Poznámky

Tato nestandardní funkce je ekvivalentní přiřazení prázdné valarrayfunkce . Příklad:

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

// equivalent to v.free()

max

Najde největší prvek v objektu valarray.

Type max() const;

Vrácená hodnota

Maximální hodnota prvků v operandu valarray.

Poznámky

Členová funkce porovnává hodnoty použitím operátoru< nebo operátoru> mezi dvojicemi prvků třídy Type, pro které musí být pro prvek Typeposkytnuty operátory .

Příklad

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

Najde nejmenší prvek v objektu valarray.

Type min() const;

Vrácená hodnota

Minimální hodnota prvků v operandu valarray.

Poznámky

Členová funkce porovnává hodnoty použitím operátoru< nebo operátoru> mezi dvojicemi prvků třídy Type, pro které musí být pro prvek Typeposkytnuty operátory .

Příklad

// 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ární operátor, který získá logické HODNOTY NOT (!) každého prvku v objektu valarray.

valarray<bool> operator!() const;

Vrácená hodnota

Logické valarray hodnoty, které jsou logickou negací hodnot prvků operandu valarray.

Poznámky

Logická operace NOT, označená !, logicky neguje prvky, protože převádí všechny nulové hodnoty na true a všechny nenulové hodnoty na false. Vrácené valarray logické hodnoty mají stejnou velikost jako operand valarray.

Příklad

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

Získá zbytek dělení prvků prvku pole moudrý buď zadaným valarray , nebo hodnotou typu prvku.

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

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

Parametry

right
Nebo valarray hodnota typu prvku, který je identický s operandem valarray , který má dělit, prvek-moudrý, operand valarray.

Vrácená hodnota

A valarray , jehož prvky jsou zbytek od prvku-moudré rozdělení operandu valarray podle right.

Příklad

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

Získá bitové AND (&) prvků v matici buď s odpovídajícími prvky v zadaném valarray nebo s hodnotou typu prvku.

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

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

Parametry

right
valarray Nebo hodnota typu prvku, který je identický s operandemvalarray, který má být kombinován, prvek moudrý, bitovou and (&) s operandem valarray.

Vrácená hodnota

A valarray jehož prvky jsou bitovým operátorem AND (&) operandu valarrayright

Poznámky

Bitovou operaci lze použít pouze k manipulaci s bity v integrálních datových typech, například char a int. Nefunguje na float, , double, long double, void, bool, nebo jiných, složitějších datových typech.

Bitový operátor AND (&) se vztahuje na datový typ na úrovni jednotlivých bitů. Dané bity b1 a b2, b1 & b2 je 1, pokud oba bity jsou 1; 0, pokud alespoň jeden bit je 0.

Příklad

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

Posune bity pro každý prvek valarray operandu zadaný počet pozic nebo o množství moudrého prvku určeného sekundou valarray.

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

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

Parametry

right
Hodnota označující množství pravého posunu nebo valarray jehož prvky označují množství pravého posunu.

Vrácená hodnota

A valarray jehož prvky byly posunuty doprava množství zadané v right.

Poznámky

Znaménka mají zachované značky.

Příklad

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

Levý posune bity pro každý prvek valarray operandu zadaný počet pozic nebo podle množství prvku určeného sekundou valarray.

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

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

Parametry

right
Hodnota označující množství levého posunu nebo valarray jehož prvky označují množství levého posunu.

Vrácená hodnota

A valarray , jehož prvky byly posunuty doleva množství zadané v right.

Poznámky

Znaménka mají zachované značky.

Příklad

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

Vynásobí prvky zadaného valarray nebo hodnoty typu prvku, element-moudrý, na operand valarray.

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

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

Parametry

right
Nebo valarray hodnota typu prvku, který je identický s operandem valarray , který se má násobit, prvek-moudrý, operand valarray.

Vrácená hodnota

A valarray , jehož prvky jsou prvek-moudrý součin operandu valarray a right.

Příklad

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

Unární operátor, který aplikuje plus na každý prvek v objektu valarray. U normálních aritmetických hodnot tato operace nemá žádný vliv.

valarray<Type> operator+() const;

Vrácená hodnota

A valarray jehož prvky jsou unární plus výsledek operandového pole.

Příklad

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

Přidá prvky zadaného valarray nebo hodnoty typu prvku, element-moudrý, do operandu valarray.

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

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

Parametry

right
valarray Nebo hodnota typu prvku, který je identický s operandemvalarray, který má být přidán, prvek-moudrý, do operandu valarray.

Vrácená hodnota

A valarray jehož prvky jsou prvek-moudrý součet operandu valarray a right.

Příklad

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

Unární operátor, který aplikuje aritmetické negace na každý prvek v objektu valarray.

valarray<Type> operator-() const;

Vrácená hodnota

A valarray jehož prvky jsou aritmeticky negovány z prvků operandu valarray.

Příklad

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

Odečte prvky zadaného valarray nebo hodnoty typu prvku, prvek-moudrý, od operandu valarray.

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

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

Parametry

right
Nebo valarray hodnota typu prvku, který je identický s operandem valarray , který má být odečten, prvek-moudrý, od operandu valarray.

Vrácená hodnota

A valarray , jehož prvky jsou element-moudrý rozdíl operand valarray a right.

Příklad

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

Vydělí prvek operandu valarray prvky zadaného valarray nebo hodnoty typu prvku.

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

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

Parametry

right
valarray Nebo hodnota typu prvku, který je identický s operandemvalarray, který má být rozdělen, prvek-moudrý, do operandu valarray.

Vrácená hodnota

A valarray jehož prvky jsou podílem operandu valarray děleného right.

Příklad

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

Přiřadí prvky k hodnotě valarray , jejíž hodnoty jsou zadány buď přímo, nebo jako součást některé valarray jiné, nebo pomocí slice_array, gslice_array, mask_arraynebo 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
Zkopírovaný valarray do operandu valarray.

val
Hodnota, která má být přiřazena k prvkům operandu valarray.

slicearray
Zkopírovaný slice_array do operandu valarray.

gslicearray
Zkopírovaný gslice_array do operandu valarray.

maskarray
Zkopírovaný mask_array do operandu valarray.

indarray
Zkopírovaný indirect_array do operandu valarray.

Vrácená hodnota

První člen operátor nahrazuje řízenou sekvenci kopií sekvence řízené right.

Druhý operátor členu je stejný jako první, ale s deklarátorem odkazu Rvalue: &&.

Třetí člen operátor nahrazuje každý prvek řízené sekvence kopií val.

Zbývající členské operátory nahradí tyto prvky řízené sekvence vybrané jejich argumenty, které jsou generovány pouze operator[].

Pokud hodnota členu v náhradní řízené sekvenci závisí na členu v počáteční řízené sekvenci, výsledek není definován.

Poznámky

Pokud se délka řízené sekvence změní, obvykle je výsledek nedefinovaný. V této implementaci je však účinek pouze zneplatnit jakékoli ukazatele nebo odkazy na prvky v řízené sekvenci.

Příklad

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

Vrátí odkaz na prvek nebo jeho hodnotu v zadaném indexu nebo zadané podmnožině.

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
Index prvku, který má být přiřazen hodnotu.

slicearray
A slice_array z valarray toho, která určuje podmnožinu, která má být vybrána nebo vrácena do nové valarray.

gslicearray
A gslice_array z valarray toho, která určuje podmnožinu, která má být vybrána nebo vrácena do nové valarray.

boolarray
A bool_array z valarray toho, která určuje podmnožinu, která má být vybrána nebo vrácena do nové valarray.

indarray
Jedná indirect_array se o podmnožinu valarray , která má být vybrána nebo vrácena do nové valarray.

Vrácená hodnota

Odkaz na prvek nebo jeho hodnotu v zadaném indexu nebo zadané podmnožině.

Poznámky

Operátor členu je přetížen, aby poskytoval několik způsobů, jak vybrat sekvence prvků z těch, které řídí *this. První skupina pěti členských operátorů spolupracuje s různými přetíženími (a dalšími operátory operator= přiřazování) umožňující selektivní nahrazení (řezy) řízené sekvence. Vybrané prvky musí existovat.

Při kompilaci pomocí _ITERATOR_DEBUG_LEVEL definovaného jako 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku mimo hranice valarray. Další informace naleznete v tématu Kontrola iterátorů.

Příklad

Podívejte se na příklady a slice::slice gslice::gslice příklad, jak deklarovat a používat operator[].

operator^=

Získá bitové výhradní nebo (^) ze zadaného valarray valarray typu prvku nebo hodnotu typu prvku.

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

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

Parametry

right
Nebo valarray hodnota typu prvku, který je identický s operandem valarray , který má být sloučen bitovým výhradním operátorem nebo (^XOR) s operandem valarray.

Vrácená hodnota

A valarray jehož prvky jsou bitové výhradní nebo (XOR) operandu valarray a right.

Poznámky

Bitové výhradní nebo, označované jako XOR a označené operátorem ^, má následující sémantiku: Dané bity b1 a b2, b1 ^ b2 je 1, pokud přesně jeden z prvků je 1, a 0, pokud oba prvky jsou 0 nebo 1.

Příklad

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

Získá bitové OR (|) prvků v matici buď s odpovídajícími prvky v zadaném valarray nebo s hodnotou typu prvku.

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

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

Parametry

right
valarray Nebo hodnota typu prvku shodného s operandemvalarray, který má být kombinován, prvek moudrý, bitovou or (|) s operandem valarray.

Vrácená hodnota

A valarray jehož prvky jsou bitové bitové OR (|) operandu valarray right.

Poznámky

Bitovou operaci lze použít pouze k manipulaci s bity v celočíselných datových typech, například char a int. Nefunguje na float, , double, long double, void, bool, nebo jiných, složitějších datových typech.

Bitový operátor OR (|) se vztahuje na datový typ na úrovni jednotlivých bitů. Dané bity b1 a b2, b1 | b2 je 1, pokud alespoň jeden z bitů je 1; 0, pokud jsou oba bity 0.

Příklad

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

Unární operátor, který získá bitový doplněk hodnot každého prvku v objektu valarray.

valarray<Type> operator~() const;

Vrácená hodnota

Hodnoty valarray , které jsou unární bitový doplněk hodnot prvku operandu valarray.

Poznámky

Bitové operace může manipulovat pouze s bity v celočíselných typech, například char a int. Nefunguje na float, , double, long double, void, bool, nebo jiných, složitějších datových typech.

Unární bitový operátor ~ doplňku se vztahuje na datový typ na úrovni jednotlivých bitů. Daný bit bje ~b 1, pokud b je 0 a 0, pokud b je 1.

Příklad

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

Změní počet prvků v zadaném valarray čísle.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Parametry

new_size
Počet prvků ve změně valarrayvelikosti .

val
Hodnota, která se má dát prvkům změněné valarrayvelikosti .

Poznámky

První člen funkce inicializuje prvky s jejich výchozí konstruktor.

Všechny ukazatele nebo odkazy na prvky v řízené sekvenci jsou neplatné.

Příklad

Následující příklad ukazuje použití valarray::resize členské funkce.

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

Posune všechny prvky v zadaném valarray počtu míst.

valarray<Type> shift(int count) const;

Parametry

count
Počet míst, kde mají být prvky posunuty dopředu.

Vrácená hodnota

Nový valarray , ve kterém byly všechny prvky přesunuty count na přední straně valarray, nebo vlevo ve srovnání s jejich pozicemi v operandu valarray.

Poznámky

Kladná count hodnota posune prvky doleva count místa s nulovou výplní.

Záporná count hodnota posune prvky doprava count s nulovou výplní.

Příklad

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

Najde počet prvků v prvku valarray.

size_t size() const;

Vrácená hodnota

Počet prvků v operandu valarray.

Příklad

Následující příklad ukazuje použití valarray::size členské funkce.

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

Určuje součet všech prvků v valarray nenulové délce.

Type sum() const;

Vrácená hodnota

Součet prvků operandu valarray.

Poznámky

Pokud je délka větší než jedna, členová funkce přičte hodnoty k součtu použitím operator+= dvojic prvků třídy Type. To znamená, že operátor musí být zadán pro prvky typu Type.

Příklad

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

Vymění prvky dvou valarray objektů.

void swap(valarray& right);

Parametry

right
Poskytnutí valarray prvků, které se mají prohodit.

Poznámky

Členová funkce prohodí řízené sekvence mezi *this a right. V konstantním čase vyvolá žádné výjimky a zneplatní žádné odkazy, ukazatele nebo iterátory prvků ve dvou kontrolovaných sekvencích.

valarray

valarray Vytvoří určitou velikost nebo s prvky určité hodnoty nebo jako kopii jiné valarray nebo podmnožinu jiného 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
Počet prvků, které mají být v valarray.

val
Hodnota, která se má použít při inicializaci prvků v souboru valarray.

ptr
Ukazatel na hodnoty, které se mají použít k inicializaci prvků v objektu valarray.

right
Existující valarray pro inicializaci nového valarraysouboru .

sliceArray
Jejíž slice_array hodnoty prvků se mají použít při inicializaci prvků vytvářeného objektu valarray .

gsliceArray
Jejíž gslice_array hodnoty prvků se mají použít při inicializaci prvků vytvářeného objektu valarray .

maskArray
Jejíž mask_array hodnoty prvků se mají použít při inicializaci prvků vytvářeného objektu valarray .

indArray
Jejíž indirect_array hodnoty prvků se mají použít při inicializaci prvků vytvářeného objektu valarray .

iList
Obsahuje initializer_list prvky, které chcete zkopírovat.

Poznámky

První (výchozí) konstruktor inicializuje objekt do prázdné valarray. Následující tři konstruktory inicializují objekt na elementy valarray count následujícím způsobem:

  • Pro explicitní valarray(size_t count), každý prvek je inicializován pomocí výchozí konstruktoru.

  • Pro valarray(const Type& val, count), každý prvek je inicializován pomocí val.

  • Pro valarray(const Type* ptr, count), prvek na pozici I je inicializován s ptr[I].

Každý zbývající konstruktor inicializuje objekt na valarray<Type> objekt určený podmnožinou zadanou v argumentu.

Poslední konstruktor je stejný jako poslední, ale s deklarátorem odkazu Rvalue: &&.

Příklad

// 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, který představuje typ prvku uloženého v objektu valarray.

typedef Type value_type;

Poznámky

Typ je synonymem pro parametr Typešablony .

Příklad

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

Viz také

Zabezpečení vláken ve standardní knihovně C++

  • Last updated on