実装をリークすることなく、内部ベクトルの反復を許可します

人々のリストを表すクラスがあります。

class AddressBook
{
public:
  AddressBook();

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

クライアントが人々のベクトルを反復処理できるようにします。私が持っていた最初の考えは単純でした：

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

しかしながら、 実装の詳細をクライアントに漏らしたくありません。ベクトルが変更されたときに特定の不変式を維持したい場合があり、実装をリークするとこれらの不変式に対する制御が失われます。

内部をリークすることなく反復を許可する最良の方法は何ですか？

内部をリークすることなく反復を許可することは、イテレータパターンが約束するとおりです。もちろん、それは主に理論なので、ここに実用的な例があります：

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

STLのシーケンスと同じように、標準beginとendメソッドを提供し、ベクターのメソッドに転送するだけでそれらを実装します。これはいくつかの実装の詳細を漏らします。つまり、ベクトルイテレータを返しますが、健全なクライアントがそれに依存することはないので、気にする必要はありません。ここではすべてのオーバーロードを示しましたが、もちろん、クライアントがPeopleエントリを変更できないようにする必要がある場合は、constバージョンを指定するだけで開始できます。標準のネーミングを使用することには利点があります。コードを読んでいる人はすぐに「標準」の反復を提供することを知っているため、すべての一般的なアルゴリズム、範囲ベースのループなどで動作します。

繰り返しが必要な場合は、おそらくラッパーでstd::for_each十分です：

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

pimpl idiomを使用して、コンテナーを反復処理するメソッドを提供できます。

ヘッダー内：

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

ソースで：

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

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

このように、クライアントがヘッダーのtypedefを使用する場合、使用しているコンテナの種類に気付かないでしょう。そして、実装の詳細は完全に隠されています。

メンバー関数を提供できます：

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

実装の詳細（連続性など）を公開せずにアクセスを許可し、イテレータクラス内でこれらを使用します。

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

その後、アドレス帳によって次のようにイテレータが返されます。

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

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

おそらく、イテレータクラスを特性などで具体化する必要がありますが、これはあなたが求めたことを行うと思います。

std :: vectorからの関数の正確な実装が必要な場合は、以下のようにプライベート継承を使用し、公開されるものを制御します。

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

編集：内部データ構造、つまりstd :: vectorも非表示にする場合、これは推奨されません。