Algoritmo C++ per applicare una funzione a elementi consecutivi

Question

C'è un modo più semplice per scrivere questo, ad es. usando un algoritmo STL o 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

È possibile utilizzare il binary version of std::transform.

Gli algoritmi std::adjacent_find/std::adjacent_difference possono essere abusati.

Answer 2

propongo di utilizzare un ciclo for:

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

---

Un ciclo più generico per iteratori bidirezionali:

// 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)); 

---

Siamo in grado di andare un po 'oltre e scrivere un ciclo per gli iteratori in avanti:

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

---

Infine, e l'algoritmo iteratori di input. Tuttavia, questo richiede che il tipo di valore sia copiabile.

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

Scriverò il proprio algoritmo per applicare un funtore a ciascuna coppia di elementi nel contenitore.

(blurb sfacciato) Nella mia presentazione ACCU quest'anno, "STL Algorithms – How to Use Them and How to Write Your Own", ha mostrato come scriverne uno come questo. L'ho chiamato adjacent_pair (circa 25:00 nel video)

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 è proprio per questo, ma come lei ha ricordato, copia il primo elemento al risultato, che non si vuole. Utilizzando Boost.Iterator, è abbastanza facile creare un back_inserter che getta via il primo elemento.

#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); 
      }); 
} 

Poi si può #include <boost/range/numeric.hpp> e fare questo:

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

---

Quando si desidera la funzione binaria per restituire un tipo diverso (ad esempio una stringa), quanto sopra soluzione non funzionerà perché, anche se l'inserimento cont.push_back(i) non è mai chiamato per il primo eleme copiato nt, deve essere ancora compilato e non funzionerà.

Quindi, è possibile creare un back_inserter che ignora qualsiasi elemento di un tipo diverso da quello nel contenitore. Questo ignorerà il primo, copiato, elemento, e accetterà il resto.

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}); 
} 

Quindi è possibile utilizzarlo in modo simile.

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

Stephan T. Lavavej ha scritto una bella classe adjacent_iterator qui:

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

Questo potrebbe anche essere utilizzato qui.