Autoriser l'itération d'un vecteur interne sans fuite de l'implémentation

J'ai une classe qui représente une liste de personnes.

class AddressBook
{
public:
  AddressBook();

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

Je veux permettre aux clients d'itérer sur le vecteur des personnes. La première pensée que j'ai eue était simplement:

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

Cependant, je ne veux pas divulguer les détails de l'implémentation au client . Je peux vouloir conserver certains invariants lorsque le vecteur est modifié, et je perds le contrôle de ces invariants lorsque je fuit l'implémentation.

Quelle est la meilleure façon de permettre l'itération sans fuir les internes?

permettre l'itération sans fuite des internes est exactement ce que le modèle d'itérateur promet. Bien sûr, c'est principalement de la théorie, alors voici un exemple pratique:

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

Vous fournissez des standards beginet des endméthodes, tout comme les séquences dans la STL et les implémentez simplement en les transmettant à la méthode du vecteur. Cela laisse fuir certains détails d'implémentation, à savoir que vous retournez un itérateur vectoriel, mais aucun client sensé ne devrait jamais en dépendre, donc ce n'est pas un problème. J'ai montré toutes les surcharges ici, mais bien sûr, vous pouvez commencer par fournir la version const si les clients ne doivent pas pouvoir modifier les entrées People. L'utilisation de la dénomination standard présente des avantages: toute personne lisant le code sait immédiatement qu'il fournit une itération `` standard '' et, en tant que tel, fonctionne avec tous les algorithmes courants, la plage basée sur les boucles, etc.

Si l'itération est tout ce dont vous avez besoin, alors peut-être qu'un wrapper std::for_eachsuffirait:

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

Vous pouvez utiliser l'idiome pimpl et fournir des méthodes pour parcourir le conteneur.

Dans l'en-tête:

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

Dans la source:

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

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

De cette façon, si votre client utilise le typedef de l'en-tête, il ne remarquera pas le type de conteneur que vous utilisez. Et les détails de mise en œuvre sont complètement cachés.

On pourrait fournir des fonctions membres:

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

Qui permettent l'accès sans exposer les détails d'implémentation (comme la contiguïté) et les utilisent au sein d'une classe d'itérateur:

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

Les itérateurs peuvent ensuite être retournés par le carnet d'adresses comme suit:

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

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

Vous auriez probablement besoin d'étoffer la classe des itérateurs avec des traits, etc. mais je pense que cela fera ce que vous avez demandé.

si vous voulez une implémentation exacte des fonctions de std :: vector, utilisez l'héritage privé comme ci-dessous et contrôlez ce qui est exposé.

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

Modifier: Ceci n'est pas recommandé si vous souhaitez également masquer la structure de données interne, c'est-à-dire std :: vector