Permitir la iteración de un vector interno sin filtrar la implementación

Tengo una clase que representa una lista de personas.

class AddressBook
{
public:
  AddressBook();

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

Quiero permitir que los clientes repitan el vector de las personas. El primer pensamiento que tuve fue simplemente:

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

Sin embargo, no quiero filtrar los detalles de implementación al cliente . Es posible que desee mantener ciertos invariantes cuando se modifica el vector, y pierdo el control sobre estos invariantes cuando pierdo la implementación.

¿Cuál es la mejor manera de permitir la iteración sin filtrar las partes internas?

Permitir la iteración sin filtrar las partes internas es exactamente lo que promete el patrón iterador. Por supuesto, eso es principalmente teoría, así que aquí hay un ejemplo práctico:

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

Usted proporciona estándares beginy endmétodos, al igual que las secuencias en el STL, y los implementa simplemente reenviando al método vectorial Esto filtra algunos detalles de implementación, es decir, que está devolviendo un iterador de vectores, pero ningún cliente sensato debería depender de eso, por lo que no es una preocupación. He mostrado todas las sobrecargas aquí, pero por supuesto, puede comenzar simplemente proporcionando la versión constante si los clientes no pueden cambiar ninguna entrada de Personas. El uso de la nomenclatura estándar tiene beneficios: cualquiera que lea el código inmediatamente sabe que proporciona una iteración 'estándar' y, como tal, funciona con todos los algoritmos comunes, rango basado en bucles, etc.

Si la iteración es todo lo que necesita, entonces quizás sea std::for_eachsuficiente un envoltorio :

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

Puede usar el idioma pimpl y proporcionar métodos para iterar sobre el contenedor.

En el encabezado:

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

En la fuente:

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

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

De esta manera, si su cliente utiliza el typedef del encabezado, no notará qué tipo de contenedor está utilizando. Y los detalles de implementación están completamente ocultos.

Se podrían proporcionar funciones miembro:

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

Lo que permite el acceso sin exponer detalles de implementación (como contigüidad) y usarlos dentro de una clase 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_;
    }
};

Los iteradores pueden ser devueltos por la libreta de direcciones de la siguiente manera:

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

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

Probablemente necesites completar la clase de iterador con rasgos, etc., pero creo que esto hará lo que has pedido.

si desea la implementación exacta de funciones de std :: vector, use la herencia privada como se muestra a continuación y controle lo que está expuesto.

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

Editar: Esto no se recomienda si también desea ocultar la estructura de datos interna, es decir, std :: vector