ทำไมต้องใช้ตัววนซ้ำแทนดัชนีอาร์เรย์

รับโค้ดสองบรรทัดต่อไปนี้:

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

และนี่:

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

ฉันบอกว่าวิธีที่สองเป็นที่ต้องการ ทำไมถึงเป็นอย่างนี้

แบบฟอร์มแรกจะมีประสิทธิภาพก็ต่อเมื่อ vector.size () เป็นการดำเนินการที่รวดเร็ว สิ่งนี้เป็นจริงสำหรับเวกเตอร์ แต่ไม่ใช่สำหรับรายการ นอกจากนี้คุณวางแผนจะทำอะไรในร่างกายของลูป? หากคุณวางแผนที่จะเข้าถึงองค์ประกอบดังเช่น

T elem = some_vector[i];

ถ้าอย่างนั้นคุณก็สมมุติว่าภาชนะนั้นได้operator[](std::size_t)กำหนดไว้ นี่เป็นความจริงสำหรับเวกเตอร์ แต่ไม่ใช่สำหรับคอนเทนเนอร์อื่น

การใช้ตัววนซ้ำทำให้คุณใกล้ชิดกับความเป็นอิสระของคอนเทนเนอร์มากขึ้น คุณไม่ได้ตั้งสมมติฐานเกี่ยวกับความสามารถในการเข้าถึงแบบสุ่มหรือsize()การดำเนินการที่รวดเร็วเท่านั้นที่คอนเทนเนอร์มีความสามารถตัววนซ้ำ

คุณสามารถปรับปรุงโค้ดของคุณเพิ่มเติมโดยใช้อัลกอริธึมมาตรฐาน ทั้งนี้ขึ้นอยู่กับสิ่งที่คุณกำลังพยายามที่จะบรรลุคุณอาจเลือกที่จะใช้งานstd::for_each(), std::transform()และอื่น ๆ ด้วยการใช้อัลกอริธึมมาตรฐานแทนที่จะวนลูปอย่างชัดเจนคุณจะหลีกเลี่ยงการสร้างวงล้อใหม่ รหัสของคุณน่าจะมีประสิทธิภาพมากกว่า (เลือกอัลกอริธึมที่ถูกต้อง) แก้ไขและนำมาใช้ซ้ำได้

มันเป็นส่วนหนึ่งของกระบวนการปลูกฝัง C ++ ที่ทันสมัย การวนซ้ำเป็นวิธีเดียวที่จะย้ำคอนเทนเนอร์ส่วนใหญ่ดังนั้นคุณจึงใช้มันแม้กับเวกเตอร์เพื่อให้เข้ากับความคิดที่เหมาะสม อย่างจริงจังนั่นเป็นเหตุผลเดียวที่ฉันทำ - ฉันไม่คิดว่าฉันเคยเปลี่ยนเวกเตอร์ด้วยคอนเทนเนอร์ชนิดอื่น

ฉันคิดว่าดัชนีอาร์เรย์อ่านได้ง่ายขึ้น มันตรงกับไวยากรณ์ที่ใช้ในภาษาอื่น ๆ และไวยากรณ์ที่ใช้สำหรับอาร์เรย์ C แบบเก่า มันยังน้อย verbose ประสิทธิภาพควรล้างหากคอมไพเลอร์ของคุณดีและมีกรณีใด ๆ ที่มันสำคัญอยู่แล้ว

ถึงกระนั้นฉันก็ยังพบว่าตัวเองใช้ตัววนซ้ำกับเวกเตอร์บ่อยครั้ง ฉันเชื่อว่าตัววนซ้ำเป็นแนวคิดที่สำคัญดังนั้นฉันจึงโปรโมตมันทุกครั้งที่ทำได้

เพราะคุณไม่ได้ผูกรหัสของคุณกับการใช้งานบางอย่างของรายการ some_vector ถ้าคุณใช้ดัชนีอาเรย์มันจะต้องเป็นรูปแบบของอาเรย์ หากคุณใช้ตัววนซ้ำคุณสามารถใช้รหัสนั้นในการใช้งานรายการใด ๆ

ลองนึกภาพ some_vector ถูกนำไปใช้กับรายการที่ลิงก์ จากนั้นการร้องขอไอเท็มใน i-th ต้องการการดำเนินการ i ที่ต้องทำเพื่อสำรวจรายการโหนด ตอนนี้ถ้าคุณใช้ตัววนซ้ำพูดโดยทั่วไปมันจะพยายามอย่างเต็มที่เพื่อให้มีประสิทธิภาพมากที่สุดเท่าที่จะทำได้ (ในกรณีของรายการที่เชื่อมโยงมันจะรักษาตัวชี้ไปยังโหนดปัจจุบันและเลื่อนไปข้างหน้าในแต่ละรอบซ้ำ การดำเนินการเดียว)

ดังนั้นจึงมีสองสิ่ง:

• การใช้งานที่เป็นนามธรรม: คุณเพียงแค่ต้องการย้ำองค์ประกอบบางอย่างคุณไม่สนใจว่าจะทำอย่างไร
• ประสิทธิภาพ

ฉันจะเป็นผู้สนับสนุนปีศาจที่นี่และไม่แนะนำให้ทำซ้ำ สาเหตุหลักคือซอร์สโค้ดทั้งหมดที่ฉันได้ทำงานตั้งแต่การพัฒนาแอพพลิเคชั่นเดสก์ท็อปไปจนถึงการพัฒนาเกมฉันไม่จำเป็นต้องใช้ตัววนซ้ำ ตลอดเวลาที่พวกเขาไม่จำเป็นต้องใช้และประการที่สองข้อสมมติฐานที่ซ่อนอยู่และความยุ่งเหยิงของรหัสและการดีบักฝันร้ายที่คุณได้รับจากตัววนซ้ำทำให้พวกเขาเป็นตัวอย่างที่ดีที่จะไม่ใช้ในแอพพลิเคชั่นที่ต้องการความเร็ว

แม้กระทั่งจากจุดยืนการซ่อมบำรุง ไม่ใช่เพราะพวกเขา แต่เป็นเพราะนามแฝงทั้งหมดที่เกิดขึ้นเบื้องหลัง ฉันจะรู้ได้อย่างไรว่าคุณไม่ได้ใช้เวกเตอร์หรือรายการอาร์เรย์เสมือนของคุณที่ทำสิ่งที่แตกต่างไปจากมาตรฐานอย่างสิ้นเชิง ฉันรู้หรือไม่ว่าตอนนี้เป็นประเภทใดในขณะรันไทม์? คุณโอเวอร์โหลดโอเปอเรเตอร์ฉันไม่มีเวลาตรวจสอบซอร์สโค้ดทั้งหมดของคุณหรือไม่ ฉันจะรู้ว่า STL ของคุณใช้เวอร์ชั่นอะไรอยู่

ปัญหาต่อไปที่คุณได้รับจากการวนซ้ำนั้นเป็นสิ่งที่เป็นนามธรรม แต่ก็มีเว็บไซต์จำนวนมากที่พูดถึงเรื่องนี้โดยละเอียดกับพวกเขา

ขออภัยฉันยังไม่ได้และยังไม่เห็นจุดใด ๆ ในตัววนซ้ำ หากพวกเขาสรุปรายการหรือเวกเตอร์ออกไปจากคุณในความเป็นจริงคุณควรรู้แล้วว่าเวกเตอร์หรือรายการของคุณจัดการกับถ้าคุณไม่แล้วคุณจะต้องตั้งค่าตัวเองสำหรับการแก้จุดบกพร่องในอนาคต

คุณอาจต้องการใช้ตัววนซ้ำถ้าคุณจะเพิ่ม / ลบรายการไปยังเวกเตอร์ในขณะที่คุณวนซ้ำ

some_iterator = some_vector.begin(); 
while (some_iterator != some_vector.end())
{
    if (/* some condition */)
    {
        some_iterator = some_vector.erase(some_iterator);
        // some_iterator now positioned at the element after the deleted element
    }
    else
    {
        if (/* some other condition */)
        {
            some_iterator = some_vector.insert(some_iterator, some_new_value);
            // some_iterator now positioned at new element
        }
        ++some_iterator;
    }
}

หากคุณใช้ดัชนีคุณจะต้องสลับรายการขึ้น / ลงในอาร์เรย์เพื่อจัดการการแทรกและการลบ

การแยกความกังวล

มันดีมากที่จะแยกรหัสการวนซ้ำออกจากข้อกังวล 'หลัก' ของลูป มันเกือบจะเป็นการตัดสินใจออกแบบ

แท้จริงแล้วการวนซ้ำโดยดัชนีจะเชื่อมโยงคุณกับการใช้งานคอนเทนเนอร์ การขอคอนเทนเนอร์สำหรับตัววนซ้ำเริ่มต้นและสิ้นสุดจะเปิดใช้งานรหัสวนรอบสำหรับใช้กับประเภทคอนเทนเนอร์อื่น

นอกจากนี้ในstd::for_eachทางที่คุณบอกคอลเลกชันจะทำอย่างไรแทนที่จะถามบางสิ่งเกี่ยวกับภายในของมัน

มาตรฐาน 0x จะนำเสนอการปิดซึ่งจะทำให้วิธีการนี้ง่ายต่อการใช้งานมากขึ้น - ดูที่พลังการแสดงออกเช่น Ruby's [1..6].each { |i| print i; }...

ประสิทธิภาพ

แต่อาจมีปัญหาเรื่องการดูแลมากคือการใช้for_eachวิธีการนี้ทำให้มีโอกาสที่จะมีการวนซ้ำแบบขนาน - บล็อกเธรดของ Intelสามารถแจกจ่ายบล็อกโค้ดในจำนวนโปรเซสเซอร์ในระบบ!

หมายเหตุ: หลังจากค้นพบalgorithmsห้องสมุดและโดยเฉพาะอย่างยิ่งforeachฉันใช้เวลาสองหรือสามเดือนในการเขียนโอเปอเรเตอร์ตัวช่วยเล็ก ๆ 'helper' ซึ่งจะทำให้นักพัฒนาเพื่อนของคุณบ้าคลั่ง หลังจากเวลานี้ฉันกลับไปที่วิธีปฏิบัติ - ร่างเล็กวนไม่สมควรforeachอีกต่อไป :)

ต้องอ่านอ้างอิง iterators เป็นหนังสือ"STL ขยาย"

GoF มีย่อหน้าเล็ก ๆ เล็กน้อยในตอนท้ายของรูปแบบ Iterator ซึ่งพูดถึงการทำซ้ำของแบรนด์นี้ มันเรียกว่า 'ตัววนซ้ำภายใน' ลองดูที่นี่ด้วย

เพราะมันเป็นเชิงวัตถุมากขึ้น หากคุณกำลังทำซ้ำกับดัชนีคุณจะถือว่า:

a) วัตถุเหล่านั้นถูกจัดเรียง
b) วัตถุเหล่านั้นสามารถรับได้โดยดัชนี
c) ที่การเพิ่มขึ้นของดัชนีจะกระทบทุกรายการ
d) ดัชนีนั้นเริ่มต้นที่ศูนย์

ด้วยตัววนซ้ำคุณกำลังพูดว่า "ให้ทุกอย่างแก่ฉันเพื่อฉันจะได้ทำงานกับมัน" โดยไม่ทราบว่าการใช้งานพื้นฐานนั้นคืออะไร (ใน Java มีคอลเลกชันที่ไม่สามารถเข้าถึงได้ผ่านดัชนี)

นอกจากนี้ยังมีตัววนซ้ำไม่จำเป็นต้องกังวลเกี่ยวกับการออกนอกขอบเขตของอาร์เรย์

อีกสิ่งที่ดีเกี่ยวกับตัววนซ้ำคือการที่พวกเขาอนุญาตให้คุณแสดง (และบังคับใช้) ความชอบของคุณ ตัวอย่างนี้ทำให้แน่ใจได้ว่าคุณจะไม่เปลี่ยนแปลงเวกเตอร์ท่ามกลางวงของคุณ:

for(std::vector<Foo>::const_iterator pos=foos.begin(); pos != foos.end(); ++pos)
{
    // Foo & foo = *pos; // this won't compile
    const Foo & foo = *pos; // this will compile
}

นอกเหนือจากคำตอบที่ยอดเยี่ยมอื่น ๆ ทั้งหมด ... intอาจไม่ใหญ่พอสำหรับเวคเตอร์ของคุณ หากคุณต้องการใช้การจัดทำดัชนีให้ใช้size_typeสำหรับคอนเทนเนอร์ของคุณแทน:

for (std::vector<Foo>::size_type i = 0; i < myvector.size(); ++i)
{
    Foo& this_foo = myvector[i];
    // Do stuff with this_foo
}

ฉันควรจะชี้ให้เห็นว่าคุณสามารถโทรหา

std::for_each(some_vector.begin(), some_vector.end(), &do_stuff);

ตัววนซ้ำ STL ส่วนใหญ่อยู่ที่นั่นเพื่อให้อัลกอริทึม STL เช่นการเรียงลำดับสามารถเป็นคอนเทนเนอร์แบบอิสระ

หากคุณต้องการวนซ้ำรายการทั้งหมดในเวกเตอร์เพียงใช้สไตล์ลูปดัชนี

มันพิมพ์น้อยลงและง่ายต่อการแยกสำหรับมนุษย์ส่วนใหญ่ มันจะดีถ้า C ++ มีลูป foreach แบบง่ายโดยไม่ต้องลงน้ำด้วยเวทย์มนตร์เทมเพลต

for( size_t i = 0; i < some_vector.size(); ++i )
{
   T& rT = some_vector[i];
   // now do something with rT
}
'

ฉันไม่คิดว่ามันจะสร้างความแตกต่างได้มากสำหรับเวกเตอร์ ฉันชอบที่จะใช้ดัชนีตัวเองเพราะฉันคิดว่ามันอ่านง่ายขึ้นและคุณสามารถเข้าถึงแบบสุ่มเช่นการกระโดดไปข้างหน้า 6 รายการหรือกระโดดไปข้างหลังหากต้องการ

ฉันยังต้องการอ้างอิงถึงรายการในวงเช่นนี้จึงมีวงเล็บเหลี่ยมไม่มากรอบสถานที่:

for(size_t i = 0; i < myvector.size(); i++)
{
    MyClass &item = myvector[i];

    // Do stuff to "item".
}

การใช้ตัววนซ้ำอาจทำได้ดีถ้าคุณคิดว่าคุณอาจจำเป็นต้องแทนที่เวกเตอร์ด้วยรายการในบางจุดในอนาคตและมันก็ดูมีสไตล์มากขึ้นสำหรับ freaks STL แต่ฉันไม่สามารถคิดด้วยเหตุผลอื่นใด

แบบฟอร์มที่สองแสดงถึงสิ่งที่คุณกำลังทำอย่างแม่นยำมากขึ้น ในตัวอย่างของคุณคุณไม่สนใจคุณค่าของ i จริงๆ - ทั้งหมดที่คุณต้องการคือองค์ประกอบถัดไปในตัววนซ้ำ

หลังจากเรียนรู้เพิ่มเติมเล็กน้อยเกี่ยวกับเรื่องของคำตอบนี้ฉันรู้ว่ามันเป็นเรื่องเล็กน้อย ความแตกต่างระหว่างวงนี้:

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

และวงนี้:

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

ค่อนข้างน้อย อันที่จริงไวยากรณ์ของการทำลูปด้วยวิธีนี้ดูเหมือนจะเติบโตกับฉัน:

while (it != end){
    //do stuff
    ++it;
}

Iterators ทำการปลดล็อกคุณสมบัติการประกาศที่ทรงพลังพอสมควรและเมื่อรวมเข้ากับไลบรารีอัลกอริธึม STL คุณสามารถทำสิ่งที่ยอดเยี่ยมที่อยู่นอกขอบเขตของการจัดทำดัชนีอาร์เรย์

การจัดทำดัชนีต้องการการmulดำเนินการพิเศษ ตัวอย่างเช่นสำหรับvector<int> vการแปลงคอมไพเลอร์เข้าไปv[i]&v + sizeof(int) * i

ในระหว่างการทำซ้ำคุณไม่จำเป็นต้องทราบจำนวนรายการที่จะดำเนินการ คุณแค่ต้องการไอเท็มและผู้วนซ้ำทำสิ่งที่ดีมาก

ยังไม่มีใครพูดถึงว่าข้อดีข้อหนึ่งของดัชนีก็คือมันจะไม่กลายเป็นโมฆะเมื่อคุณผนวกเข้ากับคอนเทนเนอร์ที่ต่อเนื่องกันเช่น std::vectorคุณสามารถเพิ่มรายการลงในคอนเทนเนอร์ในระหว่างการทำซ้ำ

สามารถทำได้ด้วยตัววนซ้ำ แต่คุณต้องโทรreserve()จึงจำเป็นต้องรู้ว่าคุณจะต่อท้ายรายการกี่รายการ

จุดดีหลายอย่างแล้ว ฉันมีความคิดเห็นเพิ่มเติมเล็กน้อย:

1. สมมติว่าเรากำลังพูดถึงไลบรารีมาตรฐาน C ++ "vector" หมายถึงคอนเทนเนอร์การเข้าถึงแบบสุ่มที่มีการรับประกันของ C-array (การเข้าถึงแบบสุ่มรูปแบบหน่วยความจำ contiguos เป็นต้น) หากคุณพูดว่า 'some_container' คำตอบข้างต้นหลายคำจะแม่นยำกว่า (ความเป็นอิสระของคอนเทนเนอร์ ฯลฯ )

2. หากต้องการกำจัดการพึ่งพาการเพิ่มประสิทธิภาพคอมไพเลอร์คุณสามารถย้าย some_vector.size () ออกจากลูปในโค้ดที่จัดทำดัชนีดังนี้:

   const size_t numElems = some_vector.size ();
   สำหรับ (size_t i = 0; i 

3. วนซ้ำที่เพิ่มขึ้นล่วงหน้าเสมอและถือว่าการเพิ่มภายหลังเป็นกรณีพิเศษ

ดังนั้นการสมมติและทำดัชนีstd::vector<>เช่นคอนเทนเนอร์ไม่มีเหตุผลที่ดีที่จะชอบสิ่งใดสิ่งหนึ่งเหนือสิ่งอื่นใดโดยเรียงตามลำดับจะผ่านภาชนะ หากคุณต้องอ้างถึงดัชนี elemnent ที่เก่ากว่าหรือใหม่กว่าบ่อยครั้งเวอร์ชันที่จัดทำดัชนีจะมีความเหมาะสมมากกว่า

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

ฉันไม่ได้ใช้ตัววนซ้ำด้วยเหตุผลเดียวกันกับที่ฉันไม่ชอบคำสั่ง foreach เมื่อมีวงในหลายวงมันยากพอที่จะติดตามตัวแปรโกลบอล / สมาชิกโดยไม่ต้องจำค่าโลคัลและชื่อตัววนซ้ำทั้งหมดเช่นกัน สิ่งที่ฉันคิดว่ามีประโยชน์คือการใช้ดัชนีสองชุดสำหรับโอกาสต่าง ๆ :

for(int i=0;i<anims.size();i++)
  for(int j=0;j<bones.size();j++)
  {
     int animIndex = i;
     int boneIndex = j;


     // in relatively short code I use indices i and j
     ... animation_matrices[i][j] ...

     // in long and complicated code I use indices animIndex and boneIndex
     ... animation_matrices[animIndex][boneIndex] ...


  }

ฉันไม่ต้องการที่จะย่อสิ่งต่าง ๆ เช่น "animation_matrices [i]" ไปยังบางตัวอย่าง "anim_matrix" - ชื่อ-iterator แบบสุ่มบางอย่างเพราะคุณจะไม่สามารถเห็นได้อย่างชัดเจนว่าอาร์เรย์นี้มีต้นกำเนิดค่านี้มาจากอะไร

• ถ้าคุณชอบอยู่ใกล้กับโลหะ / ไม่ไว้วางใจรายละเอียดการใช้งานอย่าใช้ตัววนซ้ำ
• หากคุณเปลี่ยนประเภทคอลเลกชันเป็นประจำสำหรับประเภทอื่นในระหว่างการพัฒนาให้ใช้ตัววนซ้ำ
• หากคุณพบว่ามันยากที่จะจำได้ว่าจะย้ำคอลเลกชันประเภทต่าง ๆ ได้อย่างไร (บางทีคุณอาจมีหลายประเภทจากแหล่งข้อมูลภายนอกที่แตกต่างกันในการใช้งาน) ให้ใช้ตัววนซ้ำเพื่อรวมวิธีการต่างๆ สิ่งนี้ใช้เพื่อบอกว่าสลับรายการที่เชื่อมโยงกับรายการอาร์เรย์

จริงๆแล้วนั่นคือทั้งหมดที่มีให้มัน ไม่ใช่ว่าคุณจะได้รับความกระชับมากกว่าโดยเฉลี่ยและถ้าความกะทัดรัดเป็นเป้าหมายของคุณจริงๆคุณสามารถถอยกลับมาโครได้ตลอดเวลา

หากคุณมีการเข้าถึงC ++ 11คุณสมบัติแล้วคุณยังสามารถใช้ช่วงตามforห่วงสำหรับวนมากกว่าเวกเตอร์ของคุณ (หรือภาชนะอื่น ๆ ) ดังต่อไปนี้:

for (auto &item : some_vector)
{
     //do stuff
}

ประโยชน์ของการวนซ้ำนี้คือคุณสามารถเข้าถึงองค์ประกอบของเวกเตอร์ได้โดยตรงผ่านitemตัวแปรโดยไม่เสี่ยงต่อการทำให้ดัชนียุ่งเหยิงหรือทำพลาดเมื่อทำซ้ำตัววนซ้ำ นอกจากนี้ตัวยึดตำแหน่งautoจะป้องกันไม่ให้คุณต้องทำซ้ำประเภทขององค์ประกอบภาชนะซึ่งจะทำให้คุณเข้าใกล้โซลูชันที่ไม่ขึ้นกับคอนเทนเนอร์มากยิ่งขึ้น

หมายเหตุ:

• หากคุณต้องการดัชนีองค์ประกอบในลูปและoperator[]มีอยู่สำหรับคอนเทนเนอร์ของคุณ (และเร็วพอสำหรับคุณ) จากนั้นไปที่วิธีแรกได้ดีกว่า
• forไม่สามารถใช้การวนซ้ำแบบอิงช่วงได้เพื่อเพิ่ม / ลบองค์ประกอบลงใน / จากคอนเทนเนอร์ ถ้าคุณต้องการที่จะทำอย่างนั้นดีกว่ายึดติดกับโซลูชั่นที่กำหนดโดย Brian Matthews
• หากคุณไม่ต้องการที่จะเปลี่ยนองค์ประกอบในภาชนะของคุณแล้วคุณควรใช้คำหลักดังต่อไปนี้:constfor (auto const &item : some_vector) { ... }

ดียิ่งขึ้นกว่า "บอก CPU ว่าจะทำอย่างไร" (จำเป็น) คือ "บอกห้องสมุดสิ่งที่คุณต้องการ" (การทำงาน)

ดังนั้นแทนที่จะใช้ลูปคุณควรเรียนรู้อัลกอริทึมที่มีอยู่ใน stl

เพื่อความเป็นอิสระของภาชนะ

ฉันมักจะใช้ดัชนีอาร์เรย์เพราะแอปพลิเคชันของฉันจำนวนมากต้องการบางสิ่งเช่น "ภาพขนาดย่อที่แสดง" ดังนั้นฉันจึงเขียนสิ่งนี้:

some_vector[0].left=0;
some_vector[0].top =0;<br>

for (int i = 1; i < some_vector.size(); i++)
{

    some_vector[i].left = some_vector[i-1].width +  some_vector[i-1].left;
    if(i % 6 ==0)
    {
        some_vector[i].top = some_vector[i].top.height + some_vector[i].top;
        some_vector[i].left = 0;
    }

}

การใช้งานทั้งสองถูกต้อง แต่ฉันต้องการให้วง 'for' เนื่องจากเราตัดสินใจใช้ Vector และไม่ใช่คอนเทนเนอร์อื่นการใช้ดัชนีจะเป็นตัวเลือกที่ดีที่สุด การใช้ตัววนซ้ำกับเวกเตอร์จะสูญเสียประโยชน์อย่างมากจากการมีวัตถุในบล็อกหน่วยความจำต่อเนื่องซึ่งช่วยให้เข้าถึงได้ง่าย

ฉันรู้สึกว่าไม่มีคำตอบที่นี่อธิบายว่าทำไมฉันชอบ iterator เป็นแนวคิดทั่วไปมากกว่าการจัดทำดัชนีลงในภาชนะ โปรดทราบว่าประสบการณ์ส่วนใหญ่ของฉันในการใช้ตัววนซ้ำไม่ได้มาจากภาษา C ++ แต่มาจากภาษาการเขียนโปรแกรมระดับสูงเช่น Python

อินเทอร์เฟซตัววนซ้ำกำหนดข้อกำหนดที่น้อยลงสำหรับผู้บริโภคในฟังก์ชั่นของคุณซึ่งช่วยให้ผู้บริโภคสามารถทำอะไรได้มากขึ้น

หากสิ่งที่คุณต้องมีเพื่อให้สามารถส่งต่อย้ำนักพัฒนาที่ไม่ได้ จำกัด อยู่กับการใช้ภาชนะที่จัดทำดัชนี - พวกเขาสามารถใช้ชั้นใดการดำเนินการoperator++(T&), และoperator*(T)operator!=(const &T, const &T)

#include <iostream>
template <class InputIterator>
void printAll(InputIterator& begin, InputIterator& end)
{
    for (auto current = begin; current != end; ++current) {
        std::cout << *current << "\n";
    }
}

// elsewhere...

printAll(myVector.begin(), myVector.end());

อัลกอริทึมของคุณใช้ได้กับกรณีที่คุณต้องการ - วนซ้ำเวกเตอร์ - แต่มันยังมีประโยชน์สำหรับแอปพลิเคชันที่คุณไม่จำเป็นต้องคาดหมาย:

#include <random>

class RandomIterator
{
private:
    std::mt19937 random;
    std::uint_fast32_t current;
    std::uint_fast32_t floor;
    std::uint_fast32_t ceil;

public:
    RandomIterator(
        std::uint_fast32_t floor = 0,
        std::uint_fast32_t ceil = UINT_FAST32_MAX,
        std::uint_fast32_t seed = std::mt19937::default_seed
    ) :
        floor(floor),
        ceil(ceil)
    {
        random.seed(seed);
        ++(*this);
    }

    RandomIterator& operator++()
    {
        current = floor + (random() % (ceil - floor));
    }

    std::uint_fast32_t operator*() const
    {
        return current;
    }

    bool operator!=(const RandomIterator &that) const
    {
        return current != that.current;
    }
};

int main()
{
    // roll a 1d6 until we get a 6 and print the results
    RandomIterator firstRandom(1, 7, std::random_device()());
    RandomIterator secondRandom(6, 7);
    printAll(firstRandom, secondRandom);

    return 0;
}

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

Iterators ยังยืมตัวให้ตกแต่ง ผู้ใช้สามารถเขียนตัววนซ้ำซึ่งใช้ตัววนซ้ำในตัวสร้างและขยายการทำงาน:

template<class InputIterator, typename T>
class FilterIterator
{
private:
    InputIterator internalIterator;

public:
    FilterIterator(const InputIterator &iterator):
        internalIterator(iterator)
    {
    }

    virtual bool condition(T) = 0;

    FilterIterator<InputIterator, T>& operator++()
    {
        do {
            ++(internalIterator);
        } while (!condition(*internalIterator));

        return *this;
    }

    T operator*()
    {
        // Needed for the first result
        if (!condition(*internalIterator))
            ++(*this);
        return *internalIterator;
    }

    virtual bool operator!=(const FilterIterator& that) const
    {
        return internalIterator != that.internalIterator;
    }
};

template <class InputIterator>
class EvenIterator : public FilterIterator<InputIterator, std::uint_fast32_t>
{
public:
    EvenIterator(const InputIterator &internalIterator) :
        FilterIterator<InputIterator, std::uint_fast32_t>(internalIterator)
    {
    }

    bool condition(std::uint_fast32_t n)
    {
        return !(n % 2);
    }
};


int main()
{
    // Rolls a d20 until a 20 is rolled and discards odd rolls
    EvenIterator<RandomIterator> firstRandom(RandomIterator(1, 21, std::random_device()()));
    EvenIterator<RandomIterator> secondRandom(RandomIterator(20, 21));
    printAll(firstRandom, secondRandom);

    return 0;
}

แม้ว่าของเล่นเหล่านี้อาจดูธรรมดา แต่ก็ไม่ยากที่จะจินตนาการว่าการใช้ iterators และ iterator decorator ทำสิ่งที่ทรงพลังด้วยอินเตอร์เฟสที่เรียบง่าย - การตกแต่ง iterator ไปข้างหน้าอย่างเดียวของผลลัพธ์ฐานข้อมูลด้วย iterator ซึ่งสร้างวัตถุจำลองจากผลลัพธ์เดียวเช่น . รูปแบบเหล่านี้เปิดใช้งานการวนซ้ำที่ไม่มีประสิทธิภาพของหน่วยความจำและด้วยตัวกรองเช่นเดียวกับที่ฉันเขียนไว้ด้านบน

ส่วนหนึ่งของพลังของเทมเพลต C ++ คืออินเทอร์เฟซตัววนซ้ำของคุณเมื่อนำไปใช้กับอาร์เรย์ C ที่มีความยาวคงที่การสลายตัวของเลขคณิตตัวชี้ที่เรียบง่ายและมีประสิทธิภาพทำให้เป็นนามธรรมที่ไม่มีค่าใช้จ่ายอย่างแท้จริง