C++ 在C++；

我有一个120个元素的向量。我需要每组20个值的总和（总共6组）。我目前正在使用两个嵌套for循环，如下所示：

for (int j = 0; j < 120; j+=20) 
    for (int i = j; i < (j +20); i++)
        sum += vector[i]
        code where I use the sum

for（int j=0；j<120；j+=20）
对于（int i=j；i<（j+20）；i++）
总和+=向量[i]
我使用总和的代码

---

有什么更好（更快）的方法可以仅使用STL来实现这一点？

使用标准库可能不会有太大的区别（如果有的话），但它可能会使代码更整洁：

auto const stride = 20;

for (auto b = vec.begin(); b < vec.end(); b+=stride) {
    auto sum = std::accumulate(b, b+stride, 0);
    use(sum);
}

auto-const-stride=20；
对于（自动b=vec.begin（）；b

使用标准库在这里可能不会有太大区别（如果有的话），但它可能会使代码更整洁：

auto const stride = 20;

for (auto b = vec.begin(); b < vec.end(); b+=stride) {
    auto sum = std::accumulate(b, b+stride, 0);
    use(sum);
}

auto-const-stride=20；
对于（自动b=vec.begin（）；b

首先，您可以保存6个添加项：

for (int j = 0; j < 120; j += 20) {
    auto sum = vector[j];
    for (int i = j + 1; i < j + 20; i++)
        sum += vector[i];
    // code which uses the sum
}

for（int j=0；j<120；j+=20）{
自动求和=向量[j]；
对于（int i=j+1；i

其次，您可以使用std:：acculate，希望您的实现能够以某种方式优化它：

auto it = vector.cbegin();
for (int j = 0; j < 120; j += 20) {
    auto itNext = it + 20;
    auto sum = std::accumulate(it + 1, itNext, *it);
    // code which uses the sum
    it = itNext;
}

autoit=vector.cbegin（）；
对于（int j=0；j<120；j+=20）{
自动itNext=it+20；
自动求和=std:：累加（it+1，itNext，*it）；
//使用和的代码
it=itNext；
}

---

但是请注意，除非

向量
在缓存内存中，否则这些或任何其他改进充其量都是微不足道的。在这种情况下，从RAM中读取向量所需的时间比算术要长得多。
首先，您可以保存6个加法：

for (int j = 0; j < 120; j += 20) {
    auto sum = vector[j];
    for (int i = j + 1; i < j + 20; i++)
        sum += vector[i];
    // code which uses the sum
}

for（int j=0；j<120；j+=20）{
自动求和=向量[j]；
对于（int i=j+1；i

其次，您可以使用std:：acculate，希望您的实现能够以某种方式优化它：

auto it = vector.cbegin();
for (int j = 0; j < 120; j += 20) {
    auto itNext = it + 20;
    auto sum = std::accumulate(it + 1, itNext, *it);
    // code which uses the sum
    it = itNext;
}

autoit=vector.cbegin（）；
对于（int j=0；j<120；j+=20）{
自动itNext=it+20；
自动求和=std:：累加（it+1，itNext，*it）；
//使用和的代码
it=itNext；
}

但是请注意，除非
向量
在缓存内存中，否则这些或任何其他改进充其量都是微不足道的。在这种情况下，从RAM中读取向量所花费的时间比算术要长得多。
在我看来，6个不同的for循环，每个循环对应20个元素，速度会更快。因为这将是
O（n）
；虽然循环是
O（n^2）
@BatCoder，但它不是
O（n^2）
。在OP使用的第一个循环中，
j+=20
。在内部循环之前，您忘记了
sum=0
。在没有更多信息的情况下，没有“最快的方法”来做任何事情。在我看来，6个不同的for循环，每个for循环对应20个元素，速度会更快。因为这将是
O（n）
；虽然循环是
O（n^2）
@BatCoder，但它不是
O（n^2）
。在OP使用的第一个循环中，
j+=20
。在内部循环之前，您忘记了
sum=0
。在没有更多信息的情况下，没有“最快的方法”来做任何事情。除法是一个非常慢的操作。此外，如果编译器不能确定vector.size（）在循环中没有改变，那么它可能无法优化vector.size（）/stride
。六个分区很容易比114个分区需要更多的时间。即使是一个部门也会很昂贵。@user31264:重复的理由很好。如果他真的确定大小永远是120，那么消除除法是很简单的，但是如果大小改变以节省约20个时钟周期，我必须非常渴望额外的速度来冒险进行错误的行为。@user31264:经过一些思考，我已经取消了除法，但仍然保持正确的行为。除法是一个非常缓慢的操作。此外，如果编译器不能确定vector.size（）在循环中没有改变，那么它可能无法优化vector.size（）/stride
。六个分区很容易比114个分区需要更多的时间。即使是一个部门也会很昂贵。@user31264:重复的理由很好。如果他真的确定大小永远是120，那么消除除法是很简单的，但是如果大小改变以节省约20个时钟周期，我必须非常渴望额外的速度来冒险进行错误的行为。@user31264:经过一番思考，我消除了除法，但仍然保留了正确的行为。