범위 기반 for 루프와 함께 사용하기위한 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).

내가 아는 한 C ++ 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 1314 15 16 17 18 19

Onine 데모 .

range런타임 범위라는 점을 제외하고는 정확히 동일한 목적으로 호출되는 라이브러리를 작성 했으며 제 경우 아이디어는 Python에서 나왔습니다. 나는 컴파일 타임 버전을 고려했지만, 겸손한 견해로는 컴파일 타임 버전을 얻는 것이 실질적인 이점이 없다고 생각합니다. bitbucket에서 라이브러리를 찾을 수 있으며 Boost License : Range 아래에 있습니다. 있습니다. C ++ 03과 호환되는 단일 헤더 라이브러리이며 C ++ 11의 범위 기반 for 루프에서 매력처럼 작동합니다. :)

특징 :

• 모든 종소리와 휘파람이있는 진정한 랜덤 액세스 컨테이너!

• 범위는 사전 식으로 비교할 수 있습니다.

• 두 가지 함수 exist(부울 반환) 및find (반복자 반환) 숫자의 존재를 확인합니다.

• 라이브러리는 CATCH를 사용하여 단위 테스트됩니다. .

• 기본 사용법의 예, 표준 컨테이너 작업, 표준 알고리즘 작업 및 for 루프 기반 범위 작업.

다음은 1 분 소개 입니다. 마지막으로이 작은 라이브러리에 대한 제안을 환영합니다.

나는 그것이 boost::irange표준 정수 루프보다 훨씬 느리다는 것을 발견했습니다 . 그래서 전 처리기 매크로를 사용하여 다음과 같은 훨씬 더 간단한 솔루션을 결정했습니다.

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

그런 다음 다음과 같이 반복 할 수 있습니다.

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

이 범위는 자동으로 0부터 시작됩니다. 주어진 번호에서 시작하도록 쉽게 확장 할 수 있습니다.

다음은 나를 위해 잘 작동하는 더 간단한 양식입니다. 내 접근 방식에 위험이 있습니까?

r_iterator가능한 한 많이 long int. 같은 따라서 많은 사업자 ==와는 ++, 단순히로 통과 long int. operator long int및 operator long int &변환을 통해 기본 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;
}

( 편집 : -우리는 rangeconst 대신 static 메서드를 만들 수 있습니다 .)

이것은 조금 늦을 수도 있지만 방금이 질문을 보았고 잠시 동안이 수업을 사용하고 있습니다.

#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는 C ++ 0x에서 람다로 OFC를 대체 할 수 있습니다. 또한이 사용법의 한 가지 더 작은 변형은 (엄격히 random_iterator의 경우)

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

Fwd 전용 반복자의 경우

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

std :: iota ()를 사용하여 C ++ 11에서 증가하는 시퀀스를 쉽게 생성 할 수 있습니다.

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