Разрешить итерацию внутреннего вектора без утечки реализации

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

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, и реализуете их, просто перенаправляя в метод вектора. Это приводит к утечке некоторых деталей реализации, а именно, что вы возвращаете векторный итератор, но ни один здравомыслящий клиент никогда не должен зависеть от этого, так что это не является проблемой. Я показал все перегрузки здесь, но, конечно, вы можете начать с предоставления константной версии, если клиенты не смогут изменять какие-либо записи сотрудников. Использование стандартного именования имеет свои преимущества: любой, кто читает код, сразу же знает, что он обеспечивает «стандартную» итерацию и, как таковой, работает со всеми распространенными алгоритмами, диапазоном на основе циклов и т. Д.

Если итерация - это все, что вам нужно, то, возможно, 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