允许内部向量的迭代而不会泄漏实现

我有一堂课代表一个人的名单。

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

您提供标准begin和end方法，就像STL中的序列一样，只需转发到vector的方法即可实现它们。这确实泄漏了一些实现细节，即您将返回向量迭代器，但任何理智的客户端都不应依赖于此，因此imo不必担心。我在这里显示了所有重载，但是如果客户端不应该更改任何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惯用语，并提供迭代容器的方法。

在标题中：

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），则不建议这样做