Дозволити ітерацію внутрішнього вектора без протікання реалізації

У мене є клас, який представляє список людей.

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