Odpowiednik C++ range / xrange w STL czy boost?

Boost irange powinno być odpowiedź (ThxPaul Brannan)

Dodaję swoją odpowiedź, aby podać przekonujący przykład bardzo Ważne przypadki użycia, które nie są dobrze obsługiwane przez ręczne zapętlanie:

#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/range/irange.hpp>

using namespace boost::adaptors;

static int mod7(int v) 
    { return v % 7; }

int main() 
{
    std::vector<int> v;

    boost::copy(
            boost::irange(1,100) | transformed(mod7), 
            std::back_inserter(v));

    boost::sort(v);

    boost::copy(
            v | reversed | uniqued, 
            std::ostream_iterator<int>(std::cout, ", "));
}

Wyjście: 6, 5, 4, 3, 2, 1, 0,

Zauważ, jak to przypomina Generatory / comprehensions (functional languages) i enumerables (C#)

Update pomyślałem, że wspomnę o następujących (wysoce nieelastyczny) idiom, na który pozwala C++11:

for (int x : {1,2,3,4,5,6,7})
    std::cout << x << std::endl;

Oczywiście, że możesz się z nim ożenić irange:

for (int x : boost::irange(1,8))
    std::cout << x << std::endl;

std::iota (jeszcze nie znormalizowana) jest trochę jak range. Nie czyni jednak rzeczy krótszymi ani jaśniejszymi niż wyraźna pętla for.

#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main() {
    std::vector<int> nums(5);
    std::iota(nums.begin(), nums.end(), 1);
    std::copy(nums.begin(), nums.end(),
            std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
    return 0;
}

Kompilować z g++ -std=c++0x; to drukuje "1 2 3 4 5 \n".

Cóż, oto, co napisałem, ponieważ nie wydaje się być. generator nie używa pamięci wewnętrznej poza pojedynczą liczbą całkowitą. obiekt range może być przekazywany i używany w zagnieżdżonych pętlach.

Jest mały przypadek testowy.

#include "iostream"
#include "foreach.hpp"

#include "boost/iterator/iterator_categories.hpp"

struct range {

  struct iterator_type {
    typedef int value_type;
    typedef int difference_type;
    typedef boost::single_pass_traversal_tag iterator_category;
    typedef const value_type* pointer;
    typedef const value_type & reference;

    mutable value_type value;
    const difference_type increment;

    iterator_type(value_type value, difference_type increment = 0)
      : value(value), increment(increment) {}

    bool operator==(const iterator_type &rhs) const {
      return value >= rhs.value;
    }
    value_type operator++() const { return value += increment; }
    operator pointer() const { return &value; }
  };

  typedef iterator_type iterator;
  typedef const iterator_type const_iterator;

  int first_, last_, increment_;

  range(int last) : first_(0), last_(last), increment_(1) {}
  range(int first, int last, int increment = 1)
    : first_(first), last_(last), increment_(increment) {}

  iterator begin() const {return iterator(first_, increment_);}
  iterator end() const {return iterator(last_);}
};

int test(const range & range0, const range & range1){
  foreach(int i, range0) {
    foreach(int j, range1) {
      std::cout << i << " " << j << "\n";
    }
  }
}

int main() {
  test(range(6), range(3, 10, 3));
}

Moim głównym powodem jest to, że używam mowy do tekstu, a pętla programowania zwykle jest trudna, nawet jeśli używam uzupełniania kodu. Znacznie wydajniejsze jest posiadanie zaimków.

Wiele pętli zaczyna się od zera i przyrost o jeden, co jest domyślne dla zakresu. Uważam, że Python construct jest bardziej intuicyjny

Funkcje które muszą przyjąć range jako argument:

Function(int start, int and, int inc);
function(xrange r);

Lub idiomatyczna wersja C++:

template <typename iter_type>
void function(iter_type first, iter_type last);

Próba zamiany języka X na język Y jest zawsze niewłaściwą rzeczą zrób. To nie działa i zmyli programistów języka X, którzy będą utrzymywać (lub po prostu czytać) twój kod.

Ponieważ zacząłem używać BOOST_FOREACH dla całej mojej iteracji (prawdopodobnie błędny pomysł, ale to już inna historia), oto kolejne użycie klasy range aaa:

std::vector<int> vec;
// ... fill the vector ...
BOOST_FOREACH(size_t idx, make_range(0, vec.size()))
{
  // ... do some stuff ...
}

(tak, zakres powinien być templalizowany, abym mógł używać z nim typów całkowych zdefiniowanych przez użytkownika)

I oto make_range ():

template<typename T>
range<T> make_range(T const & start, T const & end)
{
  return range<T>(start, end);
}

Zobacz także:

Http://groups.google.com/group/boost-list/browse_thread/thread/3e11117be9639bd

I:

Https://svn.boost.org/trac/boost/ticket/3469

I właśnie znalazłem boost:: integer_range; w powyższym przykładzie kod wyglądałby następująco:

using namespace boost;
std::vector<int> vec;
// ... fill the vector ...
BOOST_FOREACH(size_t idx, make_integer_range(0, vec.size()))
{
  // ... do some stuff ...
}

Pętla for obsługuje prawie automatycznie:

for(int loop=first;loop < last;loop += increment)
{
  /// Do Stuff.
}

Próbujesz wprowadzić idiom Pythona do C++. To nienaturalne. Użycie

for(int i=initVal;i<range;i+=increment) 
{ 
    /*loop body*/
}

Aby to osiągnąć. W Pythonie forma for(i in xrange(init, rng, increment)) jest niezbędna, ponieważ Python nie zapewnia prostej pętli for, tylko konstrukcję typu for-each. Więc możesz iterację tylko nad sekwencją lub generatorem. Jest to po prostu niepotrzebna i prawie na pewno zła praktyka w języku, który zapewnia składnię for(;;).

EDIT: jako zupełnie niezalecany bok, najbliżej mogę dostać się do składni for i xrange(first, last, inc) w C++ jest:

#include <cstdio>

using namespace std;

int xrange(unsigned int last, unsigned int first=0, unsigned int inc=1)
{
    static int i = first;
    return (i<last)?i+=inc:i=0;
}

int main()
{
    while(int i=xrange(10, 0, 1))
        printf("in loop at i=%d\n",i);
}

Nie to, że podczas gdy to pętla prawidłową liczbę razy, i waha się od first+inc do last, A NIE first do last-inc jak w Pythonie. Ponadto funkcja może działać niezawodnie tylko z wartościami unsigned, ponieważ gdy i==0, pętla while zakończy działanie. Czy Nie używać tej funkcji. Dodałem ten kod tylko po to, aby zademonstrować, że coś takiego jest rzeczywiście możliwe. Istnieje również kilka innych zastrzeżeń i gotchas (kod naprawdę nie będzie działać na pierwszy!=0 przy kolejnej funkcji wywołania, na przykład)

Ponieważ nie wiemy, do czego chcesz to wykorzystać, zakładam, że twój test jest reprezentatywny. A wtedy proste dla pętli są o wiele prostsze i bardziej czytelne:

int main() {
  for (int i = 0; i <= 6; ++i){
    for (int j = 3; j <= 10; j += 3){
      std::cout << i << " " << j << "\n";
    }
  }
}

Programista C++ może wejść z ulicy i zrozumieć tę funkcję bez konieczności szukania złożonych klas gdzie indziej. I to 5 linijek zamiast 60. Oczywiście, jeśli masz 400 pętli dokładnie takich jak te, to tak, zaoszczędziłbyś trochę wysiłku, używając swojego zakresu obiekt. Możesz też zawinąć te dwie pętle wewnątrz funkcji pomocniczej i wywołać , Kiedy tylko potrzebujesz.

Nie mamy wystarczająco dużo informacji, aby powiedzieć, co jest nie tak z pętlami simple for, lub co byłoby odpowiednim zamiennikiem. Pętle tutaj rozwiązują problem z dużo mniejszą złożonością i znacznie mniejszą liczbą linii kodu niż przykładowa implementacja. Jeśli jest to złe rozwiązanie, powiedz nam swoje wymagania (jak w jaki problem trzeba rozwiązać, zamiast "chcę python-style loops in C++")

Keep it simple, make a stupid macro;

#define for_range(VARNAME, START, STOP, INCREMENT) \
for(int VARNAME = START, int STOP_ = STOP, INCREMENT_ = INCREMENT; VARNAME != STOP_; VARNAME += INCREMENT_)

I używać jako;

for_range(i, 10, 5, -1)
  cout << i << endl;