堆栈上的前向迭代器

Question

我必须在基于数组的堆栈上实现一个前向迭代器。 我不能使用 std::vectors 或任何东西，我只需要它。 当我开始使用前向迭代器，特别是运算符时，我对这个程序的开发就停止了。

我有一个方法，它采用一个通用序列，从中，给定一个偏移量，创建一个堆栈：

template <typename IterT>       
  stack(IterT begin, IterT end) : _stack(0), _size(0), _capacity(0) {
    try {       
        for(; begin!=end; ++begin) {
            push(static_cast<T>(*begin));       
        }
    }
    catch(...) {
        clear();   //my method to destroy the stack 
        throw;
    }
}

在我的主要工作中，我执行以下操作：

int a[5] = {1, 2, 3, 4, 5};
stack<int> sint(a, a+5);
cout << sint << endl;

但是当代码运行时，堆栈被创建但不打印。 有人可以帮助我吗？ 并且还给我其他帮助（关于代码缩进、改进等...）谢谢，我会转发迭代器代码。

 class const_iterator {
    const T* data;
    unsigned int index;
public:
    typedef std::forward_iterator_tag iterator_category;
    typedef T                         value_type;
    typedef ptrdiff_t                 difference_type;
    typedef const T*                  pointer;
    typedef const T&                  reference;

    const_iterator() : data(0){}

    const_iterator(const T* arr) : data(arr) {}

    const_iterator(const const_iterator &other) 
        : data(other.data){ }

    const_iterator& operator=(const const_iterator &other) {
        data = other.data;
        return *this;
    }

    ~const_iterator() {
        data = 0;
    }

    reference operator*() const {
        return *data;
    }

    pointer operator->() const {
        return &(data);
    }

    const_iterator operator++(int) {
        const_iterator tmp(*this);
        ++*this;
        return tmp;
    }

    const_iterator& operator++() {
        ++data;
        return *this;
    }

    bool operator==(const const_iterator &other) const {
        return data[index] == other.data[index];
    }

    bool operator!=(const const_iterator &other) const {
        return data[index] != other.data[index] ;
    }


private:

    friend class stack; 

    const_iterator(unsigned int ind) :
        index(ind){}

}; // class const_iterator

const_iterator begin() const {
    cout << "begin" << _stack[_size-1] << endl;
    return const_iterator(_stack[_size-1]);
}

const_iterator end() const {
    cout << "end" << _stack[0] << endl;
    return const_iterator(_stack[0]);
}

最后但并非最不重要的是，我重新定义了 << 运算符以适合迭代器：

template <typename T>
std::ostream &operator<<(std::ostream &os, const stack<T> &st) {
typename stack<T>::const_iterator i, ie;
for(i = st.begin(), ie = st.end(); i!=ie; ++i){
    os << *i << std::endl;
}
return os;
}

堆栈的代码如下（为了便于阅读，我省略了一些内容）。

stack()
    : _capacity(0), _size(0), _stack(0){}
void push (const T &value){
    if (_size == _capacity){    //raddoppio la dimensione 
        if(_capacity == 0)
            ++_capacity;
        _capacity *= 2;
        T* tmp = new T[_capacity];
        copy_n(_stack, _size, tmp);
        swap(_stack, tmp);
        delete[] tmp;
    }
    _stack[_size] = value;
    ++_size;
}

void pop(){
    T _tmp;
    if(!is_empty()){
        _tmp = _stack[_size-1];
        --_size;
    }
} 

Answer 1

如果你想创建一个看起来像指针的迭代器，你不需要index ，因为data扮演了它的角色。 比较运算符应该比较data ，而不是值：

bool operator==(const const_iterator &other) const {
    return data == other.data;
}

如果要创建反向迭代器，则稍微复杂一些。 首先， operator++应该减少data 。 其次，解引用运算符不应该返回*data ，而是返回*(data - 1) 。 第三， data在begin()迭代应指向stack[size] ，并且data在end()迭代应指向stack[0] 在任何情况下都不需要析构函数。

Answer 2

我遵循了之前的建议，这是编辑后的结果，但我仍然无法弄清楚如何正确使用私有部分中的构造函数

class const_iterator {
    const T *data;
public:
    /* ITERATOR TRAITS HERE */

    const_iterator() : data(0){}

    const_iterator(const T* arr) : data(arr) {}

    const_iterator(const const_iterator &other) 
        : data(other.data){ }

    const_iterator& operator=(const const_iterator &other) {
        data = other.data;
        return *this;
    }

    ~const_iterator() {
        data = 0;
    }

    reference operator*() const {
        return *data;
    }

    pointer operator->() const {
        return &(data);
    }

    const_iterator operator++(int) {
        const_iterator tmp(*this);
        ++*this;
        return tmp;
    }

    const_iterator& operator++() {
        ++data;
        return *this;
    }

    bool operator==(const const_iterator &other) const {
        return data == other.data;
    }

    bool operator!=(const const_iterator &other) const {
        return data != other.data;
    }

private:
    friend class stack; 

    const_iterator(const T *d) {
        data = d;
    }

}; // classe const_iterator

const_iterator begin() const {
    return const_iterator(_stack[_size-1]);
}

const_iterator end() const {
    return const_iterator(_stack[0]);
}