性能敏感大型代码中：依赖索引的原始循环与STL算法选型困惑

Great question—this is a super common pain point when shifting to idiomatic, maintainable C++ while still needing index access for tasks like initializing vectors or working with tabular data. The good news is you don’t have to choose between clean code and performance; here are the best options tailored to your use case:

Option 1: Range-Based For Loop with Manual Index Tracking #

This is the simplest drop-in replacement for raw loops when you need an index. It avoids the error-prone manual boundary checks of raw loops while keeping performance on par:

std::vector<double> vect1(n);
size_t idx = 0;
for (auto& elem : vect1) {
    // Use idx to compute your value, e.g.:
    elem = idx * 0.5 + 1.0;
    ++idx;
}

Modern compilers (with -O2/-O3 optimizations) will optimize this to nearly identical machine code as a raw for (size_t i=0; i<n; ++i) loop, but you eliminate the risk of off-by-one errors or incorrect loop bounds.

Option 2: std::iota + std::transform for Index-Derived Values #

If your vector values are purely a function of their index, this functional-style approach is clean and efficient. std::iota generates a sequence of indices, and std::transform maps those indices to your desired values:

#include <numeric> // for std::iota
#include <algorithm> // for std::transform

std::vector<double> vect1(n);
std::vector<size_t> indices(n);

// Fill indices with 0, 1, 2, ..., n-1
std::iota(indices.begin(), indices.end(), 0);

// Transform indices into your vector values
std::transform(indices.begin(), indices.end(), vect1.begin(),
    [](size_t idx) {
        return some_calculation_based_on_index(idx);
    });

For C++20 and later, you can avoid the separate indices vector by using a temporary range (e.g., std::views::iota(0, n)), making this even more memory-efficient.

Option 3: C++20 Enumerated Range Views (Cleanest Option) #

If you’re on C++20 or newer, the standard library’s range views add std::views::enumerate, which gives you direct access to both the index and element in a single loop. This is the most readable and idiomatic approach:

#include <ranges>

std::vector<double> vect1(n);
for (auto [idx, elem] : vect1 | std::views::enumerate) {
    elem = some_calculation_based_on_index(idx);
}

The enumerate view is lazy—no extra memory is allocated, and the compiler optimizes this to raw loop performance. It eliminates all manual index tracking, making your code far less error-prone.

Option 4: std::for_each with a Stateful Lambda #

If you prefer sticking strictly to STL algorithms, you can use std::for_each with a lambda that tracks the index via a captured reference:

#include <algorithm>

std::vector<double> vect1(n);
size_t idx = 0;
std::for_each(vect1.begin(), vect1.end(), [&idx](auto& elem) {
    elem = some_calculation_based_on_index(idx);
    ++idx;
});

This works well, but it’s less intuitive than the range-based options above. It’s a good choice if you’re already using other STL algorithms in the same code block and want consistency.

Key Performance Note #

All these options, when compiled with optimizations enabled, will produce machine code that’s indistinguishable from a well-written raw loop. The goal here is to reduce bugs and improve maintainability without sacrificing speed—something that raw loops often fail at due to manual boundary management.

内容的提问来源于stack exchange，提问作者Yannenou