C++std::valarray用法实例详解

std::valarray 其实是 C++ 标准库中一个被不少人忽视的宝藏容器，专门用于数值数组计算，定义在 头文件里。它的设计初衷，说白了就是让你能像操作单个数值那样，对整个数组进行数学运算，省去手动写循环的麻烦。这在追求高性能向量化运算的场景下，是非常自然的设计思路。

一、核心特性

二、基础用法

1. 构造和初始化

先来看看怎么创建一个 valarray。方式挺多的，从简单的默认构造到初始化列表，基本覆盖了大部分场景。

#include 
#include 
int main() {
    // 默认构造
    std::valarray v1;
    std::cout << v1.size() << std::endl;  // 0[citation:1]
    // 指定大小
    std::valarray v2(100);           // 100个元素，默认初始化[citation:1]
    // 指定大小和初始值（注意：第一个参数是值，第二个是数量）
    std::valarray v3(5, 20);         // 20个5，注意顺序与vector相反[citation:1]
    // 从数组构造
    int arr[] = {2, 3, 5, 7, 11};
    std::valarray v4(arr, 5);        // 从数组拷贝[citation:2][citation:6]
    // C++11：初始化列表
    std::valarray v5{2, 3, 5, 7, 11}; // 直接初始化[citation:1]
    // 改变大小（原有数据会丢失）
    v5.resize(10);        // 大小变为10，所有元素重置[citation:1][citation:6]
}

2. 元素访问

访问元素也很直观，和普通数组没两样。

std::valarray v{1, 2, 3, 4, 5};
// operator[] 访问单个元素
v[2] = 10;                // 修改第3个元素[citation:2]
// size() 获取元素数量
std::cout << v.size() << std::endl;  // 5[citation:1]

三、运算操作

1. 元素级算术运算

这是 valarray 最爽的地方。运算符直接作用在整个数组上，完全不需要写循环，代码简洁到飞起。

std::valarray a{1, 2, 3};
std::valarray b{4, 5, 6};
// 数组加法（逐个元素相加）
std::valarray c = a + b;     // {5, 7, 9}[citation:7]
// 数组与标量运算
std::valarray d = a * 2;     // {2, 4, 6}
// 一元运算
std::valarray e = -a;        // {-1, -2, -3}[citation:2]

2. 复合赋值运算符

不光能直接用 +、-，还支持各种复合赋值操作。

std::valarray v1(1, 3);           // {1, 1, 1}
std::valarray v2(2, 3);           // {2, 2, 2}
v1 += v2;                              // {3, 3, 3}
v2 += 2;                               // {4, 4, 4}[citation:9]

支持的复合赋值运算符很全，包括：+=, -=, *=, /=, %=, ^=, &=, |=, <<=, >>=。可以说非常完整了。

3. 数学函数

更厉害的是，可以直接上数学函数。

#include 
#include 
std::valarray v{0, 0.25, 0.5, 0.75, 1};
// 对每个元素应用数学函数
std::valarray s = std::sin(v * std::numbers::pi);
// 结果: {0, 0.707, 1, 0.707, 0}[citation:4]
// 其他支持的函数：sin, cos, tan, exp, log, sqrt, abs 等[citation:3][citation:5]

四、进阶特性：子集访问

valarray 真正的亮点在于它提供了四种方式来灵活访问和操作数组的子集。这个设计相当有想法，堪称一个创新点。

1. Slice（切片）

从数组中提取按固定步长选取的元素序列，有点像 Python 里的切片思想。

std::valarray all{1, 2, 3, 4, 5, 6, 7, 8, 9};
// slice(start, length, stride): 从索引0开始，选5个元素，步长为2
std::slice sl(0, 5, 2);
std::valarray odd = all[sl];  // {1, 3, 5, 7, 9}[citation:2]

2. gslice（通用切片）

这个就更灵活了，能模拟多维数组操作，处理矩阵计算很方便。

// 创建类似3D数组的结构
size_t lengths[] = {3, 3};
size_t strides[] = {3, 1};
std::valarray len(lengths, 2);
std::valarray str(strides, 2);
std::valarray v(27);           // 27个元素的数组
// 使用gslice提取特定子集
// v[gslice(0, len, str)] 提取前9个元素[citation:2]

3. 掩码数组（Mask Array）

用一个布尔数组来筛选元素，非常直观。

bool b[] = {true, false, true, false, true, false, true, false, true};
std::valarray mask(b, 9);
std::valarray all{1, 2, 3, 4, 5, 6, 7, 8, 9};
std::valarray odd = all[mask];  // {1, 3, 5, 7, 9}[citation:2]

4. 间接数组（Indirect Array）

用一个索引数组来提取元素，自由度最高。

size_t idx[] = {0, 2, 4, 6, 8};
std::valarray indices(idx, 5);
std::valarray all{1, 2, 3, 4, 5, 6, 7, 8, 9};
std::valarray odd = all[indices];  // {1, 3, 5, 7, 9}[citation:2]

5. 子集的赋值操作

选中子集后，还能直接当左值来修改。这个特性很实用。

std::valarray v{1, 2, 3, 4, 5};
std::slice sl(1, 3, 1);
v[sl] = 0;           // v变成 {1, 0, 0, 0, 5}

6. 其他实用方法

除了子集访问，还有一些很实用的小方法。

std::valarray v{3, 1, 4, 1, 5};
int sum = v.sum();       // 总和：14[citation:6]
int min = v.min();       // 最小值：1[citation:3]
int max = v.max();       // 最大值：5[citation:3]
// 移位
std::valarray v2 = v.shift(2);   // {4, 1, 5, 0, 0} 左移，空位补0[citation:6]
std::valarray v3 = v.cshift(2);  // {4, 1, 5, 3, 1} 循环左移[citation:6]
// apply：将函数应用到每个元素
auto result = v.apply([](int x) { return x * x; });  // {9, 1, 16, 1, 25}[citation:8]

五、使用建议

话说回来，虽然 valarray 是为高性能数值计算量身定做的，但它在实际项目中的应用并没有想象中那么广泛。

• GCC和LLVM 在实现中运用了表达式模板技术来优化 valarray 的运算效率。
• Intel编译器 则通过集成 IPP（Intel Performance Primitives）来提供专门优化。
• 不过，像 Eigen、Blaze 这些现代数值库，更倾向于用表达式模板直接优化普通容器。相比之下，valarray 的应用场景就受到了挤压。

总的来说，如果你的项目只是需要一些简单、直接的数组运算，不想引入复杂的第三方库，那 valarray 确实是个不错的选择，开箱即用。但一旦涉及复杂的矩阵运算，比如乘法、转置，或者你需要更灵活的线性代数功能，那还是老老实实上 Eigen 这样的专业库吧，省心省力。