在这种情况下可以避免循环吗？

Question

我有一个vector<A>，A 有一个字段 A::foo。 我想创建一个向量，其中元素是前一个向量的“foo”。当然我可以遍历向量的元素，但是在 STL 或其他主要库中是否有直接实现？

Answer 1

这应该可行

vector<A> vA; // this is your vector<A>, assumed to contain some `A`'s
...
vector<Foo> vFoo; // here is where we extract the Foo's
std::transform(std::begin(vA), std::end(vA), std::back_inserter(vFoo), 
               [](const A& param){return param.foo});

Answer 2

您可以从<algorithm> 使用std::transform。

#include<algorithm>

std::vector<A> as;
// fill it
std::vector<A::foo_type> foos;
foos.resize(as.size());
std::transform(as.begin(), as.end(), foos.begin(), [](const &A) { return A.foo; });

Answer 3

您可以使用 std::transform，但在这种情况下，我认为基于范围的 for 循环更具可读性，并且至少应该与使用 STL 的算法一样高效。

---

编辑： 为了说明我的观点：

struct Foo {};

struct Bar {
    Foo foo;
};

int main() {
    vector<Bar> bars(10);
    vector<Foo> foos1, foos2, foos3;

    foos1.reserve(bars.size());
    for (const auto& e : bars) { // this will become 'for (e:bars)' in the future
        foos1.push_back(e.foo);
    }

    foos2.resize(bars.size());
    transform(bars.begin(), bars.end(), foos2.begin(), [](const Bar& bar) { return bar.foo; });

    foos3.reserve(bars.size());
    transform(bars.begin(), bars.end(), back_inserter(foos3), [](const Bar& bar){return bar.foo; });

}

在我看来，循环版本更容易阅读（但我承认这可能是个人喜好问题）。

不要误会我的意思，我真的很喜欢算法，但在这种非常简单的情况下，它们的句法开销并没有起到作用。

---

编辑2： 一些处理器有gather instruction 指令。看看一个典型的编译器是否会生成这些以及在什么条件下会很有趣。