链表迭代器实现C++

一些注意事项。

有两个选项可以声明Node和Iterator。列表类内部为List<T>::Node或外部为Node<T>。这在一定程度上是一个品味问题。但是，从工程角度来看，嵌套类的符号名称更长，因此调试信息更大。此外，当嵌套类也是模板时，在必要时很难专门化它们(因为这需要首先完全专用封闭模板)，但这里的情况并非如此。

当一个列表节点用作列表头和尾时，它会导致更优雅的代码。空列表是一个节点，其next和prev指向自身。push_front追加到指向第一个节点或自身的list.next。push_back将节点追加到指向最后一个节点或自身的list.prev。插入/删除节点时，无需对第一个和最后一个节点进行特殊处理。例如：

struct Node {
Node *next_, *prev_;
Node() 
: next_(this), prev_(this)
{}
~Node() { 
unlink();
}
void push_back(Node* n) {
n->next_ = this;
n->prev_ = prev_;
prev_->next_ = n;
prev_ = n;
}
void unlink() {
Node *next = next_, *prev = prev_;
next->prev_ = prev;
prev->next_ = next;
next_ = this;
prev_ = this;
}
};

在上面，Node只需要两个操作就可以维护一个列表。不仅如此，Node本身就是一个极简主义列表，可用于侵入性列表(在析构函数中具有自动取消链接)。请注意，使用this如何使检查nullptr变得不必要 -Node始终是有效的列表。

错误检查应仅处于调试模式(例如，使用assert)。否则，这些检查会使用不必要的运行时检查来惩罚正确的应用程序。

这是一个基于您的想法的最小工作示例：

template<class T>
class List;
class Iterator;
class Node {
friend class Iterator;
template<class T> friend class List;
protected:
Node *next_, *prev_;
void push_back(Node* n) {
n->next_ = this;
n->prev_ = prev_;
prev_->next_ = n;
prev_ = n;
}
void unlink() {
Node *next = next_, *prev = prev_;
next->prev_ = prev;
prev->next_ = next;
next_ = this;
prev_ = this;
}
public:
Node()
: next_(this), prev_(this)
{}
~Node() { unlink(); }
};
class Iterator {
protected:
Node* node_;
Iterator(Node* node)
: node_(node)
{}
public:
Iterator& operator++() {
node_ = node_->next_;
return *this;
}
bool operator==(Iterator b) const { return node_ == b.node_; }
bool operator!=(Iterator b) const { return node_ != b.node_; }
// Implement the rest of iterator interface.
};
template<class T>
class List {
class NodeT : public Node {
friend class List<T>;
T value_;
NodeT(T t) : value_(t) {}
};
template<class U>
class IteratorT : public Iterator {
friend class List<T>;
NodeT* node() const { return static_cast<NodeT*>(node_); }
public:
U& operator*() const { return node()->value_; }
U* operator->() const { return &node()->value_; }
operator IteratorT<U const>() const { return node_; } // iterator to const_iterator conversion
IteratorT(Node* node) : Iterator{node} {}
};
Node list_;
public:
using iterator = IteratorT<T>;
using const_iterator = IteratorT<T const>;
~List() { clear(); }
bool empty() const { return list_.next_ == &list_; }
iterator begin() { return list_.next_; }
iterator end() { return &list_; }
void push_back(T t) { list_.push_back(new NodeT(t)); }
void erase(const_iterator i) { delete i.node(); }
void clear() {
while(!empty())
erase(begin());
}
// Implement the rest of the functionality.
};
int main() {
List<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(3);
for(auto elem : l)
std::cout << elem << ' ';
std::cout << 'n';
}