`valarray` 클래스

아티클
10/12/2023

클래스 템플릿 valarray<Type> 은 배열로 저장되고, 고속 수학 연산을 위해 설계되고, 계산 성능에 최적화된 형식 Type 요소의 시퀀스를 제어하는 개체를 설명합니다.

설명

클래스는 정렬된 값 집합의 수학 개념을 나타냅니다. 해당 요소는 0부터 순차적으로 번호가 매겨집니다. 클래스는 첫 번째 클래스 시퀀스 컨테이너(예: 지원)가 지원하는 일부 기능을 지원하지만 전부는 아니므로 가까운 컨테이너로 vector설명됩니다. 다음 두 가지 중요한 방법으로 클래스 템플릿 vector 과 다릅니다.

와 같이 varr_x* = cos(varr_y) + sin(varr_z)형식과 길이가 같은 개체의 valarray<Type> 해당 요소 간에 많은 산술 연산을 정의합니다.
오버로드하여 개체를 첨 valarray<Type> 자하는 다양한 흥미로운 방법을 정의합니다 operator[].

클래스 Type의 개체:

기본 동작과 함께 공용 기본 생성자, 소멸자, 복사 생성자 및 대입 연산자를 포함합니다.
필요에 따라 기본 동작으로 부동 소수점 형식을 위해 정의된 산술 연산자 및 수학 함수를 정의합니다.

특히 복사본 생성과 뒤에 할당이 이어지는 기본 생성 간에는 차이가 없을 수도 있습니다. 클래스 Type 개체에 대한 작업은 예외를 throw할 수 없습니다.

멤버

생성자

이름	설명
`valarray`	다른 `valarray`의 복사본 또는 다른 `valarray`의 하위 집합으로서 특정 크기, 특정 값의 요소가 있는 `valarray`를 생성합니다.

Typedef

이름	설명
`value_type`	`valarray`에 저장된 요소의 형식을 나타내는 형식입니다.

함수

속성	설명
`apply`	`valarray`의 각 요소에 지정된 함수를 적용합니다.
`cshift`	`valarray`에 있는 모든 요소를 주기적으로 지정된 위치 수만큼 이동합니다.
`free`	`valarray`에서 사용하는 메모리를 비웁니다.
`max`	`valarray`에서 가장 큰 요소를 찾습니다.
`min`	`valarray`에서 가장 작은 요소를 찾습니다.
`resize`	필요에 따라 요소를 추가 또는 제거하여 `valarray`의 요소 수를 지정된 수로 변경합니다.
`shift`	`valarray`에 있는 모든 요소를 지정된 위치 수만큼 이동합니다.
`size`	`valarray`의 요소 수를 찾습니다.
`sum`	0이 아닌 길이의 `valarray`에 있는 모든 요소의 합계를 결정합니다.
`swap`

연산자

이름	설명
`operator!`	에 있는 각 요소의 논리적 NOT(`!`) 값을 가져오는 단항 연산자입니다 `valarray`.
`operator%=`	배열 요소를 요소별로 지정된 `valarray`나 요소 형식의 값으로 나눈 나머지를 가져옵니다.
`operator&=`	지정된 `valarray` 요소 또는 요소 형식의 값을 사용하여 배열에 있는 요소의 비트 AND(`&`)를 가져옵니다.
`operator>>=`	`valarray` 피연산자의 각 요소에 대한 비트를 지정된 위치 수 또는 두 번째 `valarray`에 지정된 요소 양만큼 오른쪽으로 이동합니다
`operator<<=`	`valarray` 피연산자의 각 요소에 대한 비트를 지정된 위치 수 또는 두 번째 `valarray`에 지정된 요소 양만큼 왼쪽으로 이동합니다
`operator*=`	요소별로 지정된 `valarray`의 요소나 요소 형식의 값을 피연산자 `valarray`에 곱합니다.
`operator+`	`valarray`의 각 요소에 +를 적용하는 단항 연산자입니다. 일반 산술 형식에서는 이 연산자가 적용되지 않습니다.
`operator+=`	요소별로, 지정된 `valarray`의 요소나 요소 형식의 값을 피연산자 `valarray`에 더합니다.
`operator-`	에 있는 각 요소에 산술 부정을 적용하는 단항 연산자입니다 `valarray`.
`operator-=`	요소별로, 지정된 `valarray`의 요소나 요소 형식의 값을 피연산자 `valarray`에서 뺍니다.
`operator/=`	요소별로 지정된 `valarray`의 요소나 요소 형식의 값을 피연산자 `valarray`에 나눕니다.
`operator=`	값이 직접 지정되었거나 다른 `valarray`의 일부로 지정되었거나 `slice_array`, `gslice_array`, `mask_array` 또는 `indirect_array`으로 지정된 `valarray`에 요소를 할당합니다.
`operator[]`	지정된 인덱스 또는 지정된 하위 집합에서 요소 또는 그 값에 대한 참조를 반환합니다.
`operator^=`	지정된 `valarray` 값이나 요소 형식의 `valarray` 값을 가진 비트 배타적 또는 (`^`)를 가져옵니다.
`operator\|=`	지정된 `valarray` 요소의 해당 요소를 사용하거나 요소 형식의 값을 사용하여 배열에 있는 요소의 비트 OR(`\|`)을 가져옵니다.
`operator~`	에 있는 각 요소의 비트 보수(`~`) 값을 가져오는 단항 연산자입니다 `valarray`.

`apply`

valarray의 각 요소에 지정된 함수를 적용합니다.

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

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

매개 변수

function_object(Type)
피연산자의 valarray각 요소에 적용할 함수 개체입니다.

function_object(const Type&)
피연산자의 valarray각 요소에 const 적용할 요소의 함수 개체입니다.

반환 값

valarray 피연산valarray자의 요소 function_object 에 요소를 적용한 요소입니다.

설명

멤버 함수는 각 요소가 elem 결과인 길이 valarray<Type>size클래스의 개체를 반환합니다function_object((*this)[elem]).

예시

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

valarray에 있는 모든 요소를 주기적으로 지정된 위치 수만큼 이동합니다.

valarray<Type> cshift(int count) const;

매개 변수

count
요소를 앞으로 이동할 위치 수입니다.

반환 값

피연산valarray자의 위치와 비교하여 모든 요소가 전면 valarray또는 왼쪽으로 주기적으로 위치를 이동 count 한 새 valarray 요소입니다.

설명

count 값이 양수이면 요소가 왼쪽으로 count개 위치만큼 순환 이동합니다.

count 값이 음수이면 요소가 오른쪽으로 count개 위치만큼 순환 이동합니다.

예시

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

valarray에서 사용하는 메모리를 비웁니다.

void free();

설명

이 비표준 함수는 빈 valarray함수를 할당하는 것과 같습니다. 예시:

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

// equivalent to v.free()

`max`

valarray에서 가장 큰 요소를 찾습니다.

Type max() const;

반환 값

피연산자 valarray에서 요소의 최대값입니다.

설명

멤버 함수는 요소에 대해 연산자를 제공해야 하는 클래스 Type요소 쌍 사이에 연산<자 또는 연산>자를 적용하여 Type값을 비교합니다.

예시

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

valarray에서 가장 작은 요소를 찾습니다.

Type min() const;

반환 값

피연산 valarray자에서 요소의 최소값입니다.

설명

멤버 함수는 요소에 대해 연산자를 제공해야 하는 클래스 Type요소 쌍 사이에 연산<자 또는 연산>자를 적용하여 Type값을 비교합니다.

예시

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

에 있는 각 요소의 논리적 NOT(!) 값을 가져오는 단항 연산자입니다 valarray.

valarray<bool> operator!() const;

반환 값

valarray 피연산valarray자의 요소 값에 대한 논리적 부정인 부울 값의 값입니다.

설명

로 표시된 !논리 연산 NOT은 0이 아닌 모든 값을 0이 아닌 값으로 변환하므로 요소를 논리적으로 truefalse부정합니다. 부울 값의 반환 valarray 크기는 피연산자 valarray입니다.

예시

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

배열 요소를 요소별로 지정된 valarray나 요소 형식의 값으로 나눈 나머지를 가져옵니다.

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

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

매개 변수

right
요소 형식의 값은 valarray 피연산자를 분할valarray하는 피연산자의 valarray 값과 동일합니다.

반환 값

valarray 해당 요소가 피연산자의 valarrayright요소별 나누기에서 re기본der인 경우

예시

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

지정된 valarray 요소 또는 요소 형식의 값을 사용하여 배열에 있는 요소의 비트 AND(&)를 가져옵니다.

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

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

매개 변수

right
valarray 피연산자와 비트 AND(&)로 결합할 피연산자의 valarray 값과 valarray동일한 요소 형식의 값입니다.

반환 값

valarray 해당 요소가 피연산 valarray 자의 비트 AND(&)인 경우right

설명

비트 연산은 정수 데이터 형식의 비트(예 char : 및 int)를 조작하는 데만 사용할 수 있습니다. 더 복잡한 데이터 형식, , doublelong double, voidbool또는 기타 데이터 형식에서는 float작동하지 않습니다.

비트 AND(&)는 개별 비트 수준의 데이터 형식에 적용됩니다. 지정된 비트와 b1b2두 비트가 모두 1이 b1 & b2 면 1이고, 하나 이상의 비트가 0이면 0입니다.

예시

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

valarray 피연산자의 각 요소에 대한 비트를 지정된 위치 수 또는 두 번째 valarray에 지정된 요소 양만큼 오른쪽으로 이동합니다

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

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

매개 변수

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

반환 값

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

설명

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

예시

// 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 피연산자의 각 요소에 대한 비트를 지정된 위치 수 또는 두 번째 valarray에 지정된 요소 양만큼 왼쪽으로 이동합니다

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

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

매개 변수

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

반환 값

요소가 이동된 A valarray 는 지정된 양을 right왼쪽으로 옮깁니다.

설명

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

예시

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

요소별로 지정된 valarray의 요소나 요소 형식의 값을 피연산자 valarray에 곱합니다.

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

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

매개 변수

right
요소 형식의 값 또는 valarray 피연산자를 곱valarray하는 피연산자의 valarray 값과 동일합니다.

반환 값

valarray 피연산자와 valarrayright.

예시

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

valarray의 각 요소에 +를 적용하는 단항 연산자입니다. 일반 산술 값의 경우 이 연산은 영향을 주지 않습니다.

valarray<Type> operator+() const;

반환 값

valarray 피연산자 배열의 단항 더하기 결과인 요소입니다.

예시

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

요소별로, 지정된 valarray의 요소나 요소 형식의 값을 피연산자 valarray에 더합니다.

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

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

매개 변수

right
valarray 피연산valarray자에서 요소 단위로 추가할 피연산자의 valarray 값과 동일한 요소 형식의 값입니다.

반환 값

valarray 피연산자와 valarrayright.

예시

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

에 있는 각 요소에 산술 부정을 적용하는 단항 연산자입니다 valarray.

valarray<Type> operator-() const;

반환 값

valarray 피연산valarray자의 요소에서 산술적으로 부정되는 요소입니다.

예시

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

요소별로, 지정된 valarray의 요소나 요소 형식의 값을 피연산자 valarray에서 뺍니다.

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

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

매개 변수

right
valarray 피연산자에서 요소 단위로 뺄 피연산자의 valarray 값과 동일한 요소 형식의 valarray값입니다.

반환 값

valarray 피연산자와 valarrayright.

예시

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

요소별로 지정된 valarray의 요소나 요소 형식의 값을 피연산자 valarray에 나눕니다.

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

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

매개 변수

right
요소 형식의 값은 valarray 피연산자의 피연산자 valarray 값과 동일하며 요소 단위로 피연산자 valarray로 분할됩니다.

반환 값

valarray 요소가 피연 valarrayright산자의 요소 단위 몫입니다.

예시

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

값이 직접 지정되었거나 다른 valarray의 일부로 지정되었거나 slice_array, gslice_array, mask_array 또는 indirect_array으로 지정된 valarray에 요소를 할당합니다.

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

매개 변수

right
valarray 피연산valarray자로 복사할 대상입니다.

val
피연산자의 요소에 할당할 값입니다 valarray.

slicearray
slice_array 피연산valarray자로 복사할 대상입니다.

gslicearray
gslice_array 피연산valarray자로 복사할 대상입니다.

maskarray
mask_array 피연산valarray자로 복사할 대상입니다.

indarray
indirect_array 피연산valarray자로 복사할 대상입니다.

반환 값

첫 번째 멤버 연산자는 제어되는 시퀀스를 right로 제어되는 시퀀스 복사본으로 바꿉니다.

두 번째 멤버 연산자는 첫 번째 멤버와 동일하지만 Rvalue 참조 선언자는 &&다음과 같습니다.

세 번째 멤버 연산자는 제어되는 시퀀스의 각 요소를 val의 복사본으로 바꿉니다.

re기본ing 멤버 연산자는 인수에서 선택한 제어되는 시퀀스의 해당 요소를 대체합니다. 이 요소는 해당 인수에서operator[]만 생성됩니다.

대체 제어되는 시퀀스의 구성원 값이 초기 제어되는 시퀀스의 구성원에 따라 달라지는 경우에는 결과가 정의되지 않습니다.

설명

제어되는 시퀀스의 길이가 변경되면 일반적으로 결과가 정의되지 않습니다. 그러나 이 구현에서는 단순히 제어되는 시퀀스의 요소에 대한 참조나 포인터만 무효화됩니다.

예시

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

지정된 인덱스 또는 지정된 하위 집합에서 요소 또는 그 값에 대한 참조를 반환합니다.

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;

매개 변수

index
값을 할당할 요소의 인덱스

slicearray
slice_arrayvalarray 선택하거나 새 valarray하위 집합으로 반환할 하위 집합을 지정하는 A입니다.

gslicearray
gslice_arrayvalarray 선택하거나 새 valarray하위 집합으로 반환할 하위 집합을 지정하는 A입니다.

boolarray
bool_arrayvalarray 선택하거나 새 valarray하위 집합으로 반환할 하위 집합을 지정하는 A입니다.

indarray
indirect_arrayvalarray 선택하거나 새 valarray하위 집합으로 반환할 하위 집합을 지정하는 항목입니다.

반환 값

지정된 인덱스 또는 지정된 하위 집합에서 요소 또는 그 값에 대한 참조

설명

멤버 연산자는 오버로드되어 제어되는 요소 중 *this에서 요소 시퀀스를 선택하는 여러 가지 방법을 제공합니다. 5명의 멤버 연산자의 첫 번째 그룹은 제어되는 시퀀스의 operator= 선택적 교체(조각화)를 허용하기 위해 다양한 오버로드(및 기타 할당 연산자)와 함께 작동합니다. 이 경우 선택한 요소가 있어야 합니다.

1 또는 2로 정의된 값을 사용하여 _ITERATOR_DEBUG_LEVEL 컴파일하면 런타임 오류가 발생합니다 valarray. 자세한 내용은 확인된 반복기를 참조 하세요.

예시

를 선언하고 gslice::gslice 사용하는 operator[]방법에 대한 slice::slice 예제 및 예제를 참조하세요.

`operator^=`

지정된 valarray 값이나 요소 형식의 valarray 값을 가진 비트 배타적 또는 (^)를 가져옵니다.

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

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

매개 변수

right
valarray 비트 배타적 또는 (XOR) 연산자(^)와 valarray피연산자를 결합할 피연산자의 valarray 요소 형식과 동일한 요소 형식의 값입니다.

반환 값

valarray 피연산자와 피연산 valarrayright자의 비트 배타적 요소 또는 (XOR)인 요소입니다.

설명

XOR라고 하며 연산^자로 표시된 비트 배타적 비트에는 지정된 비트 b1 와 b2b1 ^ b2 요소 중 정확히 하나가 1인 경우 1, 두 요소 모두 0 또는 1인 경우 0이라는 의미 체계가 있습니다.

예시

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

지정된 valarray 요소의 해당 요소를 사용하거나 요소 형식의 값을 사용하여 배열에 있는 요소의 비트 OR(|)을 가져옵니다.

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

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

매개 변수

right
valarray 피연산자를 사용하여 비트 OR(|)로 결합할 피연산자의 valarray 값과 valarray동일한 요소 형식의 값입니다.

반환 값

valarray 요소가 피연산 valarrayright자의 요소별 비트 OR(|)인 A입니다.

설명

비트 연산은 같은 정수 데이터 형식 charint의 비트만 조작하는 데 사용할 수 있습니다. 더 복잡한 데이터 형식, , doublelong double, voidbool또는 기타 데이터 형식에서는 float작동하지 않습니다.

비트 OR(|)는 개별 비트 수준의 데이터 형식에 적용됩니다. 지정된 비트와 b1b2비트 b1 | b2 중 하나 이상이 1이면 1이고, 두 비트가 모두 0이면 0입니다.

예시

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

에 있는 각 요소의 값에 대한 비트 보수를 가져오는 단항 연산자입니다 valarray.

valarray<Type> operator~() const;

반환 값

valarray 피연산valarray자의 요소 값에 대한 단항 비트 보수인 값의 값입니다.

설명

비트 연산은 정수 계열 형식의 비트만 조작할 수 있습니다(예: char 및 int.). 더 복잡한 데이터 형식, , doublelong double, voidbool또는 기타 데이터 형식에서는 float작동하지 않습니다.

단항 비트 보수 연산 ~ 자는 개별 비트 수준의 데이터 형식에 적용됩니다. 지정된 비트 b~b 는 0이면 b 1이고 0이면 b 1입니다.

예시

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

요소 수를 지정된 숫자로 valarray 변경합니다.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

매개 변수

new_size
크기가 조정 valarray된 요소의 수입니다.

val
크기가 조정 valarray된 요소에 부여할 값입니다.

설명

첫 번째 멤버 함수는 기본 생성자를 사용하여 요소를 초기화합니다.

제어된 시퀀스의 요소에 대한 모든 포인터 또는 참조가 무효화됩니다.

예시

다음 예제에서는 멤버 함수를 사용하는 방법을 valarray::resize 보여 줍니다.

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

int main()
{
    using namespace std;
    int i;
    size_t size1, sizeNew;

    valarray<int> va1(10);
    for (i = 0; i < 10; i+=1)
        va1[i] = i;

    cout << "The valarray contains ( ";
        for (i = 0; i < 10; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;

    size1 = va1.size();
    cout << "The number of elements in the valarray is: "
         << size1  << "." <<endl << endl;

    va1.resize(15, 10);

    cout << "The valarray contains ( ";
        for (i = 0; i < 15; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;
    sizeNew = va1.size();
    cout << "The number of elements in the resized valarray is: "
         << sizeNew  << "." <<endl << endl;
}

The valarray contains ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray is: 10.

The valarray contains ( 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 ).
The number of elements in the resized valarray is: 15.

`shift`

지정된 위치 수만큼 모든 요소를 valarray 이동합니다.

valarray<Type> shift(int count) const;

매개 변수

count
요소를 앞으로 이동할 위치 수입니다.

반환 값

피연산valarray자의 위치와 비교할 때 모든 요소가 앞쪽 valarray또는 왼쪽으로 위치를 이동 count 한 새 valarray 요소입니다.

설명

count 값이 양수이면 요소가 왼쪽으로 count개 위치만큼 이동하며 0이 채워집니다.

count 값이 음수이면 요소가 오른쪽으로 count개 위치만큼 이동하며 0이 채워집니다.

예시

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

valarray의 요소 수를 찾습니다.

size_t size() const;

반환 값

피연산 valarray자의 요소 수입니다.

예시

다음 예제에서는 멤버 함수를 사용하는 방법을 valarray::size 보여 줍니다.

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

int main()
{
    using namespace std;
    int i;
    size_t size1, size2;

    valarray<int> va1(10), va2(12);
    for (i = 0; i < 10; i += 1)
        va1[i] =  i;
    for (i = 0; i < 10; i += 1)
        va2[i] =  i;

    cout << "The operand valarray va1(10) is: ( ";
        for (i = 0; i < 10; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;

    size1 = va1.size();
    cout << "The number of elements in the valarray va1 is: va1.size = "
         << size1  << "." <<endl << endl;

    cout << "The operand valarray va2(12) is: ( ";
        for (i = 0; i < 10; i++)
            cout << va2[i] << " ";
    cout << ")." << endl;

    size2 = va2.size();
    cout << "The number of elements in the valarray va2 is: va2.size = "
         << size2  << "." << endl << endl;

    // Initializing two more elements to va2
    va2[10] = 10;
    va2[11] = 11;
    cout << "After initializing two more elements,\n"
         << "the operand valarray va2(12) is now: ( ";
        for (i = 0; i < 12; i++)
            cout << va2[i] << " ";
    cout << ")." << endl;
    cout << "The number of elements in the valarray va2 is still: "
         << size2  << "." << endl;
}

The operand valarray va1(10) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray va1 is: va1.size = 10.

The operand valarray va2(12) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray va2 is: va2.size = 12.

After initializing two more elements,
the operand valarray va2(12) is now: ( 0 1 2 3 4 5 6 7 8 9 10 11 ).
The number of elements in the valarray va2 is still: 12.

`sum`

0이 아닌 길이의 valarray에 있는 모든 요소의 합계를 결정합니다.

Type sum() const;

반환 값

피연산 valarray자 요소의 합계입니다.

설명

길이가 1보다 크면 멤버 함수는 클래스 Type요소 쌍 사이에 적용하여 operator+= 합계에 값을 추가합니다. 즉, 형식 Type의 요소에 대해 연산자를 제공해야 합니다.

예시

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

두 valarray 개체의 요소를 교환합니다.

void swap(valarray& right);

매개 변수

right
교환할 요소를 제공하는 valarray입니다.

설명

멤버 함수는 *this와 right 간에 제어된 시퀀스를 교환합니다. 이렇게 하려면 일정한 시간에 예외를 throw하지 않으며 제어되는 두 시퀀스의 요소에 대한 참조, 포인터 또는 반복기를 무효화하지 않습니다.

`valarray`

다른 valarray의 복사본 또는 다른 valarray의 하위 집합으로서 특정 크기, 특정 값의 요소가 있는 valarray를 생성합니다.

valarray();

explicit valarray(
    size_t count);

valarray(
    const Type& val,
    size_t count);

valarray(
    const Type* ptr,
    size_t count);

valarray(
    const valarray<Type>& right);

valarray(
    const slice_array<Type>& sliceArray);

valarray(
    const gslice_array<Type>& gsliceArray);

valarray(
    const mask_array<Type>& maskArray);

valarray(
    const indirect_array<Type>& indArray);

valarray(
    valarray<Type>&& tight);

valarray(
    initializer_list<Type> iList);

매개 변수

count
에 있을 valarray요소의 수입니다.

val
에서 요소를 초기화하는 데 사용할 값입니다 valarray.

ptr
에서 요소를 초기화하는 데 사용할 값에 valarray대한 포인터입니다.

right
새 valarray를 초기화할 기존 valarray .

sliceArray
slice_array 생성되는 요소를 초기화하는 데 사용할 요소 값입니다valarray.

gsliceArray
gslice_array 생성되는 요소를 초기화하는 데 사용할 요소 값입니다valarray.

maskArray
mask_array 생성되는 요소를 초기화하는 데 사용할 요소 값입니다valarray.

indArray
indirect_array 생성되는 요소를 초기화하는 데 사용할 요소 값입니다valarray.

iList
initializer_list 복사할 요소가 들어 있는 항목입니다.

설명

첫 번째(기본) 생성자는 개체를 빈 valarray값으로 초기화합니다. 다음 세 개의 생성자는 각각 다음과 같이 개체를 valarray 요소로 count 초기화합니다.

명시적 valarray(size_t count)의 경우 각 요소는 기본 생성자를 사용하여 초기화됩니다.
valarray(const Type& val, count)의 경우 각 요소는 val을 사용하여 초기화됩니다.
의 경우 valarray(const Type* ptr, count)위치 I 의 요소는 .을 사용하여 ptr[I]초기화됩니다.

각 재기본 생성자는 인수에 지정된 하위 집합에 의해 결정되는 개체로 개체 valarray<Type> 를 초기화합니다.

마지막 생성자는 마지막 다음 생성자와 동일하지만 Rvalue 참조 선언자를 &&사용합니다.

예시

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

valarray에 저장된 요소의 형식을 나타내는 형식입니다.

typedef Type value_type;

설명

이 형식은 템플릿 매개 변수 Type의 동의어입니다.

예시

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

참고 항목

C++ 표준 라이브러리의 스레드 안전성

valarray 클래스

설명

멤버

생성자

Typedef

함수

연산자

apply

매개 변수

반환 값

설명

예시

cshift

매개 변수

반환 값

설명

예시

free

설명

max

반환 값

설명

예시

min

반환 값

설명

예시

operator!

반환 값

설명

예시

operator%=

매개 변수

반환 값

예시

operator&=

매개 변수

반환 값

설명

예시

operator>>=

매개 변수

반환 값

설명

예시

operator<<=

매개 변수

반환 값

설명

예시

operator*=

매개 변수

반환 값

예시

operator+

반환 값

예시

operator+=

매개 변수

반환 값

예시

operator-

반환 값

예시

operator-=

매개 변수

반환 값

예시

operator/=

매개 변수

반환 값

예시

operator=

매개 변수

반환 값

설명

예시

operator[]

매개 변수

반환 값

`valarray` 클래스

`apply`

`cshift`

`free`

`max`

`min`

`operator!`

`operator%=`

`operator&=`

`operator>>=`

`operator<<=`

`operator*=`

`operator+`

`operator+=`

`operator-`

`operator-=`

`operator/=`

`operator=`

`operator[]`

`operator^=`

`operator|=`

`operator~`

`resize`

`shift`

`size`

`sum`

`swap`

`valarray`

`value_type`