Làm cách nào để tạo loại tùy chỉnh của tôi để hoạt động với các phạm vi dựa trên phạm vi của phạm vi phạm vi?

Giống như nhiều người ngày nay tôi đã thử các tính năng khác nhau mà C ++ 11 mang lại. Một trong những mục yêu thích của tôi là "phạm vi dựa trên phạm vi".

Tôi hiểu điều đó:

for(Type& v : a) { ... }

Tương đương với:

for(auto iv = begin(a); iv != end(a); ++iv)
{
  Type& v = *iv;
  ...
}

Và điều đó begin()chỉ đơn giản là trở lạia.begin() cho các container tiêu chuẩn.

Nhưng điều gì sẽ xảy ra nếu tôi muốn tạo loại tùy chỉnh "phạm vi dựa trên vòng lặp" của mình ?

Tôi có nên chỉ chuyên begin()vàend() ?

Nếu loại tùy chỉnh của tôi thuộc về không gian tên xml, tôi nên xác định xml::begin()hoặcstd::begin() ?

Tóm lại, các hướng dẫn để làm điều đó là gì?

Tiêu chuẩn đã được thay đổi kể từ khi câu hỏi (và hầu hết các câu trả lời) được đăng trong độ phân giải của báo cáo lỗi này .

Cách để tạo một for(:)vòng lặp hoạt động trên loại của bạn Xbây giờ là một trong hai cách:

• Tạo thành viên X::begin()và X::end()trả về một cái gì đó hoạt động như một trình vòng lặp

• Tạo một hàm miễn phí begin(X&)và end(X&)trả về một cái gì đó hoạt động như một trình vòng lặp, trong cùng một không gian tên với kiểu của bạn X.¹

Và tương tự cho constcác biến thể. Điều này sẽ làm việc cả trên các trình biên dịch thực hiện các thay đổi báo cáo lỗi và các trình biên dịch không.

Các đối tượng trả về không phải thực sự là các vòng lặp. Các for(:)vòng lặp, không giống như hầu hết các bộ phận của C ++ chuẩn, được quy định để mở rộng đến một cái gì đó tương đương với :

for( range_declaration : range_expression )

trở thành:

{
  auto && __range = range_expression ;
  for (auto __begin = begin_expr,
            __end = end_expr;
            __begin != __end; ++__begin) {
    range_declaration = *__begin;
    loop_statement
  }
}

trong đó các biến bắt đầu __chỉ để giải thích begin_exprvà end_exprlà phép thuật gọi begin/ end.²

Các yêu cầu về giá trị trả về bắt đầu / kết thúc rất đơn giản: Bạn phải quá tải trước ++, đảm bảo các biểu thức khởi tạo là hợp lệ, nhị phân !=có thể được sử dụng trong ngữ cảnh boolean, unary *trả về một cái gì đó bạn có thể gán - khởi tạo range_declarationvà hiển thị công khai phá hủy.

Làm như vậy theo cách không tương thích với iterator có lẽ là một ý tưởng tồi, vì các lần lặp lại trong tương lai của C ++ có thể tương đối khó khăn hơn về việc phá mã của bạn nếu bạn làm như vậy.

Bên cạnh đó, rất có khả năng một bản sửa đổi tương lai của tiêu chuẩn sẽ cho phép end_exprtrả lại một loại khác hơn begin_expr. Điều này hữu ích ở chỗ nó cho phép đánh giá "kết thúc lười biếng" (như phát hiện chấm dứt null) dễ dàng tối ưu hóa để có hiệu quả như vòng lặp C viết tay và các ưu điểm tương tự khác.

Lưu ý rằng for(:)các vòng lặp lưu trữ bất kỳ tạm thời nào trong một auto&&biến và chuyển nó cho bạn dưới dạng giá trị. Bạn không thể phát hiện nếu bạn đang lặp lại một giá trị tạm thời (hoặc giá trị khác); quá tải như vậy sẽ không được gọi bởi một for(:)vòng lặp. Xem [stmt. Sắp xếp] 1.2-1.3 từ n4527.

² Hoặc gọi begin/ endphương pháp, hoặc ADL chỉ tra cứu miễn phí chức năng begin/ end, hoặc ma thuật để hỗ trợ mảng C-phong cách. Lưu ý rằng std::beginkhông được gọi trừ khi range_expressiontrả về một đối tượng thuộc loại namespace stdhoặc phụ thuộc vào cùng.

Trong c ++ 17 biểu thức cho phạm vi đã được cập nhật

{
  auto && __range = range_expression ;
  auto __begin = begin_expr;
  auto __end = end_expr;
  for (;__begin != __end; ++__begin) {
    range_declaration = *__begin;
    loop_statement
  }
}

với các loại __beginvà __endđã được tách rời.

Điều này cho phép iterator kết thúc không cùng loại với bắt đầu. Loại trình lặp cuối của bạn có thể là "sentinel" chỉ hỗ trợ !=với loại trình lặp bắt đầu.

Một ví dụ thực tế về lý do tại sao điều này hữu ích là trình lặp cuối của bạn có thể đọc "kiểm tra xem bạn char*có xem nó '0'" khi ==với a char*. Điều này cho phép một biểu thức phạm vi C ++ tạo mã tối ưu khi lặp qua char*bộ đệm kết thúc null .

struct null_sentinal_t {
  template<class Rhs,
    std::enable_if_t<!std::is_same<Rhs, null_sentinal_t>{},int> =0
  >
  friend bool operator==(Rhs const& ptr, null_sentinal_t) {
    return !*ptr;
  }
  template<class Rhs,
    std::enable_if_t<!std::is_same<Rhs, null_sentinal_t>{},int> =0
  >
  friend bool operator!=(Rhs const& ptr, null_sentinal_t) {
    return !(ptr==null_sentinal_t{});
  }
  template<class Lhs,
    std::enable_if_t<!std::is_same<Lhs, null_sentinal_t>{},int> =0
  >
  friend bool operator==(null_sentinal_t, Lhs const& ptr) {
    return !*ptr;
  }
  template<class Lhs,
    std::enable_if_t<!std::is_same<Lhs, null_sentinal_t>{},int> =0
  >
  friend bool operator!=(null_sentinal_t, Lhs const& ptr) {
    return !(null_sentinal_t{}==ptr);
  }
  friend bool operator==(null_sentinal_t, null_sentinal_t) {
    return true;
  }
  friend bool operator!=(null_sentinal_t, null_sentinal_t) {
    return false;
  }
};

ví dụ trực tiếp trong trình biên dịch không có hỗ trợ C ++ 17 đầy đủ; forvòng lặp mở rộng bằng tay.

Tôi viết câu trả lời của mình vì một số người có thể hạnh phúc hơn với ví dụ thực tế đơn giản mà không có STL bao gồm.

Tôi có triển khai mảng dữ liệu đơn thuần của riêng mình vì một số lý do và tôi muốn sử dụng phạm vi dựa trên vòng lặp. Đây là giải pháp của tôi:

 template <typename DataType>
 class PodArray {
 public:
   class iterator {
   public:
     iterator(DataType * ptr): ptr(ptr){}
     iterator operator++() { ++ptr; return *this; }
     bool operator!=(const iterator & other) const { return ptr != other.ptr; }
     const DataType& operator*() const { return *ptr; }
   private:
     DataType* ptr;
   };
 private:
   unsigned len;
   DataType *val;
 public:
   iterator begin() const { return iterator(val); }
   iterator end() const { return iterator(val + len); }

   // rest of the container definition not related to the question ...
 };

Sau đó là ví dụ sử dụng:

PodArray<char> array;
// fill up array in some way
for(auto& c : array)
  printf("char: %c\n", c);

Phần có liên quan của tiêu chuẩn là 6.5.4 / 1:

nếu _RangeT là một loại lớp, các id-un-uni bắt đầu và kết thúc được tra cứu trong phạm vi của lớp _RangeT như thể bằng cách tra cứu truy cập của thành viên lớp (3.4.5) và nếu một (hoặc cả hai) ít nhất một khai báo, hãy bắt đầu - expr và end-expr lần lượt là __range.begin()và __range.end();

- nếu không, bắt đầu-expr và cuối expr là begin(__range)và end(__range), tương ứng, nơi bắt đầu và kết thúc đều nhìn lên với tra cứu luận phụ thuộc vào (3.4.2). Đối với mục đích tra cứu tên này, không gian tên std là một không gian tên được liên kết.

Vì vậy, bạn có thể thực hiện bất kỳ thao tác nào sau đây:

• xác định beginvà endchức năng thành viên
• định nghĩa beginvà endcác hàm miễn phí sẽ được tìm thấy bởi ADL (phiên bản đơn giản hóa: đặt chúng trong cùng một không gian tên với lớp)
• chuyên std::beginvàstd::end

std::beginbegin()dù sao cũng gọi hàm thành viên, vì vậy nếu bạn chỉ thực hiện một trong những điều trên, thì kết quả sẽ giống nhau cho dù bạn chọn cái nào. Đó là kết quả tương tự đối với các vòng lặp dựa trên phạm vi, và cũng là kết quả tương tự đối với mã xác thực không có quy tắc phân giải tên ma thuật của riêng nó, do đó, using std::begin;theo sau là một cuộc gọi không đủ tiêu chuẩn begin(a).

Tuy nhiên, nếu bạn triển khai các hàm thành viên và các hàm ADL, thì các vòng lặp dựa trên phạm vi sẽ gọi các hàm thành viên, trong khi đó, các chỉ số sẽ gọi các hàm ADL. Tốt nhất hãy chắc chắn rằng họ làm điều tương tự trong trường hợp đó!

Nếu điều bạn đang viết thực hiện giao diện container, thì nó sẽ có begin()và các end()chức năng thành viên đã đủ, điều đó là đủ. Nếu đó là một phạm vi không phải là một container (đó sẽ là một ý tưởng tốt nếu nó không thay đổi hoặc nếu bạn không biết kích thước lên phía trước), bạn có thể tự do lựa chọn.

Trong số các tùy chọn bạn đặt ra, lưu ý rằng bạn không được quá tải std::begin(). Bạn được phép chuyên môn hóa các mẫu tiêu chuẩn cho loại do người dùng xác định, nhưng ngoài ra, việc thêm định nghĩa vào không gian tên std là hành vi không xác định. Nhưng dù sao, các hàm tiêu chuẩn chuyên dụng là một lựa chọn kém nếu chỉ vì thiếu chuyên môn hóa một phần nghĩa là bạn chỉ có thể làm điều đó cho một lớp duy nhất, không phải cho một mẫu lớp.

Tôi có nên chỉ chuyên bắt đầu () và kết thúc ()?

Theo tôi biết, thế là đủ. Bạn cũng phải đảm bảo rằng việc tăng con trỏ sẽ nhận được từ đầu đến cuối.

Ví dụ tiếp theo (nó thiếu phiên bản const của bắt đầu và kết thúc) biên dịch và hoạt động tốt.

#include <iostream>
#include <algorithm>

int i=0;

struct A
{
    A()
    {
        std::generate(&v[0], &v[10], [&i](){  return ++i;} );
    }
    int * begin()
    {
        return &v[0];
    }
    int * end()
    {
        return &v[10];
    }

    int v[10];
};

int main()
{
    A a;
    for( auto it : a )
    {
        std::cout << it << std::endl;
    }
}

Đây là một ví dụ khác với hàm bắt đầu / kết thúc. Chúng phải ở trong cùng một không gian tên với lớp, vì ADL:

#include <iostream>
#include <algorithm>


namespace foo{
int i=0;

struct A
{
    A()
    {
        std::generate(&v[0], &v[10], [&i](){  return ++i;} );
    }

    int v[10];
};

int *begin( A &v )
{
    return &v.v[0];
}
int *end( A &v )
{
    return &v.v[10];
}
} // namespace foo

int main()
{
    foo::A a;
    for( auto it : a )
    {
        std::cout << it << std::endl;
    }
}

Trong trường hợp bạn muốn sao lưu trực tiếp một lớp lặp lại với lớp std::vectorhoặc std::mapthành viên của nó , đây là mã cho điều đó:

#include <iostream>
using std::cout;
using std::endl;
#include <string>
using std::string;
#include <vector>
using std::vector;
#include <map>
using std::map;


/////////////////////////////////////////////////////
/// classes
/////////////////////////////////////////////////////

class VectorValues {
private:
    vector<int> v = vector<int>(10);

public:
    vector<int>::iterator begin(){
        return v.begin();
    }
    vector<int>::iterator end(){
        return v.end();
    }
    vector<int>::const_iterator begin() const {
        return v.begin();
    }
    vector<int>::const_iterator end() const {
        return v.end();
    }
};

class MapValues {
private:
    map<string,int> v;

public:
    map<string,int>::iterator begin(){
        return v.begin();
    }
    map<string,int>::iterator end(){
        return v.end();
    }
    map<string,int>::const_iterator begin() const {
        return v.begin();
    }
    map<string,int>::const_iterator end() const {
        return v.end();
    }

    const int& operator[](string key) const {
        return v.at(key);
    }
    int& operator[](string key) {
        return v[key];
    } 
};


/////////////////////////////////////////////////////
/// main
/////////////////////////////////////////////////////

int main() {
    // VectorValues
    VectorValues items;
    int i = 0;
    for(int& item : items) {
        item = i;
        i++;
    }
    for(int& item : items)
        cout << item << " ";
    cout << endl << endl;

    // MapValues
    MapValues m;
    m["a"] = 1;
    m["b"] = 2;
    m["c"] = 3;
    for(auto pair: m)
        cout << pair.first << " " << pair.second << endl;
}

Ở đây, tôi đang chia sẻ ví dụ đơn giản nhất về việc tạo loại tùy chỉnh, sẽ hoạt động với " phạm vi dựa trên vòng lặp ":

#include<iostream>
using namespace std;

template<typename T, int sizeOfArray>
class MyCustomType
{
private:
    T *data;
    int indx;
public:
    MyCustomType(){
        data = new T[sizeOfArray];
        indx = -1;
    }
    ~MyCustomType(){
        delete []data;
    }
    void addData(T newVal){
        data[++indx] = newVal;
    }

    //write definition for begin() and end()
    //these two method will be used for "ranged based loop idiom"
    T* begin(){
        return &data[0];
    }
    T* end(){
        return  &data[sizeOfArray];
    }
};
int main()
{
    MyCustomType<double, 2> numberList;
    numberList.addData(20.25);
    numberList.addData(50.12);
    for(auto val: numberList){
        cout<<val<<endl;
    }
    return 0;
}

Hy vọng, nó sẽ hữu ích cho một số nhà phát triển người mới như tôi: p :)
Cảm ơn bạn.

Câu trả lời của Chris Redford cũng hoạt động cho các container Qt (tất nhiên). Đây là một sự thích ứng (thông báo tôi trả về a constBegin(), tương ứng constEnd()từ các phương thức const_iterator):

class MyCustomClass{
    QList<MyCustomDatatype> data_;
public:    
    // ctors,dtor, methods here...

    QList<MyCustomDatatype>::iterator begin() { return data_.begin(); }
    QList<MyCustomDatatype>::iterator end() { return data_.end(); }
    QList<MyCustomDatatype>::const_iterator begin() const{ return data_.constBegin(); }
    QList<MyCustomDatatype>::const_iterator end() const{ return data_.constEnd(); }
};

Tôi muốn giải thích một số phần trong câu trả lời của @Steve Jessop, mà lúc đầu tôi không hiểu. Hy vọng nó giúp.

std::beginbegin()dù sao cũng gọi hàm thành viên, vì vậy nếu bạn chỉ thực hiện một trong những điều trên, thì kết quả sẽ giống nhau cho dù bạn chọn cái nào. Đó là kết quả tương tự đối với các vòng lặp dựa trên phạm vi, và cũng là kết quả tương tự đối với mã xác thực không có quy tắc phân giải tên ma thuật của riêng nó, do đó, using std::begin;theo sau là một cuộc gọi không đủ tiêu chuẩn begin(a).

Tuy nhiên, nếu bạn triển khai các hàm thành viên và các hàm ADL , thì các vòng lặp dựa trên phạm vi sẽ gọi các hàm thành viên, trong khi đó, các chỉ số sẽ gọi các hàm ADL. Tốt nhất hãy chắc chắn rằng họ làm điều tương tự trong trường hợp đó!

https://en.cppreference.com/w/cpp/lingu/range-for :

• Nếu ...
• Nếu range_expressionlà một biểu thức của một loại lớp Ccó cả thành viên được đặt tên beginvà thành viên được đặt tên end(bất kể loại hoặc khả năng truy cập của thành viên đó), thì begin_exprlà __range.begin() và end_exprlà __range.end();
• Mặt khác, begin_expris begin(__range)và end_expris end(__range), được tìm thấy thông qua tra cứu phụ thuộc đối số (tra cứu không phải ADL không được thực hiện).

Đối với vòng lặp dựa trên phạm vi, các hàm thành viên được chọn trước tiên.

Nhưng cho

using std::begin;
begin(instance);

Các chức năng ADL được chọn đầu tiên.

Thí dụ:

#include <iostream>
#include <string>
using std::cout;
using std::endl;

namespace Foo{
    struct A{
        //member function version
        int* begin(){
            cout << "111";
            int* p = new int(3);  //leak I know, for simplicity
            return p;
        }
        int *end(){
            cout << "111";
            int* p = new int(4);
            return p;
        }
    };

    //ADL version

    int* begin(A a){
        cout << "222";
        int* p = new int(5);
        return p;
    }

    int* end(A a){
        cout << "222";
        int* p = new int(6);
        return p;
    }

}

int main(int argc, char *args[]){
//    Uncomment only one of two code sections below for each trial

//    Foo::A a;
//    using std::begin;
//    begin(a);  //ADL version are selected. If comment out ADL version, then member functions are called.


//      Foo::A a;
//      for(auto s: a){  //member functions are selected. If comment out member functions, then ADL are called.
//      }
}