Uygulama sızıntısı olmadan dahili bir vektörün yinelenmesine izin ver

İnsanların listesini temsil eden bir sınıfım var.

class AddressBook
{
public:
  AddressBook();

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

Müşterilerin insan vektörünü tekrar etmelerine izin vermek istiyorum. Sahip olduğum ilk düşünce basitti:

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

Ancak, uygulama detaylarını müşteriye sızdırmak istemiyorum . Vektör değiştirilirken bazı değişmezleri korumak isteyebilirim ve uygulamayı sızdırdığımda bu değişmezler üzerindeki kontrolümü kaybedebilirim.

İnternal sızıntı yapmadan yinelemeye izin vermenin en iyi yolu nedir?

İnternal sızıntı yapmadan yinelemeye izin ver , yineleyici kalıbın tam olarak vaat ettiği şeydir. Tabii ki esas olarak teori bu yüzden pratik bir örnek:

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'deki diziler gibi standart beginve endyöntemler sağlarsınız ve bunları vektör yöntemine ileterek uygularsınız. Bu, bir vektör yineleyiciyi döndürdüğünüz için bazı uygulama detaylarını sızdırıyor ancak aklı başında hiçbir müşteri buna bağlı olmamalı, bu yüzden bir endişe değil. Burada tüm aşırı yükleri gösterdim ancak elbette eğer müşterilerin herhangi bir Kişi girişini değiştirmemesi gerekiyorsa, sadece const sürümünü vererek başlayabilirsiniz. Standart isimlendirmenin faydaları vardır: kodu okuyan herkes derhal 'standart' yineleme sağladığını bilir ve bu şekilde tüm ortak algoritmalarla çalışır, döngülere dayalı aralık vb.

İhtiyacınız olan tek şey yineleme ise, belki etrafında bir sarmalayıcı std::for_eachyeterli olacaktır:

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 deyimini kullanabilir ve kabın üzerinde yineleme yapmak için yöntemler kullanabilirsiniz.

Başlıkta:

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

Kaynakta:

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

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

Bu şekilde, eğer müşteriniz başlıktan gelen typedef kullanıyorsa, ne tür bir konteyner kullandığınızı fark etmeyeceklerdir. Ve uygulama detayları tamamen gizlidir.

Biri üye işlevleri sağlayabilir:

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

Uygulama ayrıntılarını (bitişiklik gibi) göstermeden erişime izin veren ve bunları bir yineleyici sınıfında kullananlar:

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

Tekrarlayıcılar adres defterine aşağıdaki şekilde gönderilebilir:

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

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

Muhtemelen yineleyici sınıfını özellikler vb. İle çözmeniz gerekir, ancak bunun istediğiniz şeyi yapacağını düşünüyorum.

İşlevlerin std :: vector öğesinden tam olarak uygulanmasını istiyorsanız, aşağıdaki gibi özel miras kullanın ve maruz kaldıklarını kontrol edin.

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

Düzenleme: Dahili veri yapısını, örneğin std :: vector de gizlemek istiyorsanız, bu önerilmez.