`valarray`-Klasse

Artikel
10/12/2023

Die Klassenvorlage valarray<Type> beschreibt ein Objekt, das eine Abfolge von Elementen vom Typ Type steuert, die als Array gespeichert sind, für hochgeschwindigkeitsmathetische Vorgänge konzipiert und für die Berechnungsleistung optimiert sind.

Hinweise

Die Klasse ist eine Darstellung des mathematischen Konzepts einer sortierten Wertemenge. Die Elemente werden sequenziell von Null nummeriert. Die Klasse wird als näherer Container beschrieben, da sie einige, aber nicht alle Funktionen unterstützt, die Container der ersten Klasse sequenzieren, z vector. B. die Unterstützung. Sie unterscheidet sich von der Klassenvorlage vector auf zwei wichtige Arten:

Es definiert viele arithmetische Vorgänge zwischen den entsprechenden Elementen von valarray<Type> Objekten desselben Typs und der gleichen Länge, z varr_x* = cos(varr_y) + sin(varr_z). B. .
Es definiert verschiedene interessante Methoden zum Tiefstellen eines valarray<Type> Objekts durch Überladung operator[].

Ein Objekt der Klasse Type:

Es hat einen öffentlichen Standardkonstruktor, Destruktor, Kopierkonstruktor und Zuweisungsoperator mit üblichem Verhalten.
Es definiert nach Bedarf die arithmetischen Operatoren und mathematischen Funktionen, die für die Gleitkommatypen definiert sind (mit üblichem Verhalten).

Insbesondere dürfen keine feinen Unterschiede zwischen einer Kopierkonstruktion und einer Standardkonstruktion bestehen, auf die eine Zuweisung folgt. Keine der Vorgänge für Klassenobjekte Type löst Ausnahmen aus.

Member

Konstruktoren

Name	Beschreibung
`valarray`	Erstellt ein `valarray`-Objekt einer bestimmten Größe oder mit Elementen eines bestimmten Werts oder als Kopie eines anderen `valarray`-Objekts oder als Teilmenge eines anderen `valarray`-Objekts.

TypeDefs

Name	Beschreibung
`value_type`	Ein Typ, der den Typ der in einem `valarray`-Objekt gespeicherten Elemente darstellt.

Funktionen

Name	Beschreibung
`apply`	Wendet eine angegebene Funktion auf jedes Element eines `valarray`-Objekts an.
`cshift`	Verschiebt zyklisch alle Elemente in einem `valarray`-Objekt um eine angegebene Anzahl von Positionen.
`free`	Gibt den Arbeitsspeicher frei, der vom `valarray`-Objekt verwendet wird.
`max`	Sucht nach dem größten Element in einem `valarray`-Objekt.
`min`	Sucht nach dem kleinsten Element in einem `valarray`-Objekt.
`resize`	Ändert die Anzahl von Elementen in einem `valarray`-Objekt in die jeweils angegebene Anzahl, wozu Elemente nach Bedarf hinzugefügt oder entfernt werden.
`shift`	Verschiebt alle Elemente in einem `valarray`-Objekt um eine angegebene Anzahl von Positionen.
`size`	Ermittelt die Anzahl von Elementen in einem `valarray`-Objekt.
`sum`	Bestimmt die Summe aller Elemente in einem `valarray`-Objekt mit einer Länge ungleich null.
`swap`

Operatoren

Name	Beschreibung
`operator!`	Ein unärer Operator, der die logischen NOT (`!`) -Werte der einzelnen Elemente in einem `valarray`.
`operator%=`	Ruft den Rest der Division der Elemente eines Arrays elementweise entweder entsprechend einem angegebenen `valarray`-Objekt oder entsprechend einem Wert des Elementtyps ab.
`operator&=`	Ruft das bitweise UND (`&`) von Elementen in einem Array ab, entweder mit den entsprechenden Elementen in einem angegebenen `valarray` elementtyp oder mit einem Wert des Elementtyps.
`operator>>=`	Verschiebt die Bits für jedes Element eines `valarray`-Operanden um eine angegebene Anzahl von Positionen oder um einen elementweisen Betrag, der durch ein zweites `valarray`-Objekt angegeben ist, nach rechts.
`operator<<=`	Verschiebt die Bits für jedes Element eines `valarray`-Operanden um eine angegebene Anzahl von Positionen oder um einen elementweisen Betrag, der durch ein zweites `valarray`-Objekt angegeben ist, nach links.
`operator*=`	Multipliziert die Elemente eines angegebenen `valarray`-Objekts oder einen Wert des Elementtyps elementweise mit einem `valarray`-Operanden.
`operator+`	Ein unärer Operator, der ein Pluszeichen auf jedes Element in einem `valarray`-Objekt anwendet. Bei normalen arithmetischen Typen hat dieser Operator keine Auswirkung.
`operator+=`	Fügt die Elemente eines angegebenen `valarray`-Objekts oder einen Wert des Elementtyps elementweise einem `valarray`-Operanden hinzu.
`operator-`	Ein unärer Operator, der eine arithmetische Negation auf jedes Element in einem anwendet `valarray`.
`operator-=`	Subtrahiert die Elemente eines angegebenen `valarray`-Objekts oder einen Wert des Elementtyps elementweise von einem `valarray`-Operanden.
`operator/=`	Dividiert einen `valarray`-Operanden elementweise durch die Elemente eines angegebenen `valarray`-Objekts oder durch einen Wert des Elementtyps.
`operator=`	Ordnet einem `valarray`-Objekt Elemente zu, deren Werte entweder direkt oder als Teil eines anderen `valarray`-Objekts oder durch ein `slice_array`-, `gslice_array`-, `mask_array`- oder `indirect_array`-Objekt angegeben sind.
`operator[]`	Gibt einen Verweis auf ein Element oder auf den Wert zurück, den es am angegebenen Index oder in der angegebenen Teilmenge hat.
`operator^=`	Ruft die bitweise exklusiv oder (`^`) einer `valarray` mit einem angegebenen `valarray` oder einem Wert des Elementtyps ab.
`operator\|=`	Ruft das bitweise ODER (`\|`) von Elementen in einem Array ab, entweder mit den entsprechenden Elementen in einem angegebenen `valarray` elementtyp oder mit einem Wert des Elementtyps.
`operator~`	Ein unärer Operator, der die bitweisen Komplementwerte (`~`) der einzelnen Elemente in einem `valarray`.

`apply`

Wendet eine angegebene Funktion auf jedes Element eines valarray-Objekts an.

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

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

Parameter

function_object(Type)
Das Funktionsobjekt, das auf jedes Element des Operanden valarrayangewendet werden soll.

function_object(const Type&)
Das Funktionsobjekt für const Elemente, die auf jedes Element des Operanden valarrayangewendet werden sollen.

Rückgabewert

Ein Elementvalarray, dessen Elemente elementweise auf die Elemente des Operanden valarrayangewendet wurdenfunction_object.

Hinweise

Die Memberfunktion gibt ein Objekt der Klasse valarray<Type>, der Länge size, deren Elemente elem das Ergebnis von function_object((*this)[elem]).

Beispiel

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

Verschiebt zyklisch alle Elemente in einem valarray-Objekt um eine angegebene Anzahl von Positionen.

valarray<Type> cshift(int count) const;

Parameter

count
Die Anzahl der Stellen, um die die Elemente nach vorn verschoben werden.

Rückgabewert

Eine neue, valarray in der alle Elemente zyklisch in Richtung der Front des valarray, oder nach links im Vergleich zu ihren Positionen im Operanden valarrayverschoben count wurden.

Hinweise

Ein positiver Wert von count verschiebt die Elemente zyklisch um count Stellen nach links.

Ein negativer Wert von count verschiebt die Elemente zyklisch um count Stellen nach rechts.

Beispiel

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

Gibt den Arbeitsspeicher frei, der vom valarray-Objekt verwendet wird.

void free();

Hinweise

Diese nicht standardmäßige Funktion entspricht dem Zuweisen einer leeren valarrayFunktion. Beispiel:

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

// equivalent to v.free()

`max`

Sucht nach dem größten Element in einem valarray-Objekt.

Type max() const;

Rückgabewert

Der Maximalwert der Elemente im Operanden valarray.

Hinweise

Die Memberfunktion vergleicht Werte durch Anwenden von Operator< - oder Operatorpaaren> von Elementen der Klasse Type, für die Operatoren für das Element Typebereitgestellt werden müssen.

Beispiel

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

Sucht nach dem kleinsten Element in einem valarray-Objekt.

Type min() const;

Rückgabewert

Der Mindestwert der Elemente im Operanden valarray.

Hinweise

Beispiel

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

Ein unärer Operator, der die logischen NOT (!) -Werte der einzelnen Elemente in einem valarray.

valarray<bool> operator!() const;

Rückgabewert

Die valarray booleschen Werte, die die logische Negation der Elementwerte des Operanden valarraysind.

Hinweise

Der logische Vorgang NOT, der durch !die Elemente bezeichnet wird, negiert die Elemente logisch, da alle Nullwerte in true und alle Nicht-Null-Werte in falsekonvertiert werden. Die zurückgegebenen valarray booleschen Werte haben dieselbe Größe wie der Operand valarray.

Beispiel

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

Ruft den Rest der Division der Elemente eines Arrays elementweise entweder entsprechend einem angegebenen valarray-Objekt oder entsprechend einem Wert des Elementtyps ab.

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

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

Parameter

right
Der valarray Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der zum Dividieren, elementweisen, zum Operanden valarraygehört.

Rückgabewert

Avalarray, dessen Elemente die re Standard der aus der elementweisen Division des Operanden valarray durch right.

Beispiel

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

Ruft das bitweise UND (&) von Elementen in einem Array ab, entweder mit den entsprechenden Elementen in einem angegebenen valarray elementtyp oder mit einem Wert des Elementtyps.

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

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

Parameter

right
Der valarray Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der durch den bitweisen UND (&) mit dem Operanden valarraykombiniert werden soll.

Rückgabewert

A valarray , dessen Elemente bitweise UND (&) des Operanden valarray durch right

Hinweise

Ein bitweiser Vorgang kann nur zum Bearbeiten von Bits in integralen Datentypen verwendet werden, z char . B. und int. Es funktioniert nicht an floatkomplexeren Datentypen, an , , double, long doublevoid, bool, oder an anderen, komplexeren Datentypen.

Das bitweise UND (&) gilt für den Datentyp auf der Ebene der einzelnen Bits. Bestimmte Bits b1 und b2, b1 & b2 ist 1, wenn beide Bits 1 sind; 0, wenn mindestens ein Bit 0 ist.

Beispiel

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

Verschiebt die Bits für jedes Element eines valarray-Operanden um eine angegebene Anzahl von Positionen oder um einen elementweisen Betrag, der durch ein zweites valarray-Objekt angegeben ist, nach rechts.

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

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

Parameter

right
Der Wert, der die Menge der rechten Schicht angibt oder ein valarray Element, dessen Elemente die elementweise Menge der rechten Schicht angeben.

Rückgabewert

Ein valarray Element, dessen Elemente nach rechts verschoben wurden, um den in right.

Hinweise

Bei Zahlen mit Vorzeichen bleiben die Vorzeichen erhalten.

Beispiel

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

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

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

Parameter

right
Der Wert, der die Menge der linken Schicht angibt oder valarray deren Elemente die elementweise Menge der linken Schicht angeben.

Rückgabewert

Ein valarray Element, dessen Elemente verschoben wurden, hat den in .right

Hinweise

Bei Zahlen mit Vorzeichen bleiben die Vorzeichen erhalten.

Beispiel

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

Multipliziert die Elemente eines angegebenen valarray-Objekts oder einen Wert des Elementtyps elementweise mit einem valarray-Operanden.

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

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

Parameter

right
Der valarray Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der multipliziert, elementweise, der Operand valarray.

Rückgabewert

A valarray , deren Elemente das elementweise Produkt des Operanden valarray und right.

Beispiel

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

Ein unärer Operator, der ein Pluszeichen auf jedes Element in einem valarray-Objekt anwendet. Bei normalen arithmetischen Werten hat dieser Vorgang keine Auswirkung.

valarray<Type> operator+() const;

Rückgabewert

A valarray , dessen Elemente das unäre Plusergebnis des Operandenarrays sind.

Beispiel

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

Fügt die Elemente eines angegebenen valarray-Objekts oder einen Wert des Elementtyps elementweise einem valarray-Operanden hinzu.

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

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

Parameter

right
Der valarray Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der dem Operanden valarrayhinzugefügt werden soll.

Rückgabewert

A valarray , dessen Elemente die elementweise Summe des Operanden valarray und right.

Beispiel

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

Ein unärer Operator, der eine arithmetische Negation auf jedes Element in einem anwendet valarray.

valarray<Type> operator-() const;

Rückgabewert

A valarray , dessen Elemente arithmetisch von den Elementen des Operanden valarraynegiert werden.

Beispiel

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

Subtrahiert die Elemente eines angegebenen valarray-Objekts oder einen Wert des Elementtyps elementweise von einem valarray-Operanden.

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

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

Parameter

right
Der valarray Oder Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der vom Operanden valarraysubtrahiert werden soll, elementweise.

Rückgabewert

A valarray , dessen Elemente der elementweise Unterschied des Operanden valarray und rightdes .

Beispiel

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

Dividiert einen valarray-Operanden elementweise durch die Elemente eines angegebenen valarray-Objekts oder durch einen Wert des Elementtyps.

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

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

Parameter

right
Der valarray Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der in den Operanden valarrayunterteilt werden soll.

Rückgabewert

A valarray , dessen Elemente der elementweisen Quotient des Operanden valarray dividiert durch right.

Beispiel

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

Ordnet einem valarray-Objekt Elemente zu, deren Werte entweder direkt oder als Teil eines anderen valarray-Objekts oder durch ein slice_array-, gslice_array-, mask_array- oder indirect_array-Objekt angegeben sind.

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

Parameter

right
Der valarray in den Operanden valarraykopiert werden soll.

val
Der Wert, der den Elementen des Operanden valarrayzugewiesen werden soll.

slicearray
Der slice_array in den Operanden valarraykopiert werden soll.

gslicearray
Der gslice_array in den Operanden valarraykopiert werden soll.

maskarray
Der mask_array in den Operanden valarraykopiert werden soll.

indarray
Der indirect_array in den Operanden valarraykopiert werden soll.

Rückgabewert

Der Memberoperator ersetzt die gesteuerte Sequenz durch eine Kopie der von right gesteuerten Sequenz.

Der zweite Memberoperator ist identisch mit dem ersten, aber mit einem Rvalue-Verweis-Deklarator: &&.

Der dritte Memberoperator ersetzt jedes Element der gesteuerten Sequenz durch eine Kopie von Val.

Die Elementoperatoren für das erneute Standard ersetzen diese Elemente der durch ihre Argumente ausgewählten kontrollierten Sequenz, die nur von operator[]den Argumenten generiert werden.

Wenn der Wert eines Members in der gesteuerten Ersatzsequenz von einem Member in der gesteuerten Anfangssequenz abhängt, ist das Ergebnis nicht definiert.

Hinweise

Wenn sich die Länge der kontrollierten Sequenz ändert, ist das Ergebnis normalerweise nicht definiert. In dieser Implementierung werden jedoch nur Zeiger oder Verweise auf Elemente in der gesteuerten Sequenz ungültig gemacht.

Beispiel

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

Gibt einen Verweis auf ein Element oder auf den Wert zurück, den es am angegebenen Index oder in der angegebenen Teilmenge hat.

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;

Parameter

index
Der Index des Elements, das einem Wert zugewiesen werden soll.

slicearray
A slice_array of a valarray that specifies a subset to be selected or returned to a new valarray.

gslicearray
A gslice_array of a valarray that specifies a subset to be selected or returned to a new valarray.

boolarray
A bool_array of a valarray that specifies a subset to be selected or returned to a new valarray.

indarray
Eine indirect_array von einer valarray , die eine Teilmenge angibt, die ausgewählt oder an eine neue valarrayzurückgegeben werden soll.

Rückgabewert

Ein Verweis auf ein Element oder auf den Wert, den es am angegebenen Index oder in der angegebenen Teilmenge hat.

Hinweise

Der Memberoperator wird überladen, um mehrere Möglichkeiten zum Auswählen von Sequenzen von Elementen zwischen den Elementen bereitzustellen, die von diesen gesteuert werden *this. Die erste Gruppe von fünf Memberoperatoren arbeitet mit verschiedenen Überladungen ( operator= und anderen Zuweisungsoperatoren) zusammen, um die selektive Ersetzung (Slicing) der kontrollierten Sequenz zu ermöglichen. Dabei müssen die ausgewählten Elemente vorhanden sein.

Bei der Kompilierung mithilfe von _ITERATOR_DEBUG_LEVEL 1 oder 2 tritt ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element außerhalb der Grenzen der .valarray Weitere Informationen finden Sie unter "Überprüfte Iteratoren".

Beispiel

Ein Beispiel zum slice::slicegslice::gslice Deklarieren und Verwenden operator[]finden Sie in den Beispielen.

`operator^=`

Ruft die bitweise exklusiv oder (^) einer valarray mit einem angegebenen valarray oder einem Wert des Elementtyps ab.

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

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

Parameter

right
Der valarray Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der durch den bitweisen exklusiven oder (XOR)-Operator (^) mit dem Operanden valarraykombiniert werden soll.

Rückgabewert

A valarray , deren Elemente bitweise exklusiv oder (XOR) des Operanden valarray und right.

Hinweise

Die bitweise ausschließliche oder als XOR bezeichnete und vom Operator ^gekennzeichnete Semantik weist die folgende Semantik auf: Bestimmte Bits b1 und b2, b1 ^ b2 ist 1, wenn genau eines der Elemente 1 und 0 ist, wenn beide Elemente 0 oder 1 sind.

Beispiel

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

Ruft das bitweise ODER (|) von Elementen in einem Array ab, entweder mit den entsprechenden Elementen in einem angegebenen valarray elementtyp oder mit einem Wert des Elementtyps.

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

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

Parameter

right
Der valarray Wert eines Elementtyps, der mit dem des Operanden valarray identisch ist, der durch den bitweisen OR (|) mit dem Operanden valarraykombiniert werden soll.

Rückgabewert

A valarray , dessen Elemente das elementweise ODER (|) des Operanden valarray von right.

Hinweise

Ein bitweiser Vorgang kann nur verwendet werden, um Bits in integralen Datentypen wie char z. B. und int. Es funktioniert nicht an floatkomplexeren Datentypen, an , , double, long doublevoid, bool, oder an anderen, komplexeren Datentypen.

Der bitweise OR (|) gilt für den Datentyp auf der Ebene der einzelnen Bits. Bestimmte Bits b1 und b2, b1 | b2 ist 1, wenn mindestens eine der Bits 1 ist; 0, wenn beide Bits 0 sind.

Beispiel

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

Ein unärer Operator, der die bitweise Ergänzung der Werte der einzelnen Elemente in einem valarray.

valarray<Type> operator~() const;

Rückgabewert

Die valarray Werte, die die unäre bitweise Ergänzung der Elementwerte des Operanden valarraysind.

Hinweise

Ein bitweiser Vorgang kann Bits nur in integralen Typen bearbeiten, z char . B. und int. Es funktioniert nicht an floatkomplexeren Datentypen, an , , double, long doublevoid, bool, oder an anderen, komplexeren Datentypen.

Der unär bitweise Ergänzungsoperator ~ gilt für den Datentyp auf der Ebene der einzelnen Bits. Bei bit b~b ist 1 if b is 0 and 0 if b is 1.

Beispiel

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

Ändert die Anzahl der Elemente in einer valarray angegebenen Zahl.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Parameter

new_size
Die Anzahl der Elemente in der geänderten Größe valarray.

val
Der Wert, der den Elementen der geänderten Größe valarrayzugewiesen werden soll.

Hinweise

Die erste Memberfunktion initialisiert Elemente mit ihrem standardmäßigen Konstruktor.

Zeiger oder Verweise auf Elemente in der kontrollierten Sequenz werden ungültig.

Beispiel

Im folgenden Beispiel wird die Verwendung der valarray::resize Memberfunktion veranschaulicht.

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

Verschiebt alle Elemente in einer valarray um eine bestimmte Anzahl von Stellen.

valarray<Type> shift(int count) const;

Parameter

count
Die Anzahl der Stellen, um die die Elemente nach vorn verschoben werden.

Rückgabewert

Eine neue, valarray in der alle Elemente in Richtung der Vorder- oder Nach-links-Position valarrayim Vergleich zu ihren Positionen im Operanden valarrayverschoben count wurden.

Hinweise

Ein positiver Wert von count verschiebt die Elemente um count Stellen nach links und füllt mit Nullen auf.

Ein negativer Wert von count verschiebt die Elemente um count Stellen nach rechts und füllt mit Nullen auf.

Beispiel

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

Ermittelt die Anzahl von Elementen in einem valarray-Objekt.

size_t size() const;

Rückgabewert

Die Anzahl der Elemente im Operanden valarray.

Beispiel

Im folgenden Beispiel wird die Verwendung der valarray::size Memberfunktion veranschaulicht.

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

Bestimmt die Summe aller Elemente in einem valarray-Objekt mit einer Länge ungleich null.

Type sum() const;

Rückgabewert

Die Summe der Elemente des Operanden valarray.

Hinweise

Wenn die Länge größer als eine ist, fügt die Memberfunktion der Summe Werte hinzu, indem zwischen Paaren von Elementen der Klasse Typeangewendet operator+= wird. Dies bedeutet, dass der Operator für Elemente vom Typ Typebereitgestellt werden muss.

Beispiel

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

Tauscht die Elemente zweier valarray-Objekte.

void swap(valarray& right);

Parameter

right
Ein valarray-Objekt, das die auszutauschenden Elemente bereitgestellt.

Hinweise

Die Memberfunktion tauscht die kontrollierten Sequenzen zwischen *this und right aus. Dies geschieht in konstanter Zeit, es löst keine Ausnahmen aus und ungültigt keine Verweise, Zeiger oder Iteratoren auf Elemente in den beiden gesteuerten Sequenzen.

`valarray`

Erstellt ein valarray-Objekt einer bestimmten Größe oder mit Elementen eines bestimmten Werts oder als Kopie eines anderen valarray-Objekts oder als Teilmenge eines anderen valarray-Objekts.

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

Parameter

count
Die Anzahl der Elemente, die in der valarray.

val
Der Wert, der beim Initialisieren der Elemente in der valarray.

ptr
Zeigen Sie auf die Werte, die zum Initialisieren der Elemente in der valarray.

right
Ein vorhandener valarray Zum Initialisieren des neuen valarray.

sliceArray
Ein slice_array Elementwert, dessen Elementwerte verwendet werden sollen, um die Elemente des valarray zu erstellenden Elements zu initialisieren.

gsliceArray
Ein gslice_array Elementwert, dessen Elementwerte verwendet werden sollen, um die Elemente des valarray zu erstellenden Elements zu initialisieren.

maskArray
Ein mask_array Elementwert, dessen Elementwerte verwendet werden sollen, um die Elemente des valarray zu erstellenden Elements zu initialisieren.

indArray
Ein indirect_array Elementwert, dessen Elementwerte verwendet werden sollen, um die Elemente des valarray zu erstellenden Elements zu initialisieren.

iList
Die initializer_list elemente, die kopiert werden sollen.

Hinweise

Der erste (Standard)-Konstruktor initialisiert das Objekt in einem leeren valarray. Die nächsten drei Konstruktoren initialisieren das Objekt wie folgt in einem valarray Element count :

Bei expliziten valarray(size_t count) wird jedes Element mit dem Standardkonstruktor initialisiert.
Bei valarray(const Type& val, count) wird jedes Element mit val initialisiert.
For valarray(const Type* ptr, count), the element at position I is initialized with ptr[I].

Jeder neu Standard Konstruktor initialisiert das Objekt in ein valarray<Type> Objekt, das von der im Argument angegebenen Teilmenge bestimmt wird.

Der letzte Konstruktor ist identisch mit dem nächsten, aber mit einem Rvalue-Verweisdeklarator: &&.

Beispiel

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

Ein Typ, der den Typ der in einem valarray-Objekt gespeicherten Elemente darstellt.

typedef Type value_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Typedar.

Beispiel

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

Siehe auch

Threadsicherheit in der C++-Standardbibliothek

Freigeben über

valarray-Klasse

Hinweise

Member

Konstruktoren

TypeDefs

Funktionen

Operatoren

apply

Parameter

Rückgabewert

Hinweise

Beispiel

cshift

Parameter

Rückgabewert

Hinweise

Beispiel

free

Hinweise

max

Rückgabewert

Hinweise

Beispiel

min

Rückgabewert

Hinweise

Beispiel

operator!

Rückgabewert

Hinweise

Beispiel

operator%=

Parameter

Rückgabewert

Beispiel

operator&=

Parameter

Rückgabewert

Hinweise

Beispiel

operator>>=

Parameter

Rückgabewert

Hinweise

Beispiel

operator<<=

Parameter

Rückgabewert

Hinweise

Beispiel

operator*=

Parameter

Rückgabewert

Beispiel

operator+

Rückgabewert

Beispiel

operator+=

Parameter

Rückgabewert

Beispiel

operator-

Rückgabewert

Beispiel

operator-=

Parameter

Rückgabewert

Beispiel

operator/=

Parameter

Rückgabewert

Beispiel

operator=

Parameter

Rückgabewert

Hinweise

Beispiel

operator[]

Parameter

`valarray`-Klasse

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