Чи існує клас діапазону в C ++ 11 для використання з діапазоном на основі циклів?

Я нещодавно написав це:

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

І це дозволяє мені писати такі речі:

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

Тепер я знаю, що написав, можливо, не найкращий код. І, можливо, є спосіб зробити його більш гнучким і корисним. Але мені здається, що щось подібне повинно було стати частиною стандарту.

Так це? Чи була додана якась нова бібліотека для ітераторів для діапазону цілих чисел, чи, можливо, загальний діапазон обчислених скалярних значень?

Стандартна бібліотека C ++ не має такої, але Boost.Range має boost :: counting_range , що, безумовно, відповідає. Ви також можете використовувати boost :: irange , який є трохи більш орієнтованим за обсягом.

Бібліотека діапазонів C ++ 20 дозволить зробити це через view::iota(start, end).

Наскільки мені відомо, такого класу в С ++ 11 немає.

У всякому разі, я намагався покращити вашу реалізацію. Я зробив це не шаблон , тому що я не бачу жодної переваги в створенні цього шаблону . Навпаки, у нього є один головний недолік: те, що ви не можете створити діапазон під час виконання, оскільки вам потрібно знати аргументи шаблону під час компіляції.

//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!

Ось код:

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

Код тесту:

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

Вихід:

10 11 12 13 14 15 16 17 18 19

Онема демонстрація .

Я написав бібліотеку rangeз цією ж метою, за винятком діапазону часу виконання, і в моєму випадку ідея прийшла від Python. Я розглядав версію під час компіляції, але, на мій скромний погляд, немає реальної переваги отримати версію за час компіляції. Ви можете знайти бібліотеку в бітбукеті, і вона знаходиться в розділі Boost License: Range . Це одноголовна бібліотека, сумісна з C ++ 03 і працює як шарм із діапазоном для циклів на C ++ 11 :)

Особливості :

• Справжній контейнер з випадковим доступом з усіма дзвіночками!

• Діапазони можна порівняти лексикографічно.

• Дві функції exist(повертає bool) і find(повертає ітератор) для перевірки існування числа.

• Бібліотека перевірена одиницею за допомогою CATCH .

• Приклади базового використання, робота зі стандартними контейнерами, робота зі стандартними алгоритмами та робота з діапазоном на основі циклів.

Ось однохвилинне вступ . Нарешті, я вітаю будь-які пропозиції щодо цієї крихітної бібліотеки.

Я виявив, що boost::irangeце набагато повільніше, ніж цілий цілий цикл канонічних. Тож я зупинився на наступному набагато простішому рішенні за допомогою макроса препроцесора:

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

Тоді ви можете зробити цикл так:

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

Цей діапазон автоматично починається від нуля. Можна легко розширити, щоб почати з заданого числа.

Ось простіша форма, яка добре працює для мене. Чи є в моєму підході якісь ризики?

r_iteratorце тип, який максимально поводиться як а long int. Тому багато операторів, таких як ==і ++, просто проходять через long int. Я 'розкриваю' основний довгий Int через конверсії operator long intта 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;
}

( Редагувати: - ми можемо зробити методи rangeстатичних замість const.)

Це може бути трохи пізно, але я щойно побачив це питання, і я вже деякий час використовую цей клас:

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

Використання:

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

ви намагалися використовувати

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

Більшу частину часу відповідає законопроекту.

Напр

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

}

Зауважте, що printInt можна OFC замінити лямбда в C ++ 0x. Також може бути ще одна невелика варіація цього використання (строго для random_iterator)

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

Для ітератора лише Fwd

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

Ви можете легко генерувати зростаючу послідовність у C ++ 11, використовуючи 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;
}