Permitir iteração de um vetor interno sem vazar a implementação

Eu tenho uma classe que representa uma lista de pessoas.

class AddressBook
{
public:
  AddressBook();

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

Eu quero permitir que os clientes iterem sobre o vetor de pessoas. O primeiro pensamento que tive foi simplesmente:

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

No entanto, não quero vazar os detalhes de implementação para o cliente . Talvez eu queira manter certos invariantes quando o vetor é modificado e perco o controle sobre esses invariantes quando vazo a implementação.

Qual é a melhor maneira de permitir a iteração sem vazar os internos?

permitir a iteração sem vazar os internos é exatamente o que o padrão do iterador promete. Claro que isso é principalmente teoria, então aqui está um exemplo prático:

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

Você fornece padrões begine endmétodos, assim como seqüências no STL e os implementa simplesmente encaminhando para o método do vetor. Isso vaza alguns detalhes da implementação, ou seja, você está retornando um iterador de vetor, mas nenhum cliente sensato jamais deve depender disso, portanto isso não é uma preocupação. Eu mostrei todas as sobrecargas aqui, mas é claro que você pode começar apenas fornecendo a versão const se os clientes não puderem alterar nenhuma entrada de Pessoas. O uso da nomeação padrão traz benefícios: quem lê o código imediatamente sabe que ele fornece iteração 'padrão' e, como tal, trabalha com todos os algoritmos comuns, com base em intervalos para loops etc.

Se a iteração é tudo que você precisa, talvez um wrapper std::for_eachseja suficiente:

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

Você pode usar o idioma pimpl e fornecer métodos para iterar sobre o contêiner.

No cabeçalho:

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

Na fonte:

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

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

Dessa forma, se seu cliente usar o typedef do cabeçalho, ele não perceberá que tipo de contêiner você está usando. E os detalhes da implementação estão completamente ocultos.

Pode-se fornecer funções-membro:

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

Que permitem o acesso sem expor detalhes da implementação (como contiguidade) e os utilizam em uma classe de iterador:

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

Os iteradores podem ser retornados pelo catálogo de endereços da seguinte maneira:

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

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

Você provavelmente precisaria detalhar a classe do iterador com características etc., mas acho que isso fará o que você pediu.

se você deseja uma implementação exata das funções do std :: vector, use a herança privada como abaixo e controle o que está exposto.

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

Edit: Isso não é recomendado se você também deseja ocultar a estrutura de dados interna, isto é, std :: vector