มีคลาสเรนจ์ใน C ++ 11 สำหรับใช้กับ range ตามลูปหรือไม่?

ฉันพบว่าตัวเองเขียนสิ่งนี้เมื่อไม่นานมานี้:

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 :: count_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 13 14 15 16 17 18 19

สาธิต onine

ฉันเขียนไลบรารีที่เรียกrangeเพื่อวัตถุประสงค์เดียวกันทุกประการยกเว้นว่าเป็นช่วงเวลาทำงานและแนวคิดในกรณีของฉันมาจาก Python ฉันถือว่าเป็นเวอร์ชันคอมไพล์ไทม์ แต่ในความเห็นที่ต่ำต้อยของฉันไม่มีประโยชน์ที่แท้จริงที่จะได้รับเวอร์ชันเวลาคอมไพล์ คุณสามารถค้นหาห้องสมุด bitbucket และมันก็อยู่ภายใต้ใบอนุญาต Boost: ช่วง เป็นไลบรารีส่วนหัวเดียวเข้ากันได้กับ C ++ 03 และใช้งานได้อย่างมีเสน่ห์ด้วย range-based สำหรับลูปใน C ++ 11 :)

คุณสมบัติ :

• ภาชนะสุ่มที่แท้จริงพร้อมระฆังและนกหวีด!

• ช่วงสามารถเปรียบเทียบได้ตามศัพท์

• สองฟังก์ชั่นexist(ส่งคืนบูล) และfind(ส่งคืนตัววนซ้ำ) เพื่อตรวจสอบการมีอยู่ของตัวเลข

• ห้องสมุดเป็นหน่วยทดสอบโดยใช้ที่จับได้

• ตัวอย่างการใช้งานพื้นฐานการทำงานกับคอนเทนเนอร์มาตรฐานการทำงานกับอัลกอริทึมมาตรฐานและการทำงานกับช่วงที่อิงกับลูป

นี่คือการแนะนำหนึ่งนาที สุดท้ายนี้ฉันยินดีรับข้อเสนอแนะเกี่ยวกับห้องสมุดเล็ก ๆ นี้

ฉันพบว่า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แบบคงที่แทนค่าคงที่)

อาจจะช้าไปหน่อย แต่ฉันเพิ่งเห็นคำถามนี้และฉันใช้คลาสนี้มาระยะหนึ่งแล้ว:

#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 iterator เท่านั้น

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