C++ 循环数组（队列）迭代器

我有一个队列的迭代器类（实现为循环数组）。我附上下面的代码。问题在于++运算符。一旦到达数组的末尾，它就返回到它的开头，因此迭代器指向第一个元素。它工作得很好，但我无法使用此方法实现then end（）迭代器。队列类中返回begin（）和end（）迭代器的函数可以在底部看到。end（）迭代器应该指向队列的后部，但是当数组已满且后部等于数组的大小时，++运算符将返回，而不是允许它返回真正的end（），后者是后部指向的元素。关于这个问题有什么建议吗

class IteratorForwQueue : std::iterator<std::forward_iterator_tag, P*> {
    public:
        typedef IteratorForwQueue iter;
        IteratorForwQueue(P* e, Queue* q) : elem(e), _queue(q) {}
        IteratorForwQueue(const IteratorForwQueue& it, Queue* q) :
            elem(it.elem), _queue(q) {}

        iter& operator++() {
            if(elem >= (_queue->_elems + (_queue->_size - 1)) &&
                            _queue->_rear != _queue->_size)
                elem = &(_queue->_elems[0]); // circle back passed the array
            else
                ++elem;
            return *this;
        }

        P& operator*() { return *elem;}
        P* operator->() { return elem; }
        bool operator==(const iter& it) { return elem == it.elem; }
        bool operator==(const P& e) { return e == *elem; }
        bool operator!=(const iter& it) { return elem != it.elem; }
        bool operator!=(const P& e) { return e != *elem; }
    private:
        P* elem;
        Queue<P>* _queue;
    }; // end of iterator class
// ....
IteratorForwQueue begin() { return IteratorForwQueue(_elems + _front, this); }
IteratorForwQueue end() { return IteratorForwQueue(_elems + _rear, this); }

class IteratorForwQueue:std:：iterator{
公众：
typedef迭代器用于wqueue iter；
迭代器forwqueue（P*e，Queue*q）：元素（e），_Queue（q）{}
迭代器FORWQUEUE（常量迭代器FORWQUEUE&it，队列*q）：
elem（it.elem），_queue（q）{}
iter&operator++（）{
如果（元素>=（\u队列->\u元素+（\u队列->\u大小-1））&&
_队列->\u后方！=\u队列->\u大小）
elem=&（_-queue->_-elems[0]）；//循环返回数组
其他的
++元素；
归还*这个；
}
P&运算符*（）{return*elem；}
P*运算符->（）{return elem；}
布尔运算符==（const iter&it）{return elem==it.elem；}
布尔运算符==（常量P&e）{return e==*elem；}
布尔运算符！=（const iter&it）{return elem！=it.elem；}
布尔运算符！=（常量P&e）{return e！=*elem；}
私人：
P*elem；
队列
*\u队列；
}; // 迭代器类的结束
// ....
IteratorForwQueue begin（）{返回IteratorForwQueue（_elems+_front，this）；}
IteratorForwQueue end（）{返回IteratorForwQueue（_elems+_rear，this）；}

基于end不必是“过去的end”迭代器这一思想，它可以是任何东西：

class IteratorForwQueue : std::iterator<std::forward_iterator_tag, P*> {
public:
    typedef IteratorForwQueue iter;
    IteratorForwQueue(P* e, size_t sz, size_t rear) : elem(e), _base(e), _sz(sz), _rear(rear) {}
    IteratorForwQueue(const IteratorForwQueue& it, size_t sz) :
        elem(it.elem), _base(it.elem), _sz(sz) {}

    iter& operator++() {
       if(elem - _base == _rear) {
          elem = nullptr;
          _base = 0;
          _sz = 0;
          _rear = 0;
          return *this;
       } 
       if(elem >= _base + (_sz - 1))
            elem = _base; // circle back passed the array
        else
            ++elem;


        return *this;
    }

    P& operator*() { return *elem;}
    P* operator->() { return elem; }
    bool operator==(const iter& it) { return elem == it.elem; }
    bool operator==(const P& e) { return e == *elem; }
    bool operator!=(const iter& it) { return elem != it.elem; }
    bool operator!=(const P& e) { return e != *elem; }
private:
    P* elem;
    P* _base;  // can't access members of outer class
    size_t _sz; // can't access members of outer class
    size_t _rear;
}; // end of iterator class
// ....
IteratorForwQueue begin() { return IteratorForwQueue(_elems + _front, _size, _rear); }
IteratorForwQueue end() { return IteratorForwQueue(nullptr, 0, 0); }
const IteratorForwQueue cbegin() const { return     IteratorForwQueue(_elems + _front, _size); }
const IteratorForwQueue cend() const { return IteratorForwQueue(_elems + _rear, _size); }

class IteratorForwQueue:std:：iterator{
公众：
typedef迭代器用于wqueue iter；
迭代器forwqueue（P*e，size_t sz，size_t rear）：元素（e），_基（e），_sz（sz），_rear（rear）{
迭代器FORWQUEUE（常量迭代器FORWQUEUE&it，大小为）：
元素（it.elem），_base（it.elem），_sz（sz）{}
iter&operator++（）{
如果（元素-_基本=_后）{
elem=nullptr；
_基数=0；
_sz=0；
_后部=0；
归还*这个；
} 
if（elem>=_base+（_sz-1））
elem=\u base；//返回经过数组的圆
其他的
++元素；
归还*这个；
}
P&运算符*（）{return*elem；}
P*运算符->（）{return elem；}
布尔运算符==（const iter&it）{return elem==it.elem；}
布尔运算符==（常量P&e）{return e==*elem；}
布尔运算符！=（const iter&it）{return elem！=it.elem；}
布尔运算符！=（常量P&e）{return e！=*elem；}
私人：
P*elem；
P*_base；//无法访问外部类的成员
size\u t\u sz；//无法访问外部类的成员
后部尺寸；
}; // 迭代器类的结束
// ....
IteratorForwQueue begin（）{返回IteratorForwQueue（_elems+_front，_size，_reast）；}
IteratorForwQueue end（）{返回IteratorForwQueue（nullptr，0，0）；}
const IteratorForwQueue cbegin（）const{return IteratorForwQueue（_elems+_front，_size）；}
const IteratorForwQueue cend（）const{return IteratorForwQueue（_elems+_rear，_size）；}

---

顺便说一句，最好有一个指向原始数据结构的指针，使迭代器成为一个friend类，并根据需要获取

\u base

、

\u sz

和

\u rear

你能负担得起浪费一个插槽并将其用作哨兵吗？队列的前部和后部随着你的排队和退队而变化。如果它改变了，我就不能有一个sentinel。问题是，如果你把队列实现为一个循环数组，你会如何实现它的迭代器的操作符+？代码没有简化，但我也在考虑同样的问题，把这个指针传给原来的数据结构。这和修改++操作符的条件就达到了目的，只有当rear不等于size时才返回（参见代码）。出于文档目的，请将新代码复制到您的答案中，如果您不介意，请将其标记为答案，谢谢