Jak wycinać z pętlą dla zakresu? C++ 0x

Question

Korzystanie zakres oparty na pętli w C++ 0x, wiem, że będziemy w stanie zrobić:

std::vector<int> numbers = generateNumbers(); 

for(int k : numbers) 
{ 
    processNumber(k); 
} 

(może być jeszcze prostsze napisać z lambda)

Ale jak powinienem zrobić, jeśli chcę tylko zastosować processNumber (k) do części liczb? Na przykład, w jaki sposób powinienem napisać to dla pętli, aby zastosować processNumber() do połowy (głowy lub ogona) liczb? Czy "krojenie" jest dozwolone tak jak w Pythonie czy Ruby?

Answer 1

Coś takiego może działać (zaznaczone jako nie mam dostępu do kompilatora C++ 0x),

Edit: sprawdzone go na VS10, oczywiście musiałem naprawić błędy numurous ....

Należy zdefiniować klasę, która jest pełnomocnikiem dowolnego kontenera, a której tylko iterator zwraca podzbiór kontenera. Podany przeze mnie przykład jest najprostszym, który podaje pierwszą połowę, ale może być znacznie bardziej ogólny.

template <class Container> 
class head_t { 
    Container& c_; 
public: 
    template <class T> 
    class iter { 
     T curr_; 
     const T& end_; 
     int limit_; // count how many items iterated 
    public: 
     iter(T curr, const T& end) 
      : curr_(curr) 
      , end_(end)    
      , limit_(std::distance(curr_, end_)/2) 
      { } 

     typename Container::value_type operator*() { return *curr_; } 

     // Do the equivilant for for operator++(int) 
     iter& operator++() { 
      if (--limit_ == 0) // finished our slice 
       curr_ = end_; 
      else 
       ++curr_; 
      return *this; 
     } 

     bool operator!=(const iter& i) const { 
      return curr_ != i.curr_; 
     } 
    }; 

    head_t(Container& c) : c_(c) {} 
    iter<typename Container::iterator> begin() { 
     return iter<typename Container::iterator>(c_.begin(), c_.end()); 
    } 

    iter<typename Container::iterator> end() { 
     return iter<typename Container::iterator>(c_.end(), c_.end()); 
    }  
}; 

template <class T> 
head_t<T> head(T& t) { return head_t<T>(t); } 

A następnie używać go w pętli:

for(int k : head(numbers)) 

Answer 2

Jedną z możliwości może być impuls na iterator_range

(nie ma kompilatora, który obsługuje zakres oparte na, używając BOOST_FOREACH zamiast ja. "oczekuje się, że zakres pracy będzie taki sam, o ile pojemnik lub zakres ma metodę początkową i końcową.)

#include <boost/foreach.hpp> 
#include <boost/range/iterator_range.hpp> 
#include <iostream> 
#include <vector> 

int main() 
{ 
    std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 
    BOOST_FOREACH(int n, boost::make_iterator_range(v.begin(), v.begin() + v.size()/2)) { 
     std::cout << n << '\n'; 
    } 
} 

Dla wygody można również utworzyć własną funkcję przekroju, aby przyjmowała indeksy zamiast iteratorów. Znowu, może to być oparte na boost.iterator_range, czy nie:

#include <cstddef> 
#include <iterator> 

template <class Iterator> 
class iter_pair 
{ 
public: 
    typedef Iterator iterator; 
    typedef Iterator const_iterator; //BOOST_FOREACH appears to want this 
    iter_pair(iterator first, iterator last): first(first), last(last) {} 
    iterator begin() const { return first; } 
    iterator end() const { return last; } 
private: 
    iterator first, last; 
}; 

template <class Container> 
struct iterator_type 
{ 
    typedef typename Container::iterator type; 
}; 

template <class Container> 
struct iterator_type<const Container> 
{ 
    typedef typename Container::const_iterator type; 
}; 

template <class Container> 
iter_pair<typename iterator_type<Container>::type> 
    slice(Container& c, size_t i_first, size_t i_last) 
{ 
    typedef typename iterator_type<Container>::type iterator; 
    iterator first = c.begin();   
    std::advance(first, i_first); 
    iterator last = first; 
    std::advance(last, i_last - i_first); 
    return iter_pair<iterator>(first, last); 
} 

template <class Container> 
iter_pair<typename iterator_type<Container>::type> 
    slice(Container& c, size_t i_last) 
{ 
    return slice(c, 0, i_last); 
} 

//could probably also be overloaded for arrays 

#include <cctype> 
#include <string> 
#include <boost/foreach.hpp> 
#include <iostream> 

int main() 
{ 
    std::string s("Hello world, la-la-la!"); 
    BOOST_FOREACH(char& c, slice(s, 2, 11)) { 
     if (c == 'l') 
      c = std::toupper(c); 
    } 
    const std::string& r = s; 
    BOOST_FOREACH(char c, slice(r, r.size() - 1)) { 
     std::cout << c << " "; 
    } 
    std::cout << '\n'; 
} 

Ogólnie jeden prawdopodobnie pracować z iteratorów w pierwszej kolejności, więc to nie może być tak, że użyteczne.

Answer 3

Można użyć "sliced" range adaptor z biblioteki Boost.Range:

#include <boost/range/adaptor/sliced.hpp> 

using boost::adaptors::sliced; 

...

std::vector<int> numbers = generateNumbers(); 
for(int k : numbers | sliced(0, numbers.size()/2)) 
{ 
    processNumber(k); 
}