Cho phép lặp lại một vectơ nội bộ mà không rò rỉ việc thực hiện

Tôi có một lớp đại diện cho một danh sách những người.

class AddressBook
{
public:
  AddressBook();

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

Tôi muốn cho phép khách hàng lặp đi lặp lại trên vectơ của mọi người. Ý nghĩ đầu tiên tôi có chỉ đơn giản là:

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

Tuy nhiên, tôi không muốn rò rỉ các chi tiết triển khai cho khách hàng . Tôi có thể muốn duy trì một số bất biến nhất định khi vectơ được sửa đổi và tôi mất quyền kiểm soát các bất biến này khi tôi rò rỉ việc thực hiện.

Cách tốt nhất để cho phép lặp mà không rò rỉ nội bộ là gì?

cho phép lặp mà không rò rỉ các phần bên trong chính xác là những gì mẫu lặp lặp hứa hẹn. Tất nhiên đó chủ yếu là lý thuyết nên đây là một ví dụ thực tế:

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

Bạn cung cấp tiêu chuẩn beginvà endphương thức, giống như các chuỗi trong STL và thực hiện chúng đơn giản bằng cách chuyển tiếp đến phương thức của vectơ. Điều này không rò rỉ một số chi tiết triển khai cụ thể là bạn đang trả về một trình vòng lặp vector nhưng không có máy khách lành mạnh nào nên phụ thuộc vào điều đó vì vậy nó không phải là vấn đề đáng lo ngại. Tôi đã hiển thị tất cả các tình trạng quá tải ở đây nhưng tất nhiên bạn có thể bắt đầu bằng cách chỉ cung cấp phiên bản const nếu khách hàng không thể thay đổi bất kỳ mục nhập Mọi người. Sử dụng cách đặt tên tiêu chuẩn có lợi ích: bất kỳ ai đọc mã ngay lập tức đều biết rằng nó cung cấp phép lặp 'tiêu chuẩn' và như vậy hoạt động với tất cả các thuật toán phổ biến, phạm vi dựa trên các vòng lặp, v.v.

Nếu lặp đi lặp lại là tất cả những gì bạn cần, thì có lẽ một trình bao bọc xung quanh std::for_eachsẽ đủ:

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

Bạn có thể sử dụng thành ngữ pimpl và cung cấp các phương thức để lặp lại trên container.

Trong tiêu đề:

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

Trong nguồn:

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

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

Bằng cách này, nếu khách hàng của bạn sử dụng typedef từ tiêu đề, họ sẽ không nhận thấy loại container nào bạn đang sử dụng. Và các chi tiết thực hiện được ẩn hoàn toàn.

Người ta có thể cung cấp các chức năng thành viên:

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

Cho phép truy cập mà không để lộ chi tiết triển khai (như tiếp giáp) và sử dụng các chi tiết này trong một lớp lặp:

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

Lặp lại sau đó có thể được trả về bởi sổ địa chỉ như sau:

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

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

Có lẽ bạn cần phải bổ sung lớp lặp đi lặp lại với các đặc điểm, v.v. nhưng tôi nghĩ rằng điều này sẽ làm những gì bạn đã yêu cầu.

nếu bạn muốn thực hiện chính xác các chức năng từ std :: vector, hãy sử dụng kế thừa riêng như bên dưới và kiểm soát những gì được phơi bày.

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

Chỉnh sửa: Điều này không được đề xuất nếu bạn cũng muốn ẩn cấu trúc dữ liệu nội bộ, ví dụ: std :: vector