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

Question

I am making a Stack which is based on linked-list. Everything works fine except that I don't know how to implement a "range-based for loop" for this one.

I got the error: no match for ‘operator++’ (operand type is ‘Stack<int>::Node’).

What's wrong and how can I fix it?

---

Code (Foolish me overloads post ++ not prefix ++, now all corrected.):

#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;
}

Answer 1

First of all, a Stack should not be traversable at all. It should expose top, pop, push, and is_empty, and that's basically it. But let's forget about it and pretend you want to implement a regular linked list.

In C++ we work with the concept of iterators to manage containers and algorithms, and also the range-based for loop. Formally, in order to be eligible for a range-based for loop, an object needs to implement begin() and end() members (or make unqualified begin(x) and end(x) calls work), and the result of these methods needs to implement operator++, operator* and != comparison. Your Node class almost qualifies, except it implements the wrong kind of operator++ (and its logic is broken, because it never updates elem, but formally it's OK as far as the compilation goes).

A typical list class template implementations from the standard library works in a similar way, except it doesn't expose its version of Node directly. Instead, it exposes a pointer-to-node, wrapped in a special object that implements operator* and operator++ and many other things. This allows for much greater flexibility.

Such small objects that behave almost (or entirely) like pointers are called iterators in C++. Iterators are pervasive throughout the standard library and lots of user code. It's a very important concept that every C++ programmer must learn early on. Any good C++ book or course should cover them.

Here's how a fragment of an iterator-based list class may look like:

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();
};

It is recommended to learn the concept by using standard containers and algorithms that expose iterator-based interfaces.