Iteratorelement in Stack speichern

Spawn

Hallo,
wir haben folgendes Problem:

Wir haben ein Set in Form eines Binärbaumes.
In der Begin- Methode soll jeder Pointer auf einen Knoten der schon besucht wurde, mit der push()- Methode auf dem Stack abgelegt werden. Sollte beim Aufruf des ++operators ein Knoten keinen rechten Nachfolger haben, soll durch die pop()- Methode dessen Vorgänger zurückgeliefert werden, damit weiter nach rechts abgestiegen werden kann.
Die Struktur des Stack sollte soweit funktionieren, das Speichern der Pointer im Stack funktioniert aber nicht.

Fehlermeldung lautet: Iterator has no member named 's'.

Auszug aus dem Code:

template<class T, class OrderClass = DefaultOrder<T> >
class Set{
public:
    Set():root(0){}

    class Node{
    public:
        Node(T toEnter):content(toEnter),left(0),right(0){}
        Node* left;
        Node* right;
        T content;
    };

    class Iterator{
    public:
        Iterator(Node* x):content(x){
            Stack s;
        }

        T& operator * (){
            return content->content;
        }

        class Stack{
            public:
                class StackNode{
                    public:
                        StackNode(Node* inContent, StackNode* inNext):content(inContent),next(inNext){}
                    private:
                        Node* content;
                        StackNode* next;
                };

                Stack():head(0){}

                ~Stack(){delete head;}

                void push(Node* inPtr){
                    if(head == 0)head = new StackNode(inPtr,0);
                    else head = new StackNode(inPtr, head);
                }

                Node* pop(){
                    if(head == 0) return 0;
                    else{
                        StackNode* toDelete = head;
                        Node* back = head->content;
                        head = toDelete->next;
                        delete toDelete;
                        return back;
                    }    
                }
            private:
                Node* head;
        };

        private:
            Node* content;
    };          

    void insert(T toEnter){
        if(!search(toEnter)){
            Node** tmp = &root;
            while(*tmp != 0){
                order(toEnter, (*tmp)->content) ? tmp = &(*tmp)->left : tmp = &(*tmp)->right;
            }
            *tmp = new Node(toEnter);
        }
    }    

        Iterator begin(){
            Iterator toSend(0);
            toSend.s.push(0);
            Node** tmp = &root;
            if((*tmp)->left != 0){
                while((*tmp)->left != 0)
                    tmp = &(*tmp)->left;
//                Iterator toSend(tmp);
                return toSend;
            }
        }

private:
    Node* root;    
};

tag

Iterator(Node* x):content(x){
            Stack s;
        }

s ist doch eine lokale Variable innerhalb einer Funktion

Spawn

Das ist wohl war, hab ich auch mitlerweile erkannt und dynamisch alloziert.
Trotzdem bin ich nicht weiter gekommen.
Aber danke fürs durchsehen.