Có lớp phạm vi trong C ++ 11 để sử dụng với vòng lặp dựa trên phạm vi không?

Tôi thấy mình đã viết điều này chỉ một chút trước đây:

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

Và điều này cho phép tôi viết những thứ như thế này:

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

Bây giờ, tôi biết những gì tôi đã viết có lẽ không phải là mã tốt nhất. Và có thể có một cách để làm cho nó linh hoạt và hữu ích hơn. Nhưng đối với tôi, có vẻ như những thứ như thế này nên được tạo thành một phần của tiêu chuẩn.

Vậy là nó? Một số loại thư viện mới đã được thêm vào cho các trình vòng lặp trên một phạm vi số nguyên hoặc có thể là một phạm vi chung của các giá trị vô hướng được tính toán?

Thư viện tiêu chuẩn C ++ không có, nhưng Boost.Range có boost :: count_range , chắc chắn đủ điều kiện. Bạn cũng có thể sử dụng boost :: irange , tập trung hơn một chút về phạm vi.

Thư viện phạm vi của C ++ 20 sẽ cho phép bạn thực hiện điều này thông qua view::iota(start, end).

Theo như tôi biết, không có lớp nào như vậy trong C ++ 11.

Dù sao, tôi đã cố gắng cải thiện việc triển khai của bạn. Tôi đã làm cho nó không phải là khuôn mẫu , vì tôi không thấy bất kỳ lợi thế nào trong việc làm nó thành khuôn mẫu . Ngược lại, nó có một nhược điểm lớn: bạn không thể tạo phạm vi trong thời gian chạy, vì bạn cần biết các đối số mẫu tại chính thời gian biên dịch.

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

Đây là mã:

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

Mã kiểm tra:

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

Đầu ra:

10 11 12 13 14 15 16 17 18 19

Bản demo của Onine .

Tôi đã viết một thư viện được gọi rangecho cùng một mục đích ngoại trừ nó là phạm vi thời gian chạy và ý tưởng trong trường hợp của tôi đến từ Python. Tôi đã xem xét một phiên bản thời gian biên dịch, nhưng theo ý kiến ​​khiêm tốn của tôi, không có lợi thế thực sự để đạt được phiên bản thời gian biên dịch. Bạn có thể tìm thấy thư viện trên bitbucket và nó nằm trong Giấy phép Tăng cường: Phạm vi . Nó là một thư viện một tiêu đề, tương thích với C ++ 03 và hoạt động giống như sự quyến rũ với các vòng lặp for dựa trên phạm vi trong C ++ 11 :)

Các tính năng :

• Một thùng chứa truy cập ngẫu nhiên thực sự với tất cả các chuông và còi!

• Các phạm vi có thể được so sánh theo từ điển.

• Hai hàm exist(trả về bool) và find(trả về trình lặp) để kiểm tra sự tồn tại của một số.

• Thư viện được kiểm tra đơn vị bằng CATCH .

• Ví dụ về cách sử dụng cơ bản, làm việc với các vùng chứa tiêu chuẩn, làm việc với các thuật toán tiêu chuẩn và làm việc với các vòng lặp dựa trên phạm vi.

Đây là phần giới thiệu dài một phút . Cuối cùng, tôi hoan nghênh mọi gợi ý về thư viện nhỏ bé này.

Tôi thấy rằng boost::irangenó chậm hơn nhiều so với vòng lặp số nguyên chuẩn. Vì vậy, tôi đã giải quyết giải pháp đơn giản hơn nhiều sau đây bằng cách sử dụng macro bộ xử lý trước:

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

Sau đó, bạn có thể lặp lại như thế này:

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

Phạm vi này tự động bắt đầu từ 0. Nó có thể dễ dàng mở rộng để bắt đầu từ một số nhất định.

Đây là một biểu mẫu đơn giản hơn đang hoạt động tốt đối với tôi. Có bất kỳ rủi ro nào trong cách tiếp cận của tôi không?

r_iteratorlà một loại hoạt động, càng nhiều càng tốt, giống như một long int. Do đó, nhiều toán tử như ==và ++, chỉ cần chuyển qua long int. Tôi 'phơi bày' int dài cơ bản thông qua operator long intvà operator long int &chuyển đổi.

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

( Chỉnh sửa: - chúng ta có thể tạo các phương thức rangestatic thay vì const.)

Điều này có thể hơi muộn nhưng tôi vừa thấy câu hỏi này và tôi đã sử dụng lớp này một thời gian:

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

Sử dụng :

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

bạn đã thử sử dụng chưa

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

Hầu hết thời gian phù hợp với hóa đơn.

Ví dụ

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

}

Lưu ý rằng OFC có thể được thay thế printInt bằng lambda trong C ++ 0x. Ngoài ra, một biến thể nhỏ khác của cách sử dụng này có thể là (đối với random_iterator)

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

Đối với trình lặp chỉ Fwd

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

Bạn có thể dễ dàng tạo một chuỗi tăng dần trong C ++ 11 bằng cách sử dụng 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;
}