Zezwól na iterację wektora wewnętrznego bez wycierania implementacji

Mam klasę reprezentującą listę osób.

class AddressBook
{
public:
  AddressBook();

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

Chcę pozwolić klientom na iterację po wektorze ludzi. Pierwszą myślą, którą miałem, było po prostu:

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

Nie chcę jednak ujawniać klientowi szczegółów implementacji . Mogę chcieć zachować pewne niezmienniki, gdy wektor jest modyfikowany, i tracę kontrolę nad tymi niezmiennikami, gdy wyciekam z implementacji.

Jaki jest najlepszy sposób na iterację bez wycieku elementów wewnętrznych?

zezwolenie na iterację bez wycieku elementów wewnętrznych jest dokładnie tym, co obiecuje wzór iteratora. Oczywiście jest to głównie teoria, więc oto praktyczny przykład:

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

Podajesz standard begini endmetody, podobnie jak sekwencje w STL i implementujesz je po prostu przekazując do metody wektorowej. To przecieka niektóre szczegóły implementacji, a mianowicie, że zwracasz iterator wektorowy, ale żaden rozsądny klient nigdy nie powinien na tym polegać, więc nie jest to problemem. Pokazałem tutaj wszystkie przeciążenia, ale oczywiście możesz zacząć od podania stałej wersji, jeśli klienci nie będą mogli zmieniać żadnych wpisów People. Korzystanie ze standardowego nazewnictwa ma zalety: każdy, kto czyta kod, od razu wie, że zapewnia „standardową” iterację i jako taki działa ze wszystkimi popularnymi algorytmami, zasięgiem opartym na pętlach itp.

Jeśli iteracja jest wszystko, czego potrzeba, to może owinięcie wokół std::for_eachwystarczy:

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

Możesz użyć idiomu pimpl i podać metody iteracji po kontenerze.

W nagłówku:

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

W źródle:

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

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

W ten sposób, jeśli twój klient użyje typedef z nagłówka, nie zauważy, jakiego rodzaju kontenera używasz. A szczegóły implementacji są całkowicie ukryte.

Można zapewnić funkcje członkowskie:

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

Które umożliwiają dostęp bez ujawniania szczegółów implementacji (takich jak ciągłość) i wykorzystują je w klasie iteratora:

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

Iteratory mogą być następnie zwrócone przez książkę adresową w następujący sposób:

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

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

Prawdopodobnie będziesz musiał uzupełnić klasę iteratora o cechy itp., Ale myślę, że spełni to, o co prosiłeś.

jeśli chcesz dokładnej implementacji funkcji ze std :: vector, użyj prywatnego dziedziczenia jak poniżej i kontroluj, co jest widoczne.

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

Edycja: Nie jest to zalecane, jeśli chcesz również ukryć wewnętrzną strukturę danych, tj. Std :: vector