`<valarray>` betriebspersonal

Artikel
10/12/2023

`operator!=`

Überprüft, ob die entsprechenden Elemente von zwei gleich großen valarray Objekten ungleich sind oder ob alle Elemente eines valarray Objekts ungleich einem angegebenen Wert sind.

template <class Type>
valarray<bool>
operator!=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator!=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator!=(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Ein valarray Objekt, dessen Elemente auf Ungleichheit gegen ein anderes valarray Objekt getestet werden sollen, oder ein Wert des Elementtyps, der mit den einzelnen Elementen in einem valarrayverglichen werden soll.

right
Ein valarray Objekt, dessen Elemente auf Ungleichheit gegen ein anderes valarray Objekt getestet werden sollen, oder ein Wert des Elementtyps, der mit den einzelnen Elementen in einem valarrayverglichen werden soll.

Rückgabewert

Eine valarray von booleschen Werten, von denen jede lautet:

true wenn die entsprechenden Elemente ungleich sind.
false wenn die entsprechenden Elemente gleich sind.

Hinweise

Der erste Vorlagenoperator gibt ein Objekt der Klasse valarray<bool>zurück, dessen Elemente I jeweils sind left[I] != right[I].

Der zweite Vorlagenoperator speichert left[I] != right im Element I.

Der dritte Vorlagenoperator wird im Element Igespeichertleft != right[I].

Beispiel

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

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

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

   cout << "The initial Left 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;

   vaNE = ( vaL != vaR );
   cout << "The element-by-element result of "
        << "the not equal comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the not equal comparison test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator%`

Ruft den Rest ab, um die entsprechenden Elemente von zwei gleich großen valarray Objekten zu dividieren oder einen valarray durch einen angegebenen Wert zu dividieren oder einen angegebenen Wert durch ein valarray.

template <class Type>
valarray<Type>
operator%(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator%(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator%(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Ein Wert oder valarray ein Wert, der als Dividende dient, in den ein anderer Wert valarray aufgeteilt oder aufgeteilt werden soll.

right
Ein Wert oder valarray ein Wert, der als Divisor dient und einen anderen Wert teilt oder valarray.

Rückgabewert

A valarray , deren Elemente die elementweisen Reste von left geteilt durch right.

Beispiel

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

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

   valarray<int> vaL ( 6 ), vaR ( 6 );
   valarray<int> vaREM ( 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 Left 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;

   vaREM = ( vaL % vaR );
   cout << "The remainders from the element-by-element "
        << "division is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaREM [ i ] << " ";
   cout << ")." << endl;
}

The initial Left 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 zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem und einem valarray angegebenen Wert des Elementtyps ab.

template <class Type>
valarray<Type>
operator&(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator&(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator&(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren jeweilige Elemente mit dem bitweisen AND kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der durch bitweise UND mit jedem Element eines Elements valarraykombiniert werden soll.

right
Die zweite der beiden valarray Objekte, deren jeweilige Elemente mit dem bitweisen AND kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der durch bitweise UND mit jedem Element eines Elements valarraykombiniert werden soll.

Rückgabewert

A valarray , dessen Elemente die elementweise Kombination der bitweisen UND Operation von left und right.

Hinweise

Ein bitweiser Vorgang kann nur verwendet werden, um Bits in char und int Datentypen und Varianten zu bearbeiten und nicht auf float, , double, long double, voidoder bool anderen, komplexeren Datentypen.

Für die bitweise AND-Operation gilt dieselbe Wahrheitstabelle wie für die logische AND-Operation. Die bitweise AND-Operation wird jedoch nur auf den Datentyp auf der Ebene der Einzelbits angewendet. Die operator&& Anwendung wird auf Elementebene angewendet, wobei alle Nichtzerowerte als truegezählt werden, und das Ergebnis ist ein valarray boolescher Wert. Das bitweise UND operator&kann im Gegensatz dazu zu einem valarray anderen Wert als 0 oder 1 führen, je nach Ergebnis des bitweisen Vorgangs.

Beispiel

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

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

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaBWA ( 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 Left 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;

   vaBWA = ( vaL & vaR );
   cout << "The element-by-element result of "
        << "the bitwise operator & is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaBWA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 2 0 4 0 6 0 8 0 10 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the bitwise operator & is the
valarray: ( 0 0 0 0 0 4 0 0 0 8 ).

`operator&&`

Ruft das logische AND zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem und einem valarray angegebenen Wert des valarray Elementtyps ab.

template <class Type>
valarray<bool>
operator&&(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator&&(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator&&(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren jeweilige Elemente mit dem logischen UND kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der mit jedem Element eines Elements valarraykombiniert werden soll.

right
Die zweite der beiden valarray Objekte, deren jeweilige Elemente mit dem logischen UND kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der mit jedem Element eines Elements valarraykombiniert werden soll.

Rückgabewert

A valarray , dessen Elemente vom Typ bool sind und die elementweise Kombination der logischen UND Operation von left und right.

Hinweise

The logical AND operator&& applies on an element level, counting all nonzero values as true, and the result is a valarray of Boolean values. Die bitweise Version von AND operator&, im Gegensatz dazu, kann zu einem valarray anderen Wert als 0 oder 1 führen, je nach Ergebnis des bitweisen Vorgangs.

Beispiel

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

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

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaLAA ( 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 Left 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;

   vaLAA = ( vaL && vaR );
   cout << "The element-by-element result of "
        << "the logical AND operator&& is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left 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 logical AND operator&& is the
valarray: ( 0 0 0 1 0 1 0 1 0 1 ).

`operator>`

Überprüft, ob die Elemente eines valarray Elements größer als die Elemente einer gleichmäßigen Größe valarraysind oder ob alle Elemente eines valarray Elements größer oder kleiner als ein angegebener Wert sind.

template <class Type>
valarray<bool>
operator>(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator>(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator>(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

right
Die zweite der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

Rückgabewert

Eine valarray von booleschen Werten, von denen jede lautet:

true wenn das Element oder der left Wert größer als das entsprechende right Element oder wert ist.
false wenn das Element oder der left Wert nicht größer als das entsprechende right Element oder wert ist.

Hinweise

Wenn die Anzahl der Elemente in den beiden valarray Objekten nicht gleich ist, wird das Ergebnis nicht definiert.

Beispiel

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

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

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

   cout << "The initial Left 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;

   vaNE = ( vaL > vaR );
   cout << "The element-by-element result of "
        << "the greater than comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the greater than comparison test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator>=`

Überprüft, ob die Elemente eines valarray Elements größer oder gleich den Elementen einer gleichmäßigen Größe valarraysind oder ob alle Elemente eines valarray Elements größer oder gleich oder kleiner als oder gleich einem angegebenen Wert sind.

template <class Type>
valarray<bool>
operator>=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator>=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator>=(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

right
Die zweite der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

Rückgabewert

Eine valarray von booleschen Werten, von denen jede lautet:

true wenn das Element oder der left Wert größer oder gleich dem entsprechenden right Element oder Wert ist.
false wenn das Element oder der left Wert kleiner als das entsprechende right Element oder wert ist.

Hinweise

Wenn die Anzahl der Elemente in zwei valarray Objekten nicht gleich ist, wird das Ergebnis nicht definiert.

Beispiel

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

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

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

   cout << "The initial Left 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;

   vaNE = ( vaL >= vaR );
   cout << "The element-by-element result of "
        << "the greater than or equal test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the greater than or equal test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator>>`

Verschiebt die Bits für jedes Element einer valarray angegebenen Anzahl von Positionen nach rechts oder um einen elementweisen Betrag, der durch eine Sekunde valarrayangegeben wird.

template <class Type>
valarray<Type>
operator>>(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator>>(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator>>(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Der zu verschiebende Wert oder die Elemente, deren valarray Elemente verschoben werden sollen.

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

A valarray , dessen Elemente um den angegebenen Betrag nach rechts verschoben wurden.

Hinweise

Bei Zahlen mit Vorzeichen bleiben die Vorzeichen erhalten.

Beispiel

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

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

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 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 Left 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;

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

The initial Left valarray is: ( 64 -64 64 -64 64 -64 64 -64 ).
The initial 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<`

Überprüft, ob die Elemente eines valarray Elements kleiner als die Elemente einer gleichmäßigen Größe valarraysind oder ob alle Elemente eines valarray Elements größer oder kleiner als ein angegebener Wert sind.

template <class Type>
valarray<bool>
operator<(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator<(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator<(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

right
Die zweite der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

Rückgabewert

Eine valarray von booleschen Werten, von denen jede lautet:

true wenn das Element oder der left Wert kleiner als das entsprechende right Element oder wert ist.
false wenn das Element oder der left Wert nicht kleiner als das entsprechende right Element oder Wert ist.

Hinweise

Wenn die Anzahl der Elemente in zwei valarray Objekten nicht gleich ist, wird das Ergebnis nicht definiert.

Beispiel

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

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

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

   cout << "The initial Left 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;

   vaNE = ( vaL < vaR );
   cout << "The element-by-element result of "
        << "the less-than comparison test is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the less-than comparison test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator<=`

Überprüft, ob die Elemente eines valarray Elements kleiner oder gleich den Elementen einer gleichmäßigen Größe valarraysind oder ob alle Elemente eines valarray Elements größer oder gleich oder kleiner als oder gleich einem angegebenen Wert sind.

template <class Type>
valarray<bool>
operator<=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator<=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator<=(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

right
Die zweite der beiden valarray Objekte, deren Elemente verglichen werden sollen, oder ein angegebener Wert, der mit jedem Element eines elements valarrayverglichen werden soll.

Rückgabewert

Eine valarray von booleschen Werten, von denen jede lautet:

true wenn das Element oder der left Wert kleiner oder gleich dem entsprechenden right Element oder Wert ist.
false wenn das Element oder der left Wert größer als das entsprechende right Element oder wert ist.

Hinweise

Wenn die Anzahl der Elemente in zwei valarray Objekten nicht gleich ist, wird das Ergebnis nicht definiert.

Beispiel

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

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

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

   cout << "The initial Left 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;

   vaNE = ( vaL <= vaR );
   cout << "The element-by-element result of "
        << "the less than or equal test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the less than or equal test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator<<`

Links verschiebt die Bits für jedes Element einer valarray angegebenen Anzahl von Positionen oder um einen elementweisen Betrag, der durch eine Sekunde valarrayangegeben wird.

template <class Type>
valarray<Type>
operator<<(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator<<(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator<<(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Der zu verschiebende Wert oder die Elemente, deren valarray Elemente verschoben werden sollen.

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

Rückgabewert

A valarray , dessen Elemente um den angegebenen Betrag nach links verschoben wurden.

Hinweise

Bei Zahlen mit Vorzeichen bleiben die Vorzeichen erhalten.

Beispiel

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

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

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 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 Left 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;

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

The initial Left valarray is: ( 1 -1 1 -1 1 -1 1 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the left shift is the
valarray: ( 1 -2 4 -8 16 -32 64 -128 ).

`operator*`

Ruft das elementweise Produkt zwischen den entsprechenden Elementen von zwei gleich großen valarray Objekten oder zwischen einem valarray und einem angegebenen Wert ab.

template <class Type>
valarray<Type>
operator*(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator*(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator*(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren Elemente multipliziert werden sollen, oder ein angegebener Wert, der mit jedem Element eines valarraymultipliziert werden soll.

right
Die zweite der beiden valarray Objekte, deren Elemente multipliziert werden sollen, oder ein angegebener Wert, der mit jedem Element eines valarrayObjekts multipliziert werden soll.

Rückgabewert

A valarray , deren Elemente das elementweise Produkt von left und right.

Beispiel

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

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

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 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 Left 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;

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

The initial Left 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+`

Ruft die elementweise Summe zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem valarray und einem angegebenen Wert ab.

template <class Type>
valarray<Type>
operator+(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator+(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator+(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren Elemente hinzugefügt werden sollen, oder ein angegebener Wert, der mit jedem Element eines hinzugefügt valarraywerden soll.

right
Die zweite der beiden valarray Objekte, deren Elemente hinzugefügt werden sollen, oder ein angegebener Wert, der mit jedem Element eines hinzugefügt valarraywerden soll.

Rückgabewert

A valarray , deren Elemente die elementweise Summe von left und right.

Beispiel

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

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

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 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 Left 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;

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

The initial Left 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-`

Ruft den elementweisen Unterschied zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem valarray und einem angegebenen Wert ab.

template <class Type>
valarray<Type>
operator-(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator-(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator-(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Ein Wert oder valarray der als Minuend dient, der Wert, von dem andere Werte oder valarray Objekte subtrahiert werden sollen, um den Unterschied zu bilden.

right
Ein Wert oder valarray der als Subtrahend dient, der Wert, der von anderen Werten oder valarray Objekten subtrahiert werden soll, um den Unterschied zu bilden.

Rückgabewert

Avalarray, deren Elemente der elementweisen Unterschied left und .right

Hinweise

Die arithmetische Terminologie, die zum Beschreiben einer Subtraktion verwendet wird:

Differenz = Minuend - Subtrahend

Beispiel

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

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

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 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 Left 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;

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

The initial Left 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/`

Ruft den elementweisen Quotient zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem valarray und einem angegebenen Wert ab.

template <class Type>
valarray<Type>
operator/(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator/(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator/(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Ein Wert oder valarray ein Wert, der als Dividende dient, in den ein anderer Wert eingeteilt werden soll, valarray um den Quotienten zu bilden.

right
Ein Wert oder valarray ein Wert, der als Divisor dient und einen anderen Wert teilt oder valarray den Quotient bildet.

Rückgabewert

A valarray , deren Elemente der Element-Weisen-Quotient left dividiert durch right.

Hinweise

Die arithmetische Terminologie, die zum Beschreiben einer Division verwendet wird:

Quotient = Dividend/Divisor

Beispiel

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

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

   valarray<double> vaL ( 6 ), vaR ( 6 );
   valarray<double> vaNE ( 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 Left 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;

   vaNE = ( vaL / vaR );
   cout << "The element-by-element result of "
        << "the quotient is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left 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==`

Überprüft, ob die entsprechenden Elemente von zwei gleich großen valarray Objekten gleich sind oder ob alle Elemente eines valarray Objekts gleich einem angegebenen Wert sind.

template <class Type>
valarray<bool>
operator==(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator==(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator==(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Der erste der beiden valarray Objekte, deren Elemente auf Gleichheit getestet werden sollen, oder ein angegebener Wert, der mit jedem valarray Element verglichen werden soll.

right
Die zweite der beiden valarray Objekte, deren Elemente auf Gleichheit getestet werden sollen, oder ein angegebener Wert, der mit jedem valarray Element verglichen werden soll.

Rückgabewert

Eine valarray von booleschen Werten, von denen jede lautet:

true wenn die entsprechenden Elemente gleich sind.
false wenn die entsprechenden Elemente nicht gleich sind.

Hinweise

Der erste Vorlagenoperator gibt ein Objekt der Klasse valarray<bool>zurück, dessen Elemente I jeweils sind left[I] == right[I]. Der zweite Vorlagenoperator speichert left[I] == right im Element I. Der dritte Vorlagenoperator wird im Element Igespeichertleft == right[I].

Beispiel

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

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

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

   cout << "The initial Left 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;

   vaNE = ( vaL == vaR );
   cout << "The element-by-element result of "
        << "the equality comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the equality comparison test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator^`

Ruft das bitweise exklusive OR (XOR) zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem valarray und einem angegebenen Wert des Elementtyps ab.

template <class Type>
valarray<Type>
operator^(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator^(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator^(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren jeweilige Elemente mit dem bitweisen XOR kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der mit einem bitweisen XOR mit jedem Element eines Elements valarraykombiniert werden soll.

right
Die zweite der beiden valarray Objekte, deren jeweilige Elemente mit dem bitweisen XOR kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der mit einem bitweisen XOR mit jedem Element eines Elements valarraykombiniert werden soll.

Rückgabewert

A valarray , dessen Elemente die elementweise Kombination der bitweisen XOR-Operation von left und right.

Hinweise

Der bitweise exklusive OR (XOR) hat die folgende Semantik: Bestimmte Bits b1 und b2, b1 XOR b2 ist 1, wenn genau eines der Bits 1 ist; 0, wenn beide Bits 0 sind oder beide Bits 1 sind.

Beispiel

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

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

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaLAA ( 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 Left 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;

   vaLAA = ( vaL ^ vaR );
   cout << "The element-by-element result of "
        << "the bitwise XOR operator^ is the\n"
        << "valarray: ( ";
           for ( i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The initial 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 den bitweisen OR zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem und einem valarray angegebenen Wert des Elementtyps ab.

template <class Type>
valarray<Type>
operator|(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator|(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator|(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Die ersten der beiden valarray Objekte, deren jeweilige Elemente mit dem bitweisen OR kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der durch bitweise ODER mit jedem Element eines Elements valarraykombiniert werden soll.

right
Die zweite der beiden valarray Objekte, deren jeweilige Elemente mit dem bitweisen OR kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der durch bitweise ODER mit jedem Element eines Elements valarraykombiniert werden soll.

Rückgabewert

A valarray , dessen Elemente die elementweise Kombination der bitweisen OR-Operation von left und right.

Hinweise

Die bitweise ODER hat dieselbe Wahrheitstabelle wie die logische ODER, gilt jedoch für den Datentyp auf der Ebene der einzelnen Bits. Bei bestimmten Bits b1 und b2 ist b1 ODER b2 1, wenn mindestens eines der Bits 1 oder 0 ist, wenn beide Bits 0 sind. The logical OR operator|| applies on an element level, counting all nonzero values as true, and the result is a valarray of Boolean values. Das bitweise ODER operator|kann im Gegensatz dazu zu einem valarray anderen Wert als 0 oder 1 führen, je nach Ergebnis des bitweisen Vorgangs.

Beispiel

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

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

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaLAA ( 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 Left 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;

   vaLAA = ( vaL | vaR );
   cout << "The element-by-element result of "
        << "the bitwise OR operator| is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The initial 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||`

Ruft das logische OR zwischen den entsprechenden Elementen von zwei objekten gleicher Größe valarray oder zwischen einem und einem valarray angegebenen Wert des valarray Elementtyps ab.

template <class Type>
valarray<bool>
operator||(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator||(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator||(
    const Type& left,
    const valarray<Type>& right);

Parameter

left
Der erste der beiden valarray Objekte, deren jeweilige Elemente mit dem logischen OR kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der mit jedem Element eines Elements valarraykombiniert werden soll.

right
Die zweite der beiden valarray Objekte, deren jeweilige Elemente mit dem logischen OR kombiniert werden sollen, oder ein angegebener Wert des Elementtyps, der mit jedem Element eines Elements valarraykombiniert werden soll.

Rückgabewert

A valarray , dessen Elemente vom Typ bool sind und die elementweise Kombination der logischen OR-Operation von left und right.

Hinweise

The logical OR operator|| applies on an element level, counting all nonzero values as true, and the result is a valarray of Boolean values. Die bitweise Version von OR operator|kann dagegen abhängig vom Ergebnis des bitweisen Vorgangs zu einem valarray anderen Wert als 0 oder 1 führen.

Beispiel

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

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

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaLOR ( 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 += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  0;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  0;

   cout << "The initial Left 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;

   vaLOR = ( vaL || vaR );
   cout << "The element-by-element result of "
        << "the logical OR operator|| is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaLOR [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The initial Right valarray is: ( 0 0 0 3 0 0 6 0 0 9 ).
The element-by-element result of the logical OR operator|| is the
valarray: ( 0 0 0 1 0 1 1 1 0 1 ).

Freigeben über

<valarray> betriebspersonal

operator!=

Parameter

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

Hinweise

Beispiel

operator>>

Parameter

Rückgabewert

Hinweise

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+

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

Hinweise

Beispiel

operator|

`<valarray>` betriebspersonal

`operator!=`

`operator%`

`operator&`

`operator&&`

`operator>`

`operator>=`

`operator>>`

`operator<`

`operator<=`

`operator<<`

`operator*`

`operator+`

`operator-`

`operator/`

`operator==`

`operator^`

`operator|`

`operator||`