구현을 누설하지 않고 내부 벡터의 반복을 허용

사람들의 목록을 나타내는 수업이 있습니다.

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)를 숨기려면 권장하지 않습니다.