Izinkan iterasi vektor internal tanpa membocorkan implementasi

Saya memiliki kelas yang mewakili daftar orang.

class AddressBook
{
public:
  AddressBook();

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

Saya ingin memungkinkan klien untuk beralih pada vektor orang. Pikiran pertama yang saya miliki hanyalah:

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

Namun, saya tidak ingin membocorkan detail implementasi ke klien . Saya mungkin ingin mempertahankan invarian tertentu ketika vektor dimodifikasi, dan saya kehilangan kendali atas invarian ini ketika saya membocorkan implementasinya.

Apa cara terbaik untuk memungkinkan iterasi tanpa membocorkan internal?

memungkinkan iterasi tanpa membocorkan internal adalah persis apa yang dijanjikan pola iterator. Tentu saja itu terutama teori jadi di sini adalah contoh praktis:

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

Anda memberikan standar begindan endmetode, seperti urutan dalam STL dan menerapkannya hanya dengan meneruskan ke metode vektor. Ini tidak membocorkan beberapa detail implementasi yaitu bahwa Anda mengembalikan vektor iterator tetapi tidak ada klien waras yang harus bergantung pada hal itu sehingga itu juga bukan masalah. Saya telah menunjukkan semua kelebihan di sini, tetapi tentu saja Anda bisa mulai dengan hanya menyediakan versi const jika klien tidak dapat mengubah entri People. Menggunakan penamaan standar memiliki manfaat: siapa pun yang membaca kode segera tahu itu memberikan iterasi 'standar' dan karena itu bekerja dengan semua algoritma umum, rentang berdasarkan untuk loop dll.

Jika iterasi adalah semua yang Anda butuhkan, maka mungkin pembungkus std::for_eachsudah cukup:

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

Anda dapat menggunakan idiom jerawat , dan memberikan metode untuk beralih di atas wadah.

Di tajuk:

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

Dalam sumber:

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

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

Dengan cara ini, jika klien Anda menggunakan typedef dari header, mereka tidak akan melihat jenis wadah yang Anda gunakan. Dan detail implementasi sepenuhnya tersembunyi.

Satu dapat menyediakan fungsi anggota:

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

Yang memungkinkan akses tanpa memaparkan detail implementasi (seperti kedekatan) dan menggunakannya dalam kelas iterator:

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

Iterator kemudian dapat dikembalikan oleh buku alamat sebagai berikut:

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

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

Anda mungkin perlu menyempurnakan kelas iterator dengan sifat-sifat dll, tetapi saya pikir ini akan melakukan apa yang Anda minta.

jika Anda ingin implementasi fungsi yang tepat dari std :: vector, gunakan warisan pribadi seperti di bawah ini dan kontrol apa yang terbuka.

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

Sunting: Ini tidak direkomendasikan jika Anda juga ingin menyembunyikan struktur data internal yaitu std :: vector