Consentire l'iterazione di un vettore interno senza perdite nell'implementazione

consentire l'iterazione senza perdite di internals è esattamente ciò che promette il pattern iteratore. Ovviamente questa è principalmente 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 metodi standard begin e end , proprio come le sequenze nell'STL e li implementano semplicemente inoltrando al metodo di vettore. Questo fa filtrare alcuni dettagli di implementazione e cioè che stai restituendo un iteratore di vettori, ma nessun client sano di mente dovrebbe mai dipendere da questo, quindi non è un problema. Ho mostrato tutti i sovraccarichi qui, ma ovviamente è possibile iniziare semplicemente fornendo la versione const se i client non dovrebbero essere in grado di modificare le voci di People. L'utilizzo della denominazione standard presenta vantaggi: chiunque leggendo il codice sa immediatamente che fornisce l'iterazione "standard" e come tale funziona con tutti gli algoritmi comuni, la gamma basata su cicli ecc.

Se l'iterazione è tutto ciò che serve, forse un wrapper attorno a std::for_each sarebbe sufficiente:

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

Puoi utilizzare l'idioma di Pimpl e fornire metodi per iterare sul 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 tuo cliente usa il typedef dall'intestazione, non noterà che tipo di contenitore stai usando. E i dettagli di implementazione sono completamente nascosti.

Uno potrebbe fornire funzioni membro:

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

Che consentono l'accesso senza esporre dettagli di implementazione (come 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 i tratti ecc., ma penso che ciò farà ciò che hai chiesto.

se vuoi l'esatta implementazione delle funzioni da std :: vector, usa l'ereditarietà privata come sotto e controlla 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 è raccomandato se si desidera nascondere anche la struttura interna dei dati, ad es. Std :: vector