Consentire l'iterazione di un vettore interno senza perdere l'implementazione

Ho una classe che rappresenta un elenco di persone.

class AddressBook
{
public:
  AddressBook();

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

Voglio consentire ai clienti di scorrere sul vettore delle persone. Il primo pensiero che ho avuto è stato semplicemente:

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

Tuttavia, non voglio far trapelare i dettagli dell'implementazione al client . Potrei voler mantenere determinati invarianti quando il vettore viene modificato e perdo l'implementazione perdendo il controllo su questi invarianti.

Qual è il modo migliore per consentire l'iterazione senza perdite dagli interni?

consentire l'iterazione senza perdite all'interno è esattamente ciò che promette il modello iteratore. Naturalmente questa è principalmente la teoria, quindi ecco un esempio pratico:

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

Fornisci standard begine endmetodi, proprio come le sequenze nell'STL e le implementi semplicemente inoltrando al metodo del vettore. Questo perde alcuni dettagli di implementazione, vale a dire che stai restituendo un iteratore vettoriale, ma nessun client sano dovrebbe mai dipendere da quello, quindi non è un problema. Ho mostrato tutti i sovraccarichi qui, ma ovviamente puoi iniziare semplicemente fornendo la versione const se i client non dovrebbero essere in grado di modificare alcuna voce People. L'uso della denominazione standard ha vantaggi: chiunque legga il codice immediatamente sa che fornisce un'iterazione 'standard' e come tale funziona con tutti gli algoritmi comuni, intervallo basato su loop ecc.

Se l'iterazione è tutto ciò di cui hai bisogno, forse è std::for_eachsufficiente un wrapper :

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

È possibile utilizzare l'idioma del pimpl e fornire metodi per scorrere il contenitore.

Nell'intestazione:

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

Nella fonte:

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

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

In questo modo, se il client utilizza il typedef dall'intestazione, non noterà il tipo di contenitore che si sta utilizzando. E i dettagli di implementazione sono completamente nascosti.

Si potrebbero fornire funzioni membro:

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

Che consentono l'accesso senza esporre i dettagli dell'implementazione (come la contiguità) e utilizzarli all'interno di una classe iteratore:

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

Gli iteratori possono quindi essere restituiti dalla rubrica come segue:

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

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

Probabilmente avresti bisogno di arricchire la classe di iteratori con tratti ecc. Ma penso che questo farà quello che hai chiesto.

se si desidera l'implementazione esatta delle funzioni da std :: vector, utilizzare l'ereditarietà privata come di seguito e controllare ciò che è esposto.

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

Modifica: questo non è consigliato se si desidera nascondere anche la struttura di dati interna, ad esempio std :: vector