อนุญาตการวนซ้ำของเวกเตอร์ภายในโดยไม่มีการรั่วไหลของการใช้งาน

ฉันมีชั้นเรียนที่แสดงถึงรายชื่อของผู้คน

class AddressBook
{
public:
  AddressBook();

private:
  std::vector<People> people;
}

ฉันต้องการอนุญาตให้ลูกค้าทำซ้ำเวกเตอร์ของผู้คน ความคิดแรกที่ฉันมีก็คือ:

std::vector<People> & getPeople { return people; }

แต่ฉันไม่ต้องการที่จะรั่วไหลรายละเอียดการดำเนินการให้กับลูกค้า ฉันอาจต้องการรักษาค่าคงที่บางอย่างเมื่อมีการแก้ไขเวกเตอร์และฉันสูญเสียการควบคุมค่าคงที่เหล่านี้เมื่อฉันรั่วการใช้งาน

วิธีที่ดีที่สุดในการอนุญาตให้ทำซ้ำโดยไม่รั่วไหลภายในคืออะไร?

อนุญาตให้ทำซ้ำโดยไม่รั่วภายในเป็นสิ่งที่รูปแบบตัววนซ้ำสัญญา แน่นอนว่าส่วนใหญ่เป็นทฤษฎีดังนั้นนี่คือตัวอย่างที่ใช้งานได้จริง:

class AddressBook
{
  using peoples_t = std::vector<People>;
public:
  using iterator = peoples_t::iterator;
  using const_iterator = peoples_t::const_iterator;

  AddressBook();

  iterator begin() { return people.begin(); }
  iterator end() { return people.end(); }
  const_iterator begin() const { return people.begin(); }
  const_iterator end() const { return people.end(); }
  const_iterator cbegin() const { return people.cbegin(); }
  const_iterator cend() const { return people.cend(); }

private:
  peoples_t people;
};

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

หากการวนซ้ำเป็นสิ่งที่คุณต้องการบางทีการล้อมรอบstd::for_eachอาจพอเพียง:

class AddressBook
{
public:
  AddressBook();

  template <class F>
  void for_each(F f) const
  {
    std::for_each(begin(people), end(people), f);
  }

private:
  std::vector<People> people;
};

คุณสามารถใช้pimpl สำนวนและให้วิธีการย้ำมากกว่าภาชนะ

ในส่วนหัว:

typedef People* PeopleIt;

class AddressBook
{
public:
  AddressBook();


  PeopleIt begin();
  PeopleIt begin() const;
  PeopleIt end();
  PeopleIt end() const;

private:
  struct Imp;
  std::unique_ptr<Imp> pimpl;
};

ในแหล่งที่มา:

struct AddressBook::Imp
{
  std::vector<People> people;
};

PeopleIt AddressBook::begin()
{
  return &pimpl->people[0];
}

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

หนึ่งสามารถให้ฟังก์ชั่นสมาชิก:

size_t Count() const
People& Get(size_t i)

ซึ่งอนุญาตการเข้าถึงโดยไม่เปิดเผยรายละเอียดการใช้งาน (เช่นความต่อเนื่อง) และใช้สิ่งเหล่านี้ภายในคลาสตัววนซ้ำ:

class Iterator
{
    AddressBook* addressBook_;
    size_t index_;

public:
    Iterator(AddressBook& addressBook, size_t index=0) 
    : addressBook_(&addressBook), index_(index) {}

    People& operator*()
    {
        return addressBook_->Get(index_);
    }

    Iterator& operator ++ ()
    {
       ++index_;
       return *this;
    }

    bool operator != (const Iterator& i) const
    {
        assert(addressBook_ == i.addressBook_);
        return index_ != i.index_;
    }
};

ผู้ทำซ้ำสามารถส่งคืนโดยสมุดรายชื่อดังนี้:

AddressBook::Iterator AddressBook::begin()
{
    return Iterator(this);
}

AddressBook::Iterator AddressBook::end()
{
    return Iterator(this, Count());
}

คุณอาจต้องทำให้คลาสตัววนซ้ำมีลักษณะอื่น ๆ แต่ฉันคิดว่าสิ่งนี้จะทำในสิ่งที่คุณถาม

หากคุณต้องการใช้งานฟังก์ชั่นที่แน่นอนจาก std :: vector ให้ใช้การสืบทอดส่วนตัวดังต่อไปนี้และควบคุมสิ่งที่เปิดเผย

template <typename T>
class myvec : private std::vector<T>
{
public:
    using std::vector<T>::begin;
    using std::vector<T>::end;
    using std::vector<T>::push_back;
};

แก้ไข: สิ่งนี้ไม่แนะนำถ้าคุณต้องการซ่อนโครงสร้างข้อมูลภายในเช่น std :: vector