`<valarray>` 연산자

아티클
10/12/2023

`operator!=`

동일한 크기의 valarray 두 개체의 해당 요소가 같지 않은지 또는 모든 요소가 valarray 지정된 값과 같지 않은지 테스트합니다.

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

매개 변수

left
valarray 요소가 다른 valarray 개체와 같지 않은지 테스트하거나 요소 형식의 값을 테스트하여 요소의 각 요소와 비교할 개체입니다valarray.

right
valarray 요소가 다른 valarray 개체와 같지 않은지 테스트하거나 요소 형식의 값을 테스트하여 요소의 각 요소와 비교할 개체입니다valarray.

반환 값

valarray 부울 값 중 각각은 다음과 같습니다.

true 해당 요소가 같지 않으면
false 해당 요소가 같으면 입니다.

설명

첫 번째 템플릿 연산자는 각 요소가 I 클래스valarray<bool>의 개체를 반환합니다left[I] != right[I].

두 번째 템플릿 연산자는 요소I에 저장 left[I] != right 됩니다.

세 번째 템플릿 연산자는 요소I에 저장 left != right[I] 됩니다.

예시

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

같게 크기가 같은 valarray 두 개체의 해당 요소를 나누거나 지정된 값으로 나누 valarray 거나 지정된 값을 valarray1로 나누는 나머지를 가져옵니다.

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

매개 변수

left
다른 값 또는 valarray 분할할 배당금 역할을 하는 값입니다 valarray .

right
다른 값 또는 다른 값을 나누는 값 또는 valarray valarray수수 역할을 하는 값입니다.

반환 값

valarray 요소가 요소 단위로 나뉘right어 있는 나머지 요소입니다left.

예시

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

같은 크기의 valarray 두 개체의 해당 요소 간 또는 요소 형식의 a valarray 와 지정된 값 사이에 비트 AND를 가져옵니다.

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

매개 변수

left
해당 요소가 비트 AND와 결합되거나 비트 AND로 결합될 요소 형식의 지정된 값과 각 요소를 결합할 두 valarray 개체 중 첫 번째 개체입니다 valarray.

right
해당 요소가 비트 AND와 결합되거나 비트 AND로 결합될 요소 형식의 지정된 값과 각 요소를 결합할 두 개체 중 두 valarray 번째 개체입니다 valarray.

Return Value

valarray 요소의 비트 AND 연산 left 과 right.

설명

비트 연산은 비트 및 데이터 형식 및 int 변형을 조작 char 하는 데만 사용할 수 있으며 , , doublelong double또는 bool void기타 더 복잡한 데이터 형식에는 float사용할 수 없습니다.

비트 AND는 논리적 AND와 같은 진리표를 포함하지만 개별 비트 수준에서 데이터 형식에 적용됩니다. 요소 operator&& 수준에 적용되며 모든 0이 아닌 값은 부울 값으로 truevalarray 계산됩니다. 반면 비트 AND operator&는 비트 연산의 결과에 따라 0 또는 1이 아닌 값이 발생할 valarray 수 있습니다.

예시

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

동일한 크기의 valarray 두 개체의 해당 요소 간 또는 요소 형식의 지정된 valarray 값 간에 논리 AND를 valarray 가져옵니다.

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

매개 변수

left
해당 요소가 논리 AND와 결합되거나 요소 형식의 지정된 값을 각 요소와 결합할 두 valarray 개체 중 첫 번째 개체입니다 valarray.

right
해당 요소가 논리 AND와 결합되거나 요소 형식의 지정된 값을 각 요소와 결합할 두 개체 valarray 중 두 번째 개체입니다 valarray.

반환 값

valarray 해당 요소가 형식 bool 이며 논리 AND 연산 left 과 right.의 요소별 조합인 A.

설명

논리 AND operator&& 는 0이 아닌 모든 값을 true계산하여 요소 수준에 적용되며 결과는 부울 값입니다 valarray . 반면 AND operator&의 비트 버전은 비트 연산의 결과에 따라 0 또는 1 이외의 값이 발생할 valarray 수 있습니다.

예시

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

하나의 valarray 요소가 같은 크기의 valarray요소보다 큰지 또는 모든 요소가 valarray 지정된 값보다 크거나 작은지 테스트합니다.

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

매개 변수

left
요소를 비교할 두 valarray 개체의 첫 번째 개체 또는 각 요소와 비교할 지정된 값입니다 valarray.

right
요소를 비교해야 하는 두 개체 중 두 valarray 번째 개체이거나, 각 요소와 비교할 지정된 값입니다 valarray.

반환 값

valarray 부울 값 중 각각은 다음과 같습니다.

true 요소 또는 값이 left 해당 right 요소 또는 값보다 크면 입니다.
false 요소 또는 값이 left 해당 right 요소 또는 값보다 크지 않으면 입니다.

설명

두 valarray 개체의 요소 수가 같지 않으면 결과가 정의되지 않습니다.

예시

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

하나의 valarray 요소가 같은 크기의 valarray요소보다 크거나 같은지 또는 모든 요소가 valarray 지정된 값보다 크거나 같은지 또는 같은지 테스트합니다.

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

매개 변수

left
요소를 비교할 두 valarray 개체의 첫 번째 개체 또는 각 요소와 비교할 지정된 값입니다 valarray.

right
요소를 비교해야 하는 두 개체 중 두 valarray 번째 개체이거나, 각 요소와 비교할 지정된 값입니다 valarray.

반환 값

valarray 부울 값 중 각각은 다음과 같습니다.

true 요소 또는 값이 left 해당 right 요소 또는 값보다 크거나 같으면 입니다.
false 요소 또는 값이 left 해당 right 요소 또는 값보다 작으면 입니다.

설명

두 valarray 개체의 요소 수가 같지 않으면 결과가 정의되지 않습니다.

예시

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

지정된 위치 수의 valarray 각 요소에 대한 비트 또는 1초 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);

매개 변수

left
이동할 값 또는 valarray 요소를 이동할 값입니다.

right
오른쪽 시프트의 양을 나타내는 값이거나 valarray 요소에서 오른쪽 시프트의 요소 단위 양을 나타내는 값입니다.

반환 값

valarray 지정된 양만큼 요소가 오른쪽으로 이동된 요소입니다.

설명

부호 있는 숫자의 부호는 유지됩니다.

예시

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

하나의 valarray 요소가 같은 크기의 valarray요소보다 작은지 또는 모든 요소가 valarray 지정된 값보다 크거나 작은지 테스트합니다.

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

매개 변수

left
요소를 비교할 두 valarray 개체의 첫 번째 개체 또는 각 요소와 비교할 지정된 값입니다 valarray.

right
요소를 비교해야 하는 두 개체 중 두 valarray 번째 개체이거나, 각 요소와 비교할 지정된 값입니다 valarray.

반환 값

valarray 부울 값 중 각각은 다음과 같습니다.

true 요소 또는 값이 left 해당 right 요소 또는 값보다 작으면 입니다.
false 요소 또는 값이 left 해당 right 요소 또는 값보다 작지 않으면 입니다.

설명

두 valarray 개체의 요소 수가 같지 않으면 결과가 정의되지 않습니다.

예시

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

하나의 valarray 요소가 같은 크기의 valarray요소보다 작거나 같은지 또는 모든 요소가 valarray 지정된 값보다 크거나 같은지 또는 같은지 테스트합니다.

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

매개 변수

left
요소를 비교할 두 valarray 개체의 첫 번째 개체 또는 각 요소와 비교할 지정된 값입니다 valarray.

right
요소를 비교해야 하는 두 개체 중 두 valarray 번째 개체이거나, 각 요소와 비교할 지정된 값입니다 valarray.

반환 값

valarray 부울 값 중 각각은 다음과 같습니다.

true 요소 또는 값이 left 해당 right 요소 또는 값보다 작거나 같으면 입니다.
false 요소 또는 값이 left 해당 right 요소 또는 값보다 크면 입니다.

설명

두 valarray 개체의 요소 수가 같지 않으면 결과가 정의되지 않습니다.

예시

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

왼쪽은 지정된 위치 수의 각 요소에 valarray 대한 비트 또는 1초 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);

매개 변수

left
이동할 값 또는 valarray 요소를 이동할 값입니다.

right
왼쪽 시프트의 양을 나타내는 값이거나 valarray 요소 단위의 왼쪽 시프트 양을 나타내는 요소입니다.

반환 값

valarray 지정된 양만큼 요소를 왼쪽으로 이동한 요소입니다.

설명

부호 있는 숫자의 부호는 유지됩니다.

예시

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

동일한 크기의 valarray 두 개체의 해당 요소 간 또는 a 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);

매개 변수

left
요소를 곱해야 하는 두 valarray 개체 중 첫 번째 개체이거나 지정된 값을 각 요소와 곱할 수 있습니다 valarray.

right
요소를 곱해야 하는 두 개체 중 두 valarray 번째 개체이거나 지정된 값을 각 요소와 곱할 수 있습니다 valarray.

반환 값

valarray 요소가 요소별 곱 left 이고 right.

예시

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

동일한 크기의 valarray 두 개체의 해당 요소 간 또는 a 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);

매개 변수

left
요소를 추가할 두 valarray 개체 중 첫 번째 개체이거나, 각 요소와 함께 추가할 지정된 값입니다 valarray.

right
요소를 추가할 두 개체 중 두 valarray 번째 개체이거나, 각 요소에 추가할 지정된 값입니다 valarray.

반환 값

valarray 요소가 요소 단위의 합계 left 이고 .right

예시

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

크기가 같은 valarray 두 개체의 해당 요소 간 또는 a 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);

매개 변수

left
차이를 형성할 때 다른 값이나 개체를 빼야 하는 값 또는 valarray 미누엔드 역할을 하는 값 valarray 입니다.

right
차액을 형성하는 다른 값이나 valarray 개체에서 빼야 하는 값 또는 valarray 하위 컨트롤 역할을 하는 값입니다.

반환 값

valarray 요소와 요소의 차이점이 있는 요소입니다 left right.

설명

빼기를 설명하는 데 사용되는 산술 용어입니다.

차 = 피감수 - 감수

예시

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

같은 크기의 valarray 두 개체의 해당 요소 간 또는 a 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);

매개 변수

left
다른 값 또는 valarray 몫을 형성하여 나눌 배당의 역할을 하는 값 valarray 입니다.

right
다른 값을 나누거나 valarray 몫을 형성하는 값 또는 valarray 수수 역할을 하는 값입니다.

반환 값

valarray 요소가 요소 단위로 나뉘right는 몫인 요소입니다left.

설명

나누기를 설명하는 데 사용되는 산술 용어입니다.

몫 = 피제수/제수

예시

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

크기가 같은 valarray 두 개체의 해당 요소가 같은지 또는 모든 요소가 valarray 지정된 값과 같은지 여부를 테스트합니다.

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

매개 변수

left
요소가 같은지 테스트해야 하는 두 valarray 개체 중 첫 번째 개체이거나 각 valarray 요소와 비교할 지정된 값입니다.

right
요소가 같은지 테스트해야 하는 두 개체 중 두 valarray 번째 개체이거나 각 valarray 요소와 비교할 지정된 값입니다.

Return Value

valarray 부울 값 중 각각은 다음과 같습니다.

true 해당 요소가 같으면 입니다.
false 해당 요소가 같지 않으면 입니다.

설명

첫 번째 템플릿 연산자는 각 요소가 I 클래스valarray<bool>의 개체를 반환합니다left[I] == right[I]. 두 번째 템플릿 연산자는 요소I에 저장 left[I] == right 됩니다. 세 번째 템플릿 연산자는 요소I에 저장 left == right[I] 됩니다.

예시

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

동일한 크기의 valarray 두 개체의 해당 요소 간 또는 요소 형식의 지정된 valarray 값 간에 XOR(비트 배타적 OR)를 가져옵니다.

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

매개 변수

left
해당 요소가 비트 XOR와 결합되어야 하는 두 valarray 개체 중 첫 번째 개체이거나, 비트 XOR에 의해 결합될 요소 형식의 valarray지정된 값과 각 요소를 결합합니다.

right
각 요소를 비트 XOR와 결합하거나 비트 XOR로 결합할 요소 형식의 지정된 값을 각 요소와 결합할 두 개체 중 두 valarray 번째 개체입니다 valarray.

반환 값

valarray 요소의 비트 XOR 연산 left 과 right.

설명

XOR(비트 배타적 OR)에는 다음 의미 체계가 있습니다. 지정된 비트 b1 및 b2, b1 XOR b2는 정확히 비트 중 하나가 1이면 1이고, 두 비트가 0이거나 두 비트가 1이면 0입니다.

예시

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

크기가 같은 valarray 두 개체의 해당 요소 간 또는 요소 형식의 지정된 valarray 값 사이에 비트 OR을 가져옵니다.

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

매개 변수

left
해당 요소가 비트 OR과 결합되어야 하는 두 valarray 개체 중 첫 번째 개체이거나, 비트 OR로 결합할 요소 형식의 지정된 값과 각 요소를 결합 valarray합니다.

right
해당 요소가 비트 OR과 결합되어야 하는 두 valarray 개체 중 두 번째 개체이거나, 비트 OR로 결합할 요소 형식의 지정된 값을 해당 요소의 valarray각 요소와 결합합니다.

반환 값

valarray 요소의 비트 OR 연산 left 과 right.

설명

비트 OR에는 논리 OR과 동일한 진리 테이블이 있지만 개별 비트 수준의 데이터 형식에 적용됩니다. 지정된 비트 b1 및 b2, b1 또는 b2는 비트 중 하나 이상이 1이면 1이고, 두 비트가 모두 0이면 0입니다. 논리 OR operator|| 은 요소 수준에 적용되어 모든 0이 아닌 값을 계산 true하며 결과는 부울 값입니다 valarray . 반면 비트 OR operator|는 비트 연산의 결과에 따라 0 또는 1이 아닌 값이 발생할 valarray 수 있습니다.

예시

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

동일한 크기의 valarray 두 개체의 해당 요소 간 또는 요소 형식의 지정된 valarray 값 간에 논리적 OR을 valarray 가져옵니다.

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

매개 변수

left
해당 요소가 논리 OR과 결합되거나 요소 형식의 지정된 값을 각 요소와 결합할 두 valarray 개체 중 첫 번째 개체입니다 valarray.

right
해당 요소가 논리 OR과 결합되거나 요소 형식의 지정된 값을 각 요소와 결합할 두 개체 valarray 중 두 번째 개체입니다 valarray.

반환 값

해당 요소가 형식 bool 이며 논리 OR 연산 left 과 right.의 요소별 조합인 Avalarray.

설명

논리 OR operator|| 은 요소 수준에 적용되어 모든 0이 아닌 값을 계산 true하며 결과는 부울 값입니다 valarray . 반면 OR operator|의 비트 버전은 비트 연산의 결과에 따라 0 또는 1이 아닌 값이 발생할 valarray 수 있습니다.

예제

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

다음을 통해 공유

<valarray> 연산자

operator!=

매개 변수

반환 값

설명

예시

operator%

매개 변수

반환 값

예시

operator&

매개 변수

Return Value

설명

예시

operator&&

매개 변수

반환 값

설명

예시

operator>

매개 변수

반환 값

설명

예시

operator>=

매개 변수

반환 값

설명

예시

operator>>

매개 변수

반환 값

설명

예시

operator<

매개 변수

반환 값

설명

예시

operator<=

매개 변수

반환 값

설명

예시

operator<<

매개 변수

반환 값

설명

예시

operator*

매개 변수

반환 값

예시

operator+

매개 변수

반환 값

예시

operator-

매개 변수

반환 값

설명

예시

operator/

매개 변수

반환 값

설명

예시

operator==

매개 변수

Return Value

설명

예시

operator^

매개 변수

반환 값

설명

예시

operator|

`<valarray>` 연산자

`operator!=`

`operator%`

`operator&`

`operator&&`

`operator>`

`operator>=`

`operator>>`

`operator<`

`operator<=`

`operator<<`

`operator*`

`operator+`

`operator-`

`operator/`

`operator==`

`operator^`

`operator|`

`operator||`