Алгоритм 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

binary version of std::transform может использоваться.

Алгоритмы std::adjacent_find/ можно оскорблять.

Answer 2

Я предлагаю использовать для цикла:

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 3

Я бы написал собственный алгоритм для применения функтора к каждой паре элементов в контейнере.

(Бесстыдный рекламный ролик) В моем выступлении в 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 4

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) никогда не называется для первой скопированной eleme nt, он все равно должен быть составлен, и он не пойдет.

Итак, вы можете вместо этого сделать 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 5

Стефан Т. Lavavej написал хороший adjacent_iterator класс здесь:

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

Это также может быть использован здесь.