Döngüler için aralığa dayalı olarak kullanılmak üzere C ++ 11'de bir aralık sınıfı var mı?

Biraz önce kendimi bunu yazarken buldum:

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

Bu da şöyle şeyler yazmama izin veriyor:

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

Şimdi, yazdığımın belki de en iyi kod olmadığını biliyorum. Ve belki onu daha esnek ve kullanışlı hale getirmenin bir yolu vardır. Ama bana öyle geliyor ki, bunun gibi bir şey standardın bir parçası olmalıydı.

Öyle mi? Bir tam sayı aralığında yineleyiciler için bir tür yeni kitaplık eklendi mi, yoksa genel bir hesaplanmış skaler değerler aralığı mı?

C ++ standart kitaplığında bir tane yoktur, ancak Boost.Range kesinlikle uygun olan boost :: counting_range'e sahiptir . Ayrıca , kapsamı biraz daha odaklı olan boost :: irange'ı da kullanabilirsiniz .

C ++ 20'nin aralık kitaplığı, bunu aracılığıyla yapmanıza izin verecektir view::iota(start, end).

Bildiğim kadarıyla C ++ 11'de böyle bir sınıf yok.

Her neyse, uygulamanızı iyileştirmeye çalıştım. Ben yapılan numune olmayan herhangi görmüyorum olarak, avantaj o yapımında şablona . Aksine, büyük bir dezavantajı vardır: derleme zamanında şablon argümanlarını bilmeniz gerektiğinden, çalışma zamanında aralığı oluşturamazsınız.

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

İşte kod:

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

Test kodu:

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

Çıktı:

10 11 12 13 14 15 16 17 18 19

Onine demosu .

rangeBir çalışma zamanı aralığı olması dışında tamamen aynı amaç için çağrılan bir kitaplık yazdım ve benim durumumdaki fikir Python'dan geldi. Derleme zamanı sürümünü düşünmüştüm, ancak mütevazi görüşüme göre derleme zamanı sürümünü elde etmenin gerçek bir avantajı yok. Kitaplığı bitbucket'ta bulabilirsiniz ve Yükseltme Lisansı: Aralık altındadır . C ++ 03 ile uyumlu, tek başlıklı bir kitaplıktır ve C ++ 11'deki aralık tabanlı döngülerle cazibe gibi çalışır :)

Özellikler :

• Tüm zil ve ıslıklarla gerçek bir rastgele erişimli konteyner!

• Aralıklar sözlükbilimsel olarak karşılaştırılabilir.

• Bir sayının varlığını kontrol etmek için iki işlev exist(bool döndürür) ve find(yineleyici döndürür).

• Kitaplık, CATCH kullanılarak birim testine tabi tutulmuştur .

• Temel kullanım örnekleri, standart konteynerlerle çalışma, standart algoritmalarla çalışma ve döngüler için aralık tabanlı çalışma.

İşte bir dakikalık bir giriş . Son olarak, bu küçük kitaplık hakkında herhangi bir öneriye açığım.

Bunun boost::irangekanonik tamsayı döngüsünden çok daha yavaş olduğunu buldum . Bu yüzden, bir önişlemci makrosu kullanarak aşağıdaki çok daha basit çözüme karar verdim:

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

O zaman şu şekilde döngü yapabilirsiniz:

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

Bu aralık otomatik olarak sıfırdan başlar. Belirli bir sayıdan başlamak için kolayca genişletilebilir.

İşte benim için güzel çalışan daha basit bir form. Yaklaşımımda herhangi bir risk var mı?

r_iteratormümkün olduğunca a gibi davranan bir türdür long int. Gibi nedenle birçok operatör ==ve ++basitçe için geçmesi long int. Temel uzun int'i operator long intve operator long int &dönüşümleri aracılığıyla 'açığa çıkarırım' .

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

( Düzenleme: - rangeconst yerine statik yöntemler yapabiliriz .)

Bu biraz geç olabilir ama bu soruyu yeni gördüm ve bir süredir bu dersi kullanıyorum:

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

Kullanım:

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

kullanmayı denedin mi

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

Çoğu zaman faturaya uyuyor.

Örneğin

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'in OFC'nin C ++ 0x'deki bir lambda ile değiştirilebileceğini unutmayın. Ayrıca bu kullanımın küçük bir varyasyonu daha olabilir (kesinlikle random_iterator için)

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

Yalnızca Fwd yineleyici için

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

C ++ 11'de std :: iota () kullanarak kolayca artan bir dizi oluşturabilirsiniz:

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