Cách dễ nhất để tạo một trình vòng lặp tuần hoàn (bộ tuần hoàn)?

Question

Tôi có một đối tượng mà tôi muốn đi du lịch trong một vòng lặp liên tục trong một trò chơi. Tôi có một loạt tọa độ trong một số std::vector mà tôi muốn sử dụng làm điểm tham chiếu.

Có cách nào để tạo std::vector<T>::iterator tuần hoàn (còn được gọi là người lưu hành) không? Điều tốt nhất tôi có thể đưa ra là có hai vòng lặp và sau đó bất cứ khi nào trình vòng lặp đầu tiên bị kiệt sức gán cho nó giá trị của giá trị thứ hai (sẽ không được sử dụng để làm bất kỳ điều gì khác) nhưng tôi thậm chí không chắc chắn sẽ làm việc - liệu toán tử gán có sao chép bất cứ thứ gì mà trình vòng lặp đang sử dụng để giữ chỉ mục hay nó sẽ chỉ được tham chiếu (và do đó sẽ vô dụng sau vòng thứ hai)?

Tôi muốn đối tượng di chuyển điểm tham chiếu mãi mãi (trừ khi nó bị hủy nhưng điều đó không xảy ra trong phương thức đó), nhưng trình lặp sẽ chỉ được gọi một lần cho mỗi khung và phải quay lại để tôi có thể cập nhật các đối tượng trong trò chơi.

Giải pháp phải hoạt động trên trình biên dịch gcc và microsoft (nếu không thể viết nó theo chuẩn C++).

Answer 1

Ok, bây giờ vấn đề của bạn là rõ ràng hơn :-)

Hãy nhìn vào boost :: iterator_facade và đẩy mạnh :: adaptor iterator. Họ thực hiện các giao diện iterator đầy đủ và cycle_iterator chỉ là để thực hiện một vài phương pháp của bạn như increment(), giảm một():

template<class IteratorBase> 
class cycle_iterator 
    : public boost::iterator_adaptor< 
      cycle_iterator,  // the derived class overriding iterator behavior 
      IteratorBase,  // the base class providing default behavior 
      boost::use_default, // iterator value type, will be IteratorBase::value_type 
      std::forward_iterator_tag, // iterator category 
      boost::use_default // iterator reference type 
     > 
{ 
    private: 
    IteratorBase m_itBegin; 
    IteratorBase m_itEnd; 

    public: 
    cycle_iterator(IteratorBase itBegin, IteratorBase itEnd) 
     : iterator_adaptor_(itBegin), m_itBegin(itBegin), m_itEnd(itEnd) 
    {} 

    void increment() { 
     /* Increment the base reference pointer. */ 
     ++base_reference(); 

     /* Check if past-the-end element is reached and bring back the base reference to the beginning. */ 
     if(base_reference() == m_itEnd) 
      base_reference() = m_itBegin; 
    } 

    // implement decrement() and advance() if necessary 
    }; 

này có lẽ không biên dịch nhưng nên giúp bạn bắt đầu.

Edit:

boost::iterator_adaptor cài đặt giao diện iterator đầy đủ về vài chức năng. Nó cung cấp triển khai mặc định cho increment(), decrement(), advance(), distance_to(), equal_to() và dereference() bằng trình lặp cơ sở được chuyển xuống lớp cơ sở iterator_adaptor.

Nếu tất cả những gì bạn cần là một trình chuyển tiếp tiến, chỉ cần thực hiện phương thức increment() để bọc xung quanh khi bạn đến trình vòng lặp kết thúc. Trình lặp tuần hoàn có thể là hai chiều nếu bạn thực hiện decrement() theo cách tương tự. Nếu IteratorBase chính nó là một trình vòng lặp truy cập ngẫu nhiên, trình vòng lặp vòng lặp cũng có thể là truy cập ngẫu nhiên và phương thức advance và distance_to phải được thực hiện bằng cách sử dụng các phép toán modulo.

Answer 2

Lấy được bộ sưu tập của riêng bạn từ std :: vector và cung cấp việc thực hiện trình lặp của riêng bạn ghi đè số tăng thêm & toán tử giảm.

Có rất nhiều hướng dẫn trên web. Ví dụ, hãy nhìn vào this blog post

Answer 3

boost::iterator adaptor là con đường để đi, dùng từ ngữ của tôi cho nó;)

Điều đó đang được nói rằng tôi muốn chỉ ra một vài cạm bẫy. Tôi không nghĩ rằng tôi có thể chỉnh sửa một câu trả lời hiện có, vì vậy chịu với tôi.

Cho rằng trình lặp cơ sở của bạn sẽ là một vectơ, bạn cần phải cẩn thận các chức năng giao diện cốt lõi nào bạn cần thực hiện.Nếu bạn muốn cycle_iterator của bạn trở thành một iterator truy cập ngẫu nhiên bạn cần tất cả các nội dung sau:

increment() 
decrement() 
advance(n) 
distance_to(j) 

Bây giờ distance_to(j) là một khái niệm có phần hài hước cho một cycle_iterator và ngữ nghĩa của nó có thể giúp bạn có được trong tất cả các loại rắc rối. Điều này có thể tránh được bằng cách hạn chế danh mục vòng lặp của trình lặp lặp thích nghi về phía trước hoặc hai chiều. Như thế này:

template <class BaseIterator> 
class cycle_iterator 
    : public boost::iterator_adaptor< 
     cycle_iterator     // Derived 
     , BaseIterator     // Base 
     , boost::use_default    // Value 
     , boost::forward_traversal_tag // CategoryOrTraversal 
    > 
{ ... }; 

Trong trường hợp này bạn chỉ cần thực hiện increment:

void increment() 
{ 
    if (++this->base_reference() == this->m_itEnd) 
    { 
    this->base_reference() = this->m_itBegin; 
    } 
} 

Đối với một hai chiều bạn cũng cần sụt lần:

void decrement() 
{ 
    if (this->base_reference() == this->m_itBegin) 
    { 
    this->base_reference() = this->m_itEnd; 
    } 
    --this->base_reference(); 
} 

Disclaimer: Tôi không chạy này thông qua một trình biên dịch, vì vậy tôi đã sẵn sàng để được xấu hổ.