วิธีทำให้ประเภทที่กำหนดเองของฉันทำงานกับ“ ช่วงตามลูป” ได้อย่างไร

เช่นเดียวกับหลาย ๆ คนในทุกวันนี้ฉันได้ลองใช้คุณสมบัติที่แตกต่างที่ C ++ 11 นำมาใช้ หนึ่งในรายการโปรดของฉันคือ "ช่วงตามลูป"

ฉันเข้าใจ:

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

เทียบเท่ากับ:

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

และนั่นbegin()ก็แค่ส่งคืนa.begin()สำหรับคอนเทนเนอร์มาตรฐาน

แต่สิ่งที่ถ้าผมต้องการที่จะทำให้ประเภทของฉันเอง "ช่วงที่ใช้สำหรับวง" -aware ?

ฉันควรจะมีความเชี่ยวชาญbegin()และend()?

หากประเภทที่กำหนดเองของฉันเป็นของเนมสเปซxmlฉันควรกำหนดxml::begin()หรือstd::begin()?

ในระยะสั้นสิ่งที่เป็นแนวทางในการทำเช่นนั้น?

มาตรฐานมีการเปลี่ยนแปลงตั้งแต่คำถาม (และคำตอบส่วนใหญ่) ถูกโพสต์ในการแก้ปัญหาของรายงานข้อบกพร่องนี้

วิธีที่จะทำให้for(:)ลูปทำงานกับประเภทของคุณXได้แล้วตอนนี้หนึ่งในสองวิธี:

• สร้างสมาชิกX::begin()และX::end()ส่งคืนสิ่งที่ทำหน้าที่เหมือนตัววนซ้ำ

• สร้างฟังก์ชั่นฟรีbegin(X&)และend(X&)ว่าสิ่งที่ผลตอบแทนที่ทำหน้าที่เหมือน iterator ใน namespace เดียวกันเป็นชนิดของคุณX.¹

และคล้ายกันสำหรับconstรูปแบบต่างๆ สิ่งนี้จะทำงานทั้งในคอมไพเลอร์ที่ใช้การเปลี่ยนแปลงรายงานข้อบกพร่องและคอมไพเลอร์ที่ไม่มี

วัตถุที่ส่งคืนไม่จำเป็นต้องเป็นตัววนซ้ำจริง ๆ การfor(:)วนซ้ำซึ่งแตกต่างจากส่วนใหญ่ของมาตรฐาน C ++ ถูกระบุให้ขยายเป็นสิ่งที่เทียบเท่ากับ :

for( range_declaration : range_expression )

กลายเป็น:

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

โดยที่ตัวแปรที่ขึ้นต้นด้วย__มีไว้สำหรับการแสดงออกเท่านั้นและbegin_exprและend_exprเป็นเวทย์มนตร์ที่เรียกใช้begin/ end.²

ข้อกำหนดเกี่ยวกับค่าส่งคืนเริ่มต้น / สิ้นสุดนั้นง่าย: คุณต้องโอเวอร์โหลดล่วงหน้า - ++ตรวจสอบให้แน่ใจว่านิพจน์การเริ่มต้นนั้นถูกต้องไบนารี!=ที่สามารถใช้ในบริบทบูลีน, ยูนารี*ที่ส่งคืนสิ่งที่คุณสามารถกำหนดค่าเริ่มต้นrange_declarationด้วย destructor

การทำเช่นนี้ในลักษณะที่ไม่เข้ากันได้กับตัววนซ้ำอาจเป็นความคิดที่ไม่ถูกต้องเนื่องจากการทำซ้ำในอนาคตของ C ++ อาจเป็นนักขี่ม้าที่ค่อนข้างจะทำลายรหัสของคุณหากคุณทำ

นอกจากนี้ยังมีเหตุผลที่การแก้ไขมาตรฐานในอนาคตจะอนุญาตend_exprให้ส่งคืนประเภทที่แตกต่างกันbegin_exprได้ สิ่งนี้มีประโยชน์ในการอนุญาตให้ประเมิน "lazy-end" (เช่นการตรวจจับการสิ้นสุดค่า null) ซึ่งง่ายต่อการปรับให้มีประสิทธิภาพเท่ากับการวนรอบ C ที่เขียนด้วยมือและข้อดีอื่น ๆ ที่คล้ายกัน

¹โปรดทราบว่าfor(:)ลูปจะเก็บชั่วคราวในauto&&ตัวแปรและส่งให้คุณในรูปแบบ lvalue คุณไม่สามารถตรวจพบว่าคุณทำซ้ำชั่วคราว (หรือ rvalue อื่น ๆ ); โอเวอร์โหลดดังกล่าวจะไม่ถูกเรียกโดยfor(:)ลูป ดู [stmt.ranged] 1.2-1.3 จาก n4527

²ทั้งโทรbegin/ endวิธีการหรือ ADL เท่านั้นค้นหาแบบของฟังก์ชั่นฟรีbegin/ end, หรือมายากลสำหรับการสนับสนุนอาร์เรย์แบบ C โปรดทราบstd::beginว่าไม่ได้เรียกว่าเว้นแต่จะrange_expressionส่งกลับวัตถุประเภทnamespace stdหรือขึ้นอยู่กับเดียวกัน

ใน C ++ 17 มีการอัปเดตนิพจน์ช่วงสำหรับ

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

ด้วยประเภทของ__beginและ__endได้รับการแยกออก

สิ่งนี้อนุญาตให้ตัววนซ้ำสิ้นสุดไม่เหมือนกับชนิดเริ่มต้น ประเภทตัววนซ้ำสุดท้ายของคุณสามารถเป็น "sentinel" ซึ่งรองรับเฉพาะ!=กับตัววนซ้ำเริ่มต้นเท่านั้น

ตัวอย่างที่ใช้งานได้จริงว่าทำไมสิ่งนี้มีประโยชน์คือตัววนซ้ำสุดท้ายของคุณสามารถอ่าน "ตรวจสอบchar*เพื่อดูว่ามันชี้ไปที่'0'" เมื่อ==ใช้ a char*หรือไม่ สิ่งนี้อนุญาตให้มีการแสดงออกในช่วง C ++ เพื่อสร้างรหัสที่ดีที่สุดเมื่อทำการวนซ้ำผ่านchar*บัฟเฟอร์ที่สิ้นสุดด้วยค่า 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;
  }
};

ตัวอย่างสดในคอมไพเลอร์โดยไม่มีการสนับสนุนแบบเต็ม C ++ 17; forขยายวงด้วยตนเอง

ฉันเขียนคำตอบของฉันเพราะบางคนอาจจะมีความสุขมากกว่ากับตัวอย่างชีวิตจริงที่เรียบง่ายโดยไม่มี STL

ฉันมีการใช้งาน data array แบบเรียบง่ายของตัวเองด้วยเหตุผลบางอย่างและฉันต้องการใช้ช่วงที่เป็นลูป นี่คือทางออกของฉัน:

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

จากนั้นตัวอย่างการใช้งาน:

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

ส่วนที่เกี่ยวข้องของมาตรฐานคือ 6.5.4 / 1:

ถ้า _RangeT เป็นประเภทคลาส unquali fi ed-ids เริ่มต้นและสิ้นสุดจะค้นหาในขอบเขตของคลาส _RangeT ราวกับว่าโดยการค้นหาการเข้าถึงการเข้าถึงสมาชิกระดับสมาชิก (3.4.5) และถ้าอย่างใดอย่างหนึ่ง (หรือทั้งสอง) declar nds ประกาศอย่างน้อยหนึ่งเริ่ม - expr และ end-expr คือ__range.begin()และ__range.end()ตามลำดับ

- มิฉะนั้น start-expr และ end-expr คือ begin(__range)และ end(__range)ตามลำดับโดยที่เริ่มต้นและสิ้นสุดถูกค้นหาด้วยการค้นหาอาร์กิวเมนต์ (3.4.2) สำหรับวัตถุประสงค์ของการค้นหาชื่อเนมสเปซ std คือเนมสเปซที่เชื่อมโยง

ดังนั้นคุณสามารถทำสิ่งใดสิ่งหนึ่งต่อไปนี้:

• กำหนด beginและendฟังก์ชั่นสมาชิก
• กำหนด beginและendฟังก์ชั่นอิสระที่จะพบได้โดย ADL (เวอร์ชั่นที่ง่าย: ใส่ไว้ในเนมสเปซเดียวกับคลาส)
• เชี่ยวชาญstd::beginและstd::end

std::beginเรียกbegin()ฟังก์ชันสมาชิกแล้วดังนั้นหากคุณใช้เพียงอย่างใดอย่างหนึ่งข้างต้นผลลัพธ์ก็ควรจะเหมือนกันไม่ว่าคุณจะเลือกแบบใด นั่นเป็นผลลัพธ์ที่เหมือนกันสำหรับ ranged-based สำหรับลูปและผลลัพธ์เดียวกันสำหรับโค้ดมรรตัยเพียงอย่างเดียวที่ไม่มีกฎการแก้ไขชื่อเวทมนต์ของตัวเองดังนั้นเพียงแค่ทำusing std::begin;begin(a)ตามมาด้วยการโทรไปอย่างไม่มีเงื่อนไข

หากคุณใช้ฟังก์ชั่นสมาชิกและ ADL แล้วช่วงตามลูปควรเรียกฟังก์ชั่นสมาชิกในขณะที่ปุถุชนเพียงจะเรียกฟังก์ชั่น ADL ดีที่สุดให้แน่ใจว่าพวกเขาทำสิ่งเดียวกันในกรณีนั้น!

หากสิ่งที่คุณเขียนใช้ส่วนติดต่อคอนเทนเนอร์แล้วมันจะมีbegin()และend()ฟังก์ชั่นสมาชิกแล้วซึ่งควรจะเพียงพอ ถ้าเป็นช่วงที่ไม่ใช่คอนเทนเนอร์ (ซึ่งเป็นความคิดที่ดีถ้ามันไม่เปลี่ยนรูปหรือถ้าคุณไม่รู้ขนาดด้านหน้า) คุณมีอิสระที่จะเลือก

ตัวเลือกที่คุณ lay out ทราบว่าคุณต้องไม่std::begin()เกิน คุณได้รับอนุญาตให้เชี่ยวชาญแม่แบบมาตรฐานสำหรับประเภทที่ผู้ใช้กำหนด แต่นอกเหนือจากนั้นการเพิ่มคำจำกัดความในเนมสเปซ std เป็นพฤติกรรมที่ไม่ได้กำหนด แต่อย่างไรก็ตามฟังก์ชั่นมาตรฐานที่เชี่ยวชาญนั้นเป็นตัวเลือกที่ไม่ดีถ้าเพียงเพราะการขาดความเชี่ยวชาญบางส่วนของฟังก์ชั่นหมายความว่าคุณสามารถทำได้สำหรับคลาสเดียวเท่านั้นไม่ใช่สำหรับเทมเพลตคลาส

ฉันควรจะเป็นผู้เชี่ยวชาญในการเริ่มต้น () และสิ้นสุด () หรือไม่

เท่าที่ฉันรู้นั่นก็เพียงพอแล้ว คุณต้องให้แน่ใจว่าการเพิ่มตัวชี้จะได้รับตั้งแต่ต้นจนจบ

ตัวอย่างถัดไป (มันหายไปรุ่น const ของการเริ่มต้นและสิ้นสุด) รวบรวมและทำงานได้ดี

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

นี่คืออีกตัวอย่างหนึ่งที่มี start / end เป็น function พวกเขาต้องอยู่ในเนมสเปซเดียวกันกับคลาสเนื่องจาก 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;
    }
}

ในกรณีที่คุณต้องการสำรองการวนซ้ำของคลาสโดยตรงกับสมาชิกstd::vectorหรือstd::mapนี่คือรหัสสำหรับ:

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

ที่นี่ฉันกำลังแบ่งปันตัวอย่างที่ง่ายที่สุดในการสร้างประเภทที่กำหนดเองซึ่งจะทำงานกับ " range-based for loop ":

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

หวังว่ามันจะเป็นประโยชน์สำหรับนักพัฒนามือใหม่อย่างฉัน: p :)
ขอบคุณ

คำตอบของ Chris Redford ก็ใช้ได้กับตู้คอนเทนเนอร์ของ Qt (แน่นอน) นี่คือการปรับ (สังเกตว่าฉันคืน a constBegin()ตามลำดับconstEnd()จากวิธีการ 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(); }
};

ฉันต้องการอธิบายบางส่วนของคำตอบของ @Steve Jessop ซึ่งตอนแรกฉันไม่เข้าใจ หวังว่ามันจะช่วย

std::beginเรียกbegin()ฟังก์ชันสมาชิกแล้วดังนั้นหากคุณใช้เพียงอย่างใดอย่างหนึ่งข้างต้นผลลัพธ์ก็ควรจะเหมือนกันไม่ว่าคุณจะเลือกแบบใด นั่นเป็นผลเหมือนกันสำหรับ ranged ที่ใช้สำหรับลูปและยังผลเดียวกันรหัสเพียงมนุษย์ที่ไม่ได้มีมนต์ขลังกฎความละเอียดชื่อของตัวเองดังนั้นก็ไม่ ตามมาด้วยการโทรไปอย่างไม่มีเงื่อนไขusing std::begin;begin(a)

หากคุณใช้ฟังก์ชั่นสมาชิก และ ฟังก์ชั่นADLแล้วช่วงตามลูปควรเรียกฟังก์ชั่นสมาชิกในขณะที่ปุถุชนเพียงจะเรียกฟังก์ชั่น ADL ดีที่สุดให้แน่ใจว่าพวกเขาทำสิ่งเดียวกันในกรณีนั้น!

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

• ถ้า ...
• หากrange_expressionเป็นการแสดงออกของประเภทชั้นเรียนCที่มีทั้งชื่อสมาชิกbeginและสมาชิกชื่อend(ไม่คำนึงถึงประเภทหรือการเข้าถึงของสมาชิกดังกล่าว) แล้วก็begin_exprคือ __range.begin() และend_exprเป็น__range.end();
• มิฉะนั้นbegin_exprคือbegin(__range)และend_exprคือend(__range)ซึ่งพบได้ผ่านการค้นหาที่ขึ้นอยู่กับอาร์กิวเมนต์ (ไม่ได้ทำการค้นหาที่ไม่ใช่ ADL)

สำหรับช่วงตามลูปฟังก์ชันสมาชิกจะถูกเลือกก่อน

แต่สำหรับ

using std::begin;
begin(instance);

ฟังก์ชั่น ADL ถูกเลือกก่อน

ตัวอย่าง:

#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.
//      }
}