无输出变换

Question

我有两个相同大小的vector。我需要用另一个vector的内容来修改一个vector中的每个元素。是否有一种标准算法可以在不返回到原始vector的情况下完成此操作?

假设我想将vector foo的所有元素修改为vector bar的相应元素。我可以使用transform:

transform(foo.begin(), foo.end(), bar.begin(), foo.begin(), [](auto& a, const auto& b){a.func(b); return a;});

但是没有必要赋值回foo。或者，我可以编写自己的函数:

auto a = foo.begin();
auto b = bar.begin();
while(a != foo.end()){
    (a++)->func(*(b++));
}

Answer 1

您所要求的基本上是二进制函数的std::for_each。由于(目前)还没有这样的东西，您可以执行以下操作之一:

1)为二进制函数实现一个通用版本的for_each:

(代码取自https://groups.google.com/a/isocpp.org/d/msg/std-proposals/fNqx2TR-ju8/MIqPwgSoWukJ)

#include <vector>
#include <iostream>
template<class InputIt1, class InputIt2, class BinaryFunction>
BinaryFunction for_each(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryFunction f)
{
    for (; first1 != last1; ++first1, ++first2) {
        f(*first1, *first2);
    }
    return f;
}
struct Foo
{
    Foo() : k(-1){}
    int k;
    void func(int i){k=i;}
};
int main() {
    std::vector<Foo> foo(5);
    std::vector<int> bar(5,55);
    for_each(foo.begin(), foo.end(), bar.begin(), [](auto& a, const auto& b){a.func(b); return a;});
    for(auto f : foo)
    {
        std::cout << f.k << std::endl;
    }
    return 0;
}

live on coliru

2)使用boost::zip_iterator和现有std::for_each:

#include <algorithm>
#include <vector>
#include <iostream>
#include <boost/iterator/zip_iterator.hpp>
struct Foo
{
    Foo() : k(-1){}
    int k;
    void func(int i){k=i;}
};
template<typename... Iterators>
auto zip(Iterators... its)
{
    return boost::make_zip_iterator(boost::make_tuple(its...));
}
int main() {
    std::vector<Foo> foo(5);
    std::vector<int> bar(5,55);
    auto zip_func = [](auto&& t){t.template get<0>().func(t.template get<1>());};
    std::for_each(
        zip(foo.begin(), bar.begin()),
        zip(foo.end(), bar.end()),
        zip_func
    );
    for(auto f : foo)
    {
        std::cout << f.k << std::endl;
    }
    return 0;
}

生活在coliru

Answer 2

小工具函数模板:

template <typename Input1, typename Input2, typename BinaryOperation>
void zip(Input1 b1, Input1 e1, Input2 b2, BinaryOperation binOp) {
    while (b1 != e1) binOp(*b1++, *b2++);
}

用法:

zip(begin(foo), end(foo), begin(bar), [](auto& a, const auto& b){ a.func(b); });

Answer 3

最简洁的答案似乎是使用索引而不是迭代器。

for(auto i = 0; i < foo.size(); ++i) foo[i].func(bar[i]);

它的唯一要求类似于任何多输入迭代器算法:所有容器必须至少具有第一对迭代器所指示的相同范围。这里的意思是所有容器的大小应该大于或等于foo.size()。与transform的滥用不同，它可以扩展为支持尽可能多的括号操作符可访问的容器:

for(auto i = 0; i < foo.size(); ++i) foo[i].func(bar[i], baz[i], buz[i]);