`valarray` クラス

[アーティクル]
07/19/2022

クラステンプレート valarray<Type> は、配列として格納され、高速な数学演算用に設計され、計算パフォーマンス用に最適化された型 Type の要素のシーケンスを制御するオブジェクトを記述します。

注釈

このクラスは、順序付けられた値のセットの数学的概念を表します。その要素には、0 から順番に番号が付けられます。クラスは、一部 (すべてではない) の一部のシーケンスコンテナー (たとえば、サポート) の機能をサポートするため、近いコンテナーとして vector記述されます。これは、次の 2 つの重要な方法でクラステンプレート vector とは異なります。

これは、同じ型と長さのオブジェクトの対応する要素間の valarray<Type> 多くの算術演算を varr_x* = cos(varr_y) + sin(varr_z)定義します。
オーバーロードによってオブジェクトを下書き valarray<Type> するさまざまな興味深い方法を定義します operator[]。

クラス Type のオブジェクト:

従来の動作で、パブリックな既定のコンストラクター、デストラクター、コピーコンストラクター、および代入演算子が用意されています。
従来の動作で、必要に応じて浮動小数点型に対して定義される算術演算子と数学関数を定義します。

特に、コピーによる構築と、代入に先行する既定の構築の間に、微妙な違いはありません。 Type クラスのオブジェクトの演算では例外がスローされない場合があります。

メンバー

コンストラクター

名前	説明
`valarray`	特定のサイズの、または特定の値の要素を持つ `valarray` を構築します。また、他の `valarray` のコピーやサブセットとして `valarray` を構築します。

Typedefs

名前	説明
`value_type`	`valarray` 内に格納された要素の型を表す型。

関数

名前	説明
`apply`	`valarray` 内の各要素に対して指定された関数を適用します。
`cshift`	指定された位置数で、`valarray` 内のすべての要素を周期的にシフトします。
`free`	`valarray` によって使用されるメモリを解放します。
`max`	`valarray` 内の最大要素を検索します。
`min`	`valarray` 内の最小要素を検索します。
`resize`	必要に応じて要素を追加または削除して、`valarray` 内の要素数を指定された数に変更します。
`shift`	`valarray` 内のすべての要素を指定された位置数だけシフトします。
`size`	`valarray` 内の要素数を検索します。
`sum`	`valarray` 内にある長さが 0 以外の要素すべての合計を求めます。
`swap`

演算子

名前	説明
`operator!`	内の各要素`valarray`の論理 NOT (`!`) 値を取得する単項演算子。
`operator%=`	指定された `valarray` または要素型の値で配列の要素を要素ごとに除算した剰余を取得します。
`operator&=`	配列内の要素のビットごとの AND (`&`) を、指定された `valarray` 要素内の対応する要素または要素型の値で取得します。
`operator>>=`	`valarray` オペランドの各要素のビットを、指定された位置数だけ右にシフトさせるか、2 番目の `valarray` で指定された要素ごとの量だけ右にシフトさせます。
`operator<<=`	`valarray` オペランドの各要素のビットを、指定された位置数だけ左にシフトさせるか、2 番目の `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`または値を持つ a `valarray` のビットごとの排他的または (`^`) を取得します。
`operator\|=`	配列内の要素のビットごとの OR (`\|`) を、指定された `valarray` 要素内の対応する要素または要素型の値で取得します。
`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要素。

注釈

メンバー関数は、長さのsizeクラスvalarray<Type>のオブジェクトを返します。各要素elemが結果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 の要素のペアに対して operator< または operator> を適用して値を比較します。そのため、要素 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内の要素の最小値。

注釈

例

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

内の各要素valarrayの論理 NOT (!) 値を取得する単項演算子。

valarray<bool> operator!() const;

戻り値

valarrayオペランドvalarrayの要素値の論理否定であるブール値。

注釈

論理演算 NOT は、 !0 以外のすべての値を 0 以外の値 true に変換するため、要素を論理的に false否定します。ブール値の戻り 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のvalarray要素ごとの除算の剰余である要素を指定しますright。

例

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

配列内の要素のビットごとの AND (&) を、指定された valarray 要素内の対応する要素または要素型の値で取得します。

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

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

パラメーター

right
valarrayビットごとの AND (&) とオペランドで結合されるオペランドvalarrayと同一の要素型のvalarray値。

戻り値

valarrayその要素がオペランドvalarrayのビットごとの AND (&) であるright

注釈

ビットごとの演算は、整数データ型のビットを操作する場合にのみ使用できます。たとえばcharint、これは、より複雑なデータ型、、voidlong doubleboolまたは他のデータ型では機能floatdoubleしません。

ビットごとの AND (&) は、個々のビットのレベルのデータ型に適用されます。ビットと、b1 & b2両方のb2ビットb1が 1 の場合は 1、少なくとも 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 オペランドの各要素のビットを、指定された位置数だけ右にシフトさせるか、2 番目の valarray で指定された要素ごとの量だけ右にシフトさせます。

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

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

パラメーター

right
右シフトの量を示す値、または valarray 要素が右シフトの要素ごとの量を示す値。

戻り値

で valarray 指定した right量を右にシフトした要素。

注釈

符号付きの数値の符号は保持されます。

例

// 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 オペランドの各要素のビットを、指定された位置数だけ左にシフトさせるか、2 番目の valarray で指定された要素ごとの量だけ左にシフトさせます。

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

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

パラメーター

right
左シフトの量を示す値、またはその valarray 要素が左シフトの要素ごとの量を示す値。

戻り値

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オペランドvalarrayの要素ごとの積である要素を持つ要素と right.

例

// 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その要素がオペランドvalarrayと right.

例

// 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オペランドvalarrayと right.

例

// 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オペランドvalarrayの要素ごとの商を 1 で除算した要素を持つ値を指定しますright。

例

// 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 によって制御されるシーケンスのコピーと置き換えます。

2 番目のメンバー演算子は最初のメンバー演算子と同じですが、右辺値参照宣言子を使用します &&。

3 番目のメンバー演算子は、被制御シーケンスの各要素を val のコピーと置き換えます。

残りのメンバー演算子は、被制御シーケンスの、それぞれの引数で選択される要素を置き換えます。これらは 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発生します。詳細については、「Checked Iterators」を参照してください。

例

宣言して使用operator[]するslice::slice方法の例とgslice::gslice例を参照してください。

`operator^=`

要素型の指定valarrayまたは値を持つ a valarray のビットごとの排他的または (^) を取得します。

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

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

パラメーター

right
valarrayビットごとの排他的演算子または (XOR) 演算子 (^) とオペランドで結合されるオペランドvalarrayと同じ要素型のvalarray値。

戻り値

A valarray whose elements are the bitwise exclusive or (XOR) of the operand valarray and right.

注釈

ビットごとの排他的または XOR と呼ばれ、演算子 ^で示されるセマンティクスは次のとおりです。指定されたビット b1 と b2、 b1 ^ b2 要素の 1 つが 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|=`

配列内の要素のビットごとの OR (|) を、指定された valarray 要素内の対応する要素または要素型の値で取得します。

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

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

パラメーター

right
valarrayビットごとの OR (|) valarrayとオペランドで結合されるオペランドvalarrayと同一の要素型の値。

戻り値

オペランドの valarray 要素ごとのビットごとの OR (|) である要素を valarray 指定します right。

注釈

ビットごとの演算は、整数データ型charintのビットを操作する場合にのみ使用できます。これは、より複雑なデータ型、、voidlong doubleboolまたは他のデータ型では機能floatdoubleしません。

ビットごとの OR (|) は、個々のビットのレベルのデータ型に適用されます。ビットb1のb2b1 | b2少なくとも 1 つが 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の要素値の単項ビットごとの補数である値の値。

注釈

ビットごとの演算では、整数型のビットのみを操作できます。たとえばcharint、これは、より複雑なデータ型、、voidlong doubleboolまたは他のデータ型では機能floatdoubleしません。

単項ビットごとの補数演算子 ~ は、個々のビットのレベルでデータ型に適用されます。 bビットを指定すると、 ~b 0 の場合bは 1、1 の場合bは 0 です。

例

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

a 内の要素の数を valarray 指定した数に変更します。

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

パラメーター

new_size
サイズ変更された valarray要素の数。

val
サイズ変更された valarray要素に指定する値。

注釈

1 つ目のメンバー関数は、既定のコンストラクターを使用して要素を初期化します。

制御されるシーケンス内の要素へのすべてのポインターまたは参照は無効になります。

例

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`

a valarray 内のすべての要素を指定した数だけシフトします。

valarray<Type> shift(int count) const;

パラメーター

count
要素を前方向へシフトする位置数。

戻り値

オペランドvalarray内の位置と比較すると、すべての要素が前方valarrayまたは左方向に移動countされた新しいvalarray要素。

注釈

count に正の値を指定すると、要素の位置は count 個分、左方向へシフトし、ゼロ埋め込みが行われます。

count に負の値を指定すると、要素の位置は count 個分、右方向へシフトし、ゼロ埋め込みが行われます。

例

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

valarray 内にある長さが 0 以外の要素すべての合計を求めます。

Type sum() const;

戻り値

オペランド valarrayの要素の合計。

注釈

長さが 1 より大きい場合、メンバー関数は、クラスの要素のペア間で適用 operator+= することで、合計に値を追加します Type。これは、型 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`

2 つの valarray オブジェクトの要素を交換します。

void swap(valarray& right);

パラメーター

right
交換する要素を提供する valarray。

注釈

このメンバー関数は、*this と right の間で被制御シーケンスを交換します。定数時間で実行され、例外はスローされません。また、2 つの被制御シーケンス内の要素への参照、ポインター、反復子は無効になりません。

`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に初期化します。次の 3 つのコンストラクターはそれぞれ、次のようにオブジェクトを要素の 1 count つにvalarray初期化します。

明示的な valarray(size_t count) の場合、各要素は既定のコンストラクターで初期化されます。
valarray(const Type& val, count) の場合、各要素は val で初期化されます。
の場合 valarray(const Type* ptr, count)、位置 I の要素は . で ptr[I]初期化されます。

残りの各コンストラクターは、 valarray<Type> 引数で指定されたサブセットによって決定されたオブジェクトに対してオブジェクトを初期化します。

最後のコンストラクターは次のコンストラクターと同じですが、右辺値参照宣言子を使用します &&。

例

// 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 decalared 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 decalared value_type Right is: 10
The resulting valarray is:  ( 0 -10 20 -10 40 -10 60 -10 80 -10 ).

valarray クラス

注釈

メンバー

コンストラクター

Typedefs

関数

演算子

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`