`valarray` クラス

[アーティクル]
08/04/2024

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

解説

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

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

クラス 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`または要素型の値を持つ`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の要素に要素単位で適用function_object要素を持つvalarray。

解説

メンバー関数は、長さsizeのクラス valarray<Type>のオブジェクトを返します。各要素elemfunction_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の前count向かって循環的に移動されるか、オペランド valarray内の位置と比較して左方向に移動された新しい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 は、 !で示され、要素を論理的に否定します。これは、すべてのゼロ値を true に変換し、0 以外のすべての値を 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を要素単位で除算します。

戻り値

rightによってvalarrayオペランドの要素ごとの除算からの剰余である要素を持つvalarray。

例

// 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
ビットごとの AND (&) とオペランドvalarrayで結合されるオペランドvalarrayと同じ要素型のvalarrayまたは値。

戻り値

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

解説

ビットごとの演算は、 char や intなどの整数データ型のビットを操作する場合にのみ使用できます。 float、double、long double、void、bool、その他の複雑なデータ型では機能しません。

ビットごとの AND (&) は、個々のビットのレベルのデータ型に適用されます。ビット b1 と b2では、両方のビットが 1 の場合、 b1 & b2 は 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 。

戻り値

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

例

// 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とrightの要素ごとの合計を要素とするvalarray。

例

// 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とrightの要素ごとの差を要素とするvalarray。

例

// 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に分割します。

戻り値

オペランドの要素ごとの商を要素とするvalarrayvalarrayrightで除算されます。

例

// 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
オペランド valarrayにコピーするslice_array。

gslicearray
オペランド valarrayにコピーするgslice_array。

maskarray
オペランド valarrayにコピーするmask_array。

indarray
オペランド valarrayにコピーするindirect_array。

戻り値

最初のメンバー演算子は、被制御シーケンスを right によって制御されるシーケンスのコピーに置き換えます。

2 番目のメンバー演算子は最初のメンバー演算子と同じですが、 Rvalue 参照宣言子 : &&。

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
選択または新しいvalarrayに返されるサブセットを指定するvalarrayのslice_array。

gslicearray
選択または新しいvalarrayに返されるサブセットを指定するvalarrayのgslice_array。

boolarray
選択または新しいvalarrayに返されるサブセットを指定するvalarrayのbool_array。

indarray
選択または新しいvalarrayに返されるサブセットを指定するvalarrayのindirect_array。

戻り値

指定されたインデックスまたは指定されたサブセットにある、要素またはその値への参照。

解説

メンバー演算子は、 *thisによって制御される要素の中から要素のシーケンスを選択するいくつかの方法を提供するためにオーバーロードされます。 5 つのメンバー演算子の最初のグループは、 operator= のさまざまなオーバーロード (およびその他の代入演算子) と連携して、制御シーケンスの選択的置換 (インスタンス化) を可能にします。選択された要素は存在していなければなりません。

1 または 2 として定義された _ITERATOR_DEBUG_LEVEL を使用してコンパイルすると、 valarrayの範囲外の要素にアクセスしようとすると、ランタイムエラーが発生します。詳細については、「Checked Iterators」を参照してください。

例

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

`operator^=`

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

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

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

パラメーター

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

戻り値

オペランドvalarrayおよびrightのビットごとの排他的または (XOR) 要素を持つvalarray。

解説

ビットごとの排他的、または XOR と呼ばれ、演算子 ^で示されるセマンティクスがあります。ビット b1 と b2を指定すると、要素の 1 つが 1 の場合は b1 ^ b2 が 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
ビットごとの OR (|) とオペランド valarrayで結合されるオペランドvalarrayと同じ要素型のvalarrayまたは値。

戻り値

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

解説

ビットごとの OR (|) は、個々のビットのレベルのデータ型に適用されます。ビット b1 と b2を指定すると、少なくとも 1 つのビットが 1 の場合は b1 | b2 が 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などの整数型のビットのみを操作できます。 float、double、long double、void、bool、その他の複雑なデータ型では機能しません。

単項ビットごとの補数演算子 ~ は、個々のビットのレベルのデータ型に適用されます。ビット bでは、bが 0 の場合は ~b が 1、bが 1 の場合は 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`

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`

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

valarray<Type> shift(int count) const;

パラメーター

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

戻り値

すべての要素がvalarrayの前面count位置に移動されるか、オペランド valarray内の位置と比較して左に移動された新しい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 より大きい場合、メンバー関数は、クラス 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`

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
構築されるvalarrayの要素の初期化に使用される要素値を持つslice_array。

gsliceArray
構築されるvalarrayの要素の初期化に使用される要素値を持つgslice_array。

maskArray
構築されるvalarrayの要素の初期化に使用される要素値を持つmask_array。

indArray
構築されるvalarrayの要素の初期化に使用される要素値を持つindirect_array。

iList
コピーする要素を含む initializer_list。

解説

最初の (既定の) コンストラクターは、空の valarrayにオブジェクトを初期化します。次の 3 つのコンストラクターはそれぞれ、次のようにオブジェクトをcount要素のvalarrayに初期化します。

明示的な 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 ).

次の方法で共有

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`