实现基于链表的堆栈的基于范围的 for 循环

Implement range-based for loop of a Stack based on linked-list

本文关键字：范围 for 循环 于范围 堆栈 链表 实现 于链表      更新时间：2023-10-16

我正在制作一个基于linked-list的Stack。一切都很好，除了我不知道如何为此实现"基于范围的 for 循环"。

我得到了error: no match for ‘operator++’ (operand type is ‘Stack<int>::Node’).

出了什么问题，我该如何解决？

代码(愚蠢的我重载帖子++不前缀++，现在全部更正。

#include <iostream>
using namespace std;
template<typename T>
class Stack{
private:
class Node{
friend Stack;
public:
void operator++(){
this->next = this->next->next;   //point to next Node
}
bool operator!=(const Node& rhs){
return !(*this == rhs);
}
T operator*(){
return this->next->elem;  //return current Node elem
}
bool operator==(const Node& rhs){
return this->next == rhs.next;
}
private:
T elem;
Node* next;
};
Node* first;
int _size;
public:
Stack():_size(0){
first = nullptr;
}
void push(T item){
Node* n = new Node;
n->elem = item;
n->next = first;
first = n;
_size++;
}
T pop(){
T item = first->elem;
Node* old_first = first;
first = first->next;
delete old_first;
_size--;
return item;
}
int size(){
return _size;
}
bool empty(){
return _size == 0;
}
Node begin(){
Node n;
n.next = first;
return n;
}
Node end(){
Node m;
m.next = nullptr;
return m;
}
~Stack(){
Node* ele_to_delete;
while(first != nullptr){
ele_to_delete = first;
first = first->next;
delete ele_to_delete;
}
}
Stack(const Stack&) = delete;
Stack& operator=(const Stack&) = delete;
};

int main(){
Stack<int> ls;
ls.push(1);
ls.push(2);
ls.push(3);
for(auto s: ls){
cout << s << "|";
}
return 0;
}

首先，Stack根本不应该是可遍历的。它应该公开top、pop、push和is_empty，基本上就是这样。但是让我们忘记它，假装你想实现一个常规的链表。

在C++我们使用迭代器的概念来管理容器和算法，以及基于范围的 for 循环。形式上，为了符合基于范围的 for 循环，对象需要实现begin()和end()成员(或使非限定begin(x)和end(x)调用工作(，并且这些方法的结果需要实现operator++、operator*和!=比较。你的Node类几乎是合格的，除了它实现了错误的operator++(它的逻辑被破坏了，因为它从不更新elem，但正式地就编译而言是可以的(。

标准库中的典型列表类模板实现的工作方式类似，只是它不直接公开其Node版本。相反，它公开了一个指向节点的指针，该指针包装在一个实现operator*和operator++以及许多其他事情的特殊对象中。这提供了更大的灵活性。

这种行为几乎(或完全(像指针的小对象在C++中称为迭代器。迭代器在整个标准库和大量用户代码中无处不在。这是一个非常重要的概念，每个C++程序员都必须尽早学习。任何一本好的C++书或课程都应该涵盖它们。

下面是基于迭代器的列表类的片段的外观：

template <class T> class List {
struct Node {
T elem; 
...
};
...
public:
class Iterator {
Node* node;
public:
Iterator operator++() { 
node = node->next; return *this;
}
T& operator*() { 
return node->elem;
}
...
};
Iterator begin();
Iterator end();
};

建议通过使用公开基于迭代器的接口的标准容器和算法来学习该概念。

相关文章：