¿Existe una clase de rango en C ++ 11 para usar con bucles for basados ​​en rango?

Me encontré escribiendo esto hace un poco:

template <long int T_begin, long int T_end>
class range_class {
 public:
   class iterator {
      friend class range_class;
    public:
      long int operator *() const { return i_; }
      const iterator &operator ++() { ++i_; return *this; }
      iterator operator ++(int) { iterator copy(*this); ++i_; return copy; }

      bool operator ==(const iterator &other) const { return i_ == other.i_; }
      bool operator !=(const iterator &other) const { return i_ != other.i_; }

    protected:
      iterator(long int start) : i_ (start) { }

    private:
      unsigned long i_;
   };

   iterator begin() const { return iterator(T_begin); }
   iterator end() const { return iterator(T_end); }
};

template <long int T_begin, long int T_end>
const range_class<T_begin, T_end>
range()
{
   return range_class<T_begin, T_end>();
}

Y esto me permite escribir cosas como esta:

for (auto i: range<0, 10>()) {
    // stuff with i
}

Ahora, sé que lo que escribí quizás no sea el mejor código. Y tal vez haya una forma de hacerlo más flexible y útil. Pero me parece que algo como esto debería haberse incluido en el estándar.

¿Por lo que es? ¿Se agregó algún tipo de biblioteca nueva para iteradores en un rango de enteros, o tal vez un rango genérico de valores escalares calculados?

La biblioteca estándar de C ++ no tiene uno, pero Boost.Range tiene boost :: counting_range , que ciertamente califica. También puede usar boost :: irange , que tiene un alcance un poco más centrado.

La biblioteca de rango de C ++ 20 le permitirá hacer esto a través de view::iota(start, end).

Hasta donde yo sé, no existe tal clase en C ++ 11.

De todos modos, intenté mejorar su implementación. Lo hice sin plantilla , ya que no veo ninguna ventaja en lo que es template . Por el contrario, tiene una desventaja importante: que no puede crear el rango en tiempo de ejecución, ya que necesita conocer los argumentos de la plantilla en el tiempo de compilación.

//your version
auto x = range<m,n>(); //m and n must be known at compile time

//my version
auto x = range(m,n);  //m and n may be known at runtime as well!

Aquí está el código:

class range {
 public:
   class iterator {
      friend class range;
    public:
      long int operator *() const { return i_; }
      const iterator &operator ++() { ++i_; return *this; }
      iterator operator ++(int) { iterator copy(*this); ++i_; return copy; }

      bool operator ==(const iterator &other) const { return i_ == other.i_; }
      bool operator !=(const iterator &other) const { return i_ != other.i_; }

    protected:
      iterator(long int start) : i_ (start) { }

    private:
      unsigned long i_;
   };

   iterator begin() const { return begin_; }
   iterator end() const { return end_; }
   range(long int  begin, long int end) : begin_(begin), end_(end) {}
private:
   iterator begin_;
   iterator end_;
};

Código de prueba:

int main() {
      int m, n;
      std::istringstream in("10 20");
      if ( in >> m >> n ) //using in, because std::cin cannot be used at coliru.
      {
        if ( m > n ) std::swap(m,n); 
        for (auto i : range(m,n)) 
        {
             std::cout << i << " ";
        }
      }
      else 
        std::cout <<"invalid input";
}

Salida:

10 11 12 13 14 15 16 17 18 19

Demostración en línea .

Escribí una biblioteca llamada rangepara exactamente el mismo propósito, excepto que es un rango de tiempo de ejecución, y la idea en mi caso vino de Python. Consideré una versión en tiempo de compilación, pero en mi humilde opinión, no hay ninguna ventaja real para ganar la versión en tiempo de compilación. Puede encontrar la biblioteca en bitbucket, y está bajo Boost License: Range . Es una biblioteca de un encabezado, compatible con C ++ 03 y funciona a la perfección con bucles for basados ​​en rangos en C ++ 11 :)

Caracteristicas :

• ¡Un verdadero contenedor de acceso aleatorio con todas las campanas y silbidos!

• Los rangos se pueden comparar lexicográficamente.

• Dos funciones exist(devuelve bool) y find(devuelve iterador) para comprobar la existencia de un número.

• La biblioteca se prueba unitariamente mediante CATCH .

• Ejemplos de uso básico, trabajar con contenedores estándar, trabajar con algoritmos estándar y trabajar con rangos basados ​​en bucles for.

Aquí hay una introducción de un minuto . Finalmente, agradezco cualquier sugerencia sobre esta pequeña biblioteca.

Descubrí que boost::irangeera mucho más lento que el ciclo de enteros canónicos. Así que me decidí por la siguiente solución mucho más simple usando una macro de preprocesador:

#define RANGE(a, b) unsigned a=0; a<b; a++

Entonces puedes hacer un bucle como este:

for(RANGE(i, n)) {
    // code here
}

Este rango comienza automáticamente desde cero. Se podría ampliar fácilmente para empezar desde un número determinado.

Aquí hay una forma más simple que me está funcionando muy bien. ¿Existe algún riesgo en mi enfoque?

r_iteratores un tipo que se comporta, en la medida de lo posible, como un long int. Por lo tanto, muchos operadores, como ==y ++, simplemente pasan a long int. 'Expongo' el int largo subyacente a través de las conversiones operator long inty operator long int &.

#include <iostream>
using namespace std;

struct r_iterator {
        long int value;
        r_iterator(long int _v) : value(_v) {}
        operator long int () const { return value; }
        operator long int& ()      { return value; }
        long int operator* () const { return value; }
};
template <long int _begin, long int _end>
struct range {
        static r_iterator begin() {return _begin;}
        static r_iterator end  () {return _end;}
};
int main() {
        for(auto i: range<0,10>()) { cout << i << endl; }
        return 0;
}

( Editar: podemos hacer que los métodos sean rangeestáticos en lugar de const.)

Esto puede ser un poco tarde, pero acabo de ver esta pregunta y he estado usando esta clase por un tiempo:

#include <iostream>
#include <utility>
#include <stdexcept>

template<typename T, bool reverse = false> struct Range final {
    struct Iterator final{
        T value;
        Iterator(const T & v) : value(v) {}
        const Iterator & operator++() { reverse ? --value : ++value; return *this; }
        bool operator!=(const Iterator & o) { return o.value != value; }
        T operator*() const { return value; }
    };
    T begin_, end_;
    Range(const T & b, const T & e)  : begin_(b), end_(e) {
        if(b > e) throw std::out_of_range("begin > end");
    }

    Iterator begin() const { return reverse ? end_ -1 : begin_; }
    Iterator end() const { return reverse ? begin_ - 1: end_; }

    Range() = delete;
    Range(const Range &) = delete;
};

using UIntRange = Range<unsigned, false>;
using RUIntRange = Range<unsigned, true>;

Uso:

int main() {
    std::cout << "Reverse : ";
    for(auto i : RUIntRange(0, 10)) std::cout << i << ' ';
    std::cout << std::endl << "Normal : ";
    for(auto i : UIntRange(0u, 10u)) std::cout << i << ' ';
    std::cout << std::endl;
}

has intentado usar

template <class InputIterator, class Function>
   Function for_each (InputIterator first, InputIterator last, Function f);

La mayoría de las veces se ajusta a los requisitos.

P.ej

template<class T> void printInt(T i) {cout<<i<<endl;}
void test()
{
 int arr[] = {1,5,7};
 vector v(arr,arr+3);

 for_each(v.begin(),v.end(),printInt);

}

Tenga en cuenta que printInt puede reemplazarse OFC con una lambda en C ++ 0x. También podría ser una pequeña variación más de este uso (estrictamente para random_iterator)

 for_each(v.begin()+5,v.begin()+10,printInt);

Para iterador solo de Fwd

 for_each(advance(v.begin(),5),advance(v.begin(),10),printInt);

Puede generar fácilmente una secuencia creciente en C ++ 11 usando std :: iota ():

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>

template<typename T>
std::vector<T> range(T start, T end)
{
  std::vector<T> r(end+1-start, T(0));
  std::iota(r.begin(), r.end(), T(start));//increasing sequence
  return r;
}

int main(int argc, const char * argv[])
{
  for(auto i:range<int>(-3,5))
    std::cout<<i<<std::endl;

  return 0;
}