`valarray` 类

项目
06/16/2023

类模板 valarray<Type> 描述了一个对象，该对象控制类型 Type 的元素序列，这些元素存储为数组并用于执行高速数学运算，且针对计算性能进行了优化。

备注

此类是一组有序值的数学概念表示形式。元素从 0 开始按顺序编号。此类描述为一个近容器，因为它支持一些（并非所有）第一类序列容器（如 vector）支持的功能。它在以下两个重要方面不同于类模板 vector：

它定义了具有相同类型和长度的 valarray<Type> 对象的相应元素之间的大量算术运算，例如 varr_x* = cos(varr_y) + sin(varr_z)。
通过重载 operator[]，它定义了各种下标 valarray<Type> 对象的有趣方式。

Type 类的对象：

具有公共默认构造函数、析构函数、复制构造函数、赋值运算符和常规行为。
根据需要，定义适用于浮点类型的算术运算符、数学函数和常规行为。

具体而言，复制构造和后跟分配的默认构造之间可能不存在任何细微的差异。对 Type 类的对象执行的所有操作都不会引发异常。

成员

构造函数

名称	描述
`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`	确定长度不为零的 `valarray` 中的所有元素的总和。
`swap`

运算符

名称	描述
`operator!`	一个一元运算符，该运算符获取 `valarray` 中每个元素的逻辑 NOT (`!`) 值。
`operator%=`	获取用指定 `valarray` 或元素类型的值对数组元素进行点除所得的余数。
`operator&=`	获取数组中元素的按位 AND (`&`)，该数组具有指定 `valarray` 中的对应元素或具有元素类型的值。
`operator>>=`	将 `valarray` 操作数中的每个元素向右移动指定数目的位置，或者按第二个 `valarray` 指定的点算数右移。
`operator<<=`	将 `valarray` 操作数中的每个元素向左移动指定数目的位置，或者按第二个 `valarray` 指定的点算数左移。
`operator*=`	将指定 `valarray` 的元素或元素类型的值与操作数 `valarray` 进行点乘。
`operator+`	一个一元运算符，该运算符将 `valarray` 中的所有元素相加。在正常算术类型上，此运算符不起任何作用。
`operator+=`	将指定 `valarray` 的元素或元素类型的值与操作数 `valarray` 进行点加。
`operator-`	一个一元运算符，该运算符对 `valarray` 中的所有元素进行算术求反。
`operator-=`	将指定 `valarray` 的元素或元素类型的值与操作数 `valarray` 进行点减。
`operator/=`	将操作数 `valarray` 与指定 `valarray` 的元素或元素类型的值进行点除。
`operator=`	将元素分配给 `valarray`，其值可以直接指定，也可以作为一些其他 `valarray` 的一部分指定，或由 `slice_array`、`gslice_array`、`mask_array` 或 `indirect_array` 指定。
`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&)
const 元素的函数对象将应用于操作数 valarray 的每个元素。

返回值

一个 valarray，它的元素已使 function_object 将点算应用到操作数 valarray 的元素。

备注

成员函数将返回类 valarray<Type> 的对象，长度为 size，其中每个元素 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 中的元素最小值。

注解

成员函数通过以下方法比较值：应用类 Type 的元素对之间的 operator< 或 operator>，因此，必须为元素 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!`

一个一元运算符，该运算符获取 valarray 中每个元素的逻辑 NOT (!) 值。

valarray<bool> operator!() const;

返回值

布尔值的 valarray，这些布尔值表示操作数 valarray 的元素值的逻辑求反运算。

备注

逻辑运算 NOT 由 ! 表示，将对元素进行逻辑求反，因为它会将所有零值转换为 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，它的元素为用 right 对操作数 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
元素类型的 valarray 或值与操作数 valarray 相同，用于通过按位 AND (&) 与操作数 valarray 进行点算合并。

返回值

一个 valarray，它的元素是通过 right 进行的操作数 valarray 的按位 AND (&)

备注

按位运算仅可用于操作整型数据类型中的位（如 char 和 int）。它不适用于 float、double、long double、void、bool 或其他更复杂的数据类型。

按位 AND (&) 适用于单个位级别上的数据类型。假设有位 b1 和 b2，如果两个位都为 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（其元素指示右移的元素指向值）。

返回值

一个 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 操作数中的每个元素向左移动指定数目的位置，或者按第二个 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 点除 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，其值可以直接指定，也可以作为一些其他 valarray 的一部分指定，或由 slice_array、gslice_array、mask_array 或 indirect_array 指定。

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 控制的序列的副本替换受控序列。

第二个成员运算符与第一个成员运算符相同，但前者具有右值引用声明符：&&。

第三个成员运算符使用 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 的 slice_array，它指定要选择或返回到新 valarray 的子集。

gslicearray
一个 valarray 的 gslice_array，它指定要选择或返回到新 valarray 的子集。

boolarray
一个 valarray 的 bool_array，它指定要选择或返回到新 valarray 的子集。

indarray
一个 valarray 的 indirect_array，它指定要选择或返回到新 valarray 的子集。

返回值

对指定索引或指定子集处的元素或其值的引用。

注解

成员运算符将重载，从而提供多种方法用于从 *this 控制的元素序列中进行选择。五个成员运算符中的第一组将配合 operator=（以及其他赋值运算符）的各种重载进行工作，从而允许受控序列的选择性替换（切片）。所选的元素必须存在。

当使用定义为 1 或 2 的 _ITERATOR_DEBUG_LEVEL 进行编译时，如果试图访问 valarray 边界之外的元素，将发生运行时错误。有关详细信息，请参阅检查的迭代器。

示例

有关如何声明和使用 operator[] 的示例，请参阅 slice::slice 和 gslice::gslice 的示例。

`operator^=`

获取 valarray 与指定 valarray 或元素类型的值进行的按位异或 (^)。

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

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

参数

right
元素类型的 valarray 或值与操作数 valarray 相同，用于通过按位异或 (XOR) 运算符 (^) 与操作数 valarray 进行合并。

返回值

一个 valarray，它的元素是操作数 valarray 和 right 的按位异或 (XOR)。

备注

按位异或（称为 XOR 且由运算符 ^ 表示）具有以下语义：假设有位 b1 和 b2，如果其中恰好有一个元素为 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
元素类型的 valarray 或值与操作数 valarray 相同，用于通过按位 OR (|) 与操作数 valarray 进行点算合并。

返回值

一个 valarray，它的元素是通过 right 进行的操作数 valarray 的点算按位 OR (|)。

备注

按位 OR (|) 适用于单个位级别上的数据类型。假设有位 b1 和 b2，如果至少有一个位为 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 的元素的值。

注解

第一个成员函数使用其默认构造函数初始化元素。

受控序列中元素的任何指针或引用都会失效。

示例

以下示例演示 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 个位置，用零填充。

负值 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 中的所有元素的总和。

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 之间的受控序列。它在固定时间内执行此操作，它不引发任何异常，不使任何引用、指针或两个受控序列中的元素的迭代器失效。

`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。接下来的三个构造函数将对象初始化为 count 元素的 valarray，如下所示：

对于显式 valarray(size_t count)，使用默认构造函数初始化每个元素。
对于 valarray(const Type& val, count)，使用 val 初始化每个元素。
对于 valarray(const Type* ptr, count)，使用 ptr[I] 初始化位置 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 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[]

参数