将函数应用于连续元素的 C++ 算法

Question

有没有更简单的方法来写这个，例如通过使用 STL 或 boost 算法？

std::vector<int> v { 0, 1, 2, 3 }; // any generic STL container
std::vector<int> result;
std::transform(v.begin(), v.end() - 1, // (0, 1, 2)
               v.begin() + 1,          // (1, 2, 3)
               std::back_inserter(result),
               [](int a, int b){ return a + b; }); // any binary function
// result == { 1, 3, 5 }

Answer 1

我建议使用 for 循环：

for(std::vector::size_type i = 0; i < v.size() - 1; i++)
    result.push_back(v[i] + v[i+1])

---

一个更通用的双向迭代器循环：

// let begin and end be iterators to corresponding position
// let out be an output iterator
// let fun be a binary function
for (auto it = begin, end_it = std::prev(end); it != end_it; ++it)
   *out++ = fun(*it, *std::next(it));

---

我们可以更进一步，为前向迭代器编写一个循环：

if(begin != end) {
    for (auto curr = begin,
         nxt = std::next(begin); nxt != end; ++curr, ++nxt) {
        *out++ = fun(*curr, *nxt);
    }
}

---

最后，输入迭代器的算法。但是，这要求值类型是可复制的。

if(begin != end) {
    auto left = *begin;
    for (auto it = std::next(begin); it != end; ++it) {
        auto right = *it;
        *out++ = fun(left, right);
        left = right;
    }
}

Answer 2

可以使用binary version of std::transform。

std::adjacent_find/std::adjacent_difference 算法可能会被滥用。

Answer 3

std::adjacent_difference 正是为此，但正如您所提到的，它将第一个元素复制到结果中，这是您不想要的。 使用 Boost.Iterator，很容易创建一个 back_inserter，它会丢弃第一个元素。

#include <boost/function_output_iterator.hpp>

template <class Container>
auto mybackinsrtr(Container& cont) {
    // Throw away the first element
    return boost::make_function_output_iterator(
            [&cont](auto i) -> void { 
              static bool first = true;
              if (first)
                first = false;
              else
                cont.push_back(i);
            });
}

然后你可以#include <boost/range/numeric.hpp> 并这样做：

std::vector<int> v { 0, 1, 2, 3 }; // any generic STL container
std::vector<int> result;
boost::adjacent_difference(v, mybackinsrtr(result), std::plus<>{}); // any binary function

See it on ideone

---

当您希望二进制函数返回不同的类型（例如字符串）时，上述解决方案将不起作用，因为即使插入 cont.push_back(i) 从未调用复制的元素，它仍然必须编译，它不会去。

因此，您可以改为创建一个 back_inserter，它会忽略与进入容器不同类型的任何元素。这将忽略第一个复制的元素，并接受其余的。

template <class Container>
struct ignore_insert {
    // Ignore any insertions that don't match container's type
    Container& cont;
    ignore_insert(Container& c) : cont(c) {}
    void operator() (typename Container::value_type i) {
        cont.push_back(i);
    }
    template <typename T>
    void operator() (T) {}
};

template <class Container>
auto ignoreinsrtr(Container& cont) {
    return boost::make_function_output_iterator(ignore_insert<Container>{cont});
}

那么你可以类似地使用它。

std::vector<int> v { 0, 1, 2, 3 }; // any generic STL container
std::vector<std::string> result;
boost::adjacent_difference(v, ignoreinsrtr(result), [](int a, int b){ return std::to_string(a+b); });

On ideone

Answer 4

我会编写您自己的算法来将函子应用于容器中的每对元素。

（无耻的宣传）在我今年的 ACCU 演讲中，“STL Algorithms – How to Use Them and How to Write Your Own”展示了如何写一个这样的。我叫它adjacent_pair（大约25:00进入视频）

template <typename ForwardIterator, typename Func>
void adjacent_pair(ForwardIterator first, ForwardIterator last, Func f)
{
    if (first != last)
    {
        ForwardIterator trailer = first;
        ++first;
        for (; first != last; ++first, ++trailer)
            f(*trailer, *first);
    }
}

Answer 5

Stephan T. Lavavej 在这里写了一个很好的 adjacent_iterator 类：

How do I loop over consecutive pairs in an STL container using range-based loop syntax?

这里也可以使用。