Da drin ist folgende Klasse:

#ifndef SIMPLELIST_H
#define SIMPLELIST_H
#include<cassert>
#include<iterator>
namespace br_stl {
template<class T>
class slist {
    public:
/*Einige Typen der Klasse slist werden mit öffentlichen, außerhalb der Klasse
verwendbaren Namen versehen, damit sie ohne Kenntnis der Implementierung
verwendet werden können.
*/
        typedef T value_type;
        typedef ptrdiff_t difference_type;
        typedef T* pointer;
        typedef T& reference;
// etc. siehe Text
        slist() : firstElement(0), Count(0) {}
/*Kopierkonstruktor, Destruktor und Zuweisungsoperator fehlen! Die Implementierung
von push_front() erzeugt ein neues Listenelement und fügt es am Anfang
der Liste ein:
*/
        void push_front(const T& Datum) { // am Anfang einfügen
            firstElement = new ListElement(Datum, firstElement);
            ++Count;
        }
    private:
        struct ListElement {
                    T Data;
                    ListElement *Next;
                    ListElement(const T& Datum, ListElement* p)
                    : Data(Datum), Next(p) {}
        };
        ListElement *firstElement;
        size_t Count;

    public:
        class iterator {
            public:
                typedef std::forward_iterator_tag iterator_category;
                typedef T value_type;
                typedef T* pointer;
                typedef T& reference;
                typedef size_t size_type;
                typedef ptrdiff_t difference_type;

                iterator(ListElement* Init = 0)
                    : current(Init){}

                T& operator*() { // Dereferenzierung
                        return current->Data;
                }

                const T& operator*() const { // Dereferenzierung
                    return current->Data;
                }
                iterator& operator++() 
                { // Präfix
                        if(current) // noch nicht am Ende angelangt?
                        current = current->Next;
                        return *this;
                }
                iterator operator++(int) { // Postfix
                        iterator temp = *this;
                        ++*this;
                        return temp;
                }
                bool operator==(const iterator& x) const {
                    return current == x.current;
                }
                bool operator!=(const iterator& x) const {
                    return current != x.current;
                }
            private:
                ListElement* current; // Verweis auf aktuelles Element
        }; // iterator
/*Wie oben erkennbar, wird der Kopierkonstruktor innerhalb der Postfix-Variante
des ++-Operators bei der Initialisierung und der Rückgabe von temp benötigt.
Aus diesem Grund sollte die Präfix-Variante bevorzugt werden. Einige Methoden
der Klasse slist benutzen die Klasse iterator:
*/
    iterator begin() const { return iterator(firstElement);}
    iterator end() const { return iterator();}
};
} // namespace br_stl
#endif // SIMPLELIST_H

[Übungsaufgabe]Dazu soll jetzt noch eine erase Methode implementiert werden:

iterator erase(iterator p);

Nur leider habe ich nen Stein vorm Kopf und kriege es nicht hin.
Ich kann ja wohl schlecht über p auf current zugreifen um es zu löschen und ich muss ja auch dafür sorgen, dass das vorherige Element, auf das nach p zeigt.

Und ich habe ja auch kein prev zeiger, der mir ein Element vorger gibt.
Das könnte ich ja noch selber reinmachen aber wie kriege ich denn da jetzt was gelöscht.

Ich habe das Gefühl in dem Code fehlt irgendwas, oder muss ich doch mehr implemtieren als nur eine Funktion..

PS: Ja, dazu benötigst du friend-Zugriff in deine Iterator-Klasse.