template<class T>
class List
{
	public:
		struct Element;

		class Iterator
		{
			private:
				Element *e;

			public:
				Iterator			()				{e = NULL;}
				bool operator!=		(Iterator i)	{e != i.e;}
				bool operator==		(Iterator i)	{e == i.e;}
				Iterator operator++ ()				{e = e->next, return *this;}
				Iterator operator++	(int)			{Iterator i = *this, ++*this, return i;}
				Iterator operator--	()				{e = e->prev, return *this;}
				Iterator operator--	(int)			{Iterator i = *this, --*this, return i;}
				T& operator*		() const		{return e->data;}
				T* operator->		() const		{return &(e->data);}
				//Iterator &operator=	(Iterator &i)	{e = i.e, return *this;}
				//Iterator &operator=	(T t)			{e->data = t, return *this;}
				friend class List<T>;
		};

		List<T>				();
		List<T>				(const List<T> &l);
		~List<T>			()					{while(size()) pop_front(), elements = 0;}
		List<T>& operator=	(const List<T> &l);
		int size() const	{return elements;}
		void push_back		(T t);
		void push_front		(T t);
		T pop_back			();
		T pop_front			();
		void erase			()		{while(size()) pop_front(), elements = 0;}

		Iterator begin() const		{return first;}
		Iterator end() const		{Iterator i, return i;}
		Iterator rbegin() const		{return last;}
		Iterator rend() const		{Iterator i, return i;}
		Iterator insert_before(Iterator i, T t);
		Iterator insert_after(Iterator i, T t);
		void erase(Iterator i);

	private:
		struct Element
		{
			Element *next;
			Element *prev;
			T data;
			Element ()		{next = NULL, prev = NULL;}
			Element (T &t)	{next = NULL, prev = NULL, data = t;}
		};

		Iterator *first;
		Iterator *last;
		Element *head;
		Element *tail;
		int elements;
};

Aufrufen tu ich das mit:

List<int>::Iterator k;
	k = l.begin();

mit folgender Fehlermeldung:

g:\entwicklung\vc++2005\doublelinkedlist\DoubleLinkedList.h(38) : error C2664: 'List<T>::Iterator::Iterator(const List<T>::Iterator &)' : cannot convert parameter 1 from 'List<T>::Iterator *const ' to 'const List<T>::Iterator &'
        with
        [
            T=int
        ]
        Reason: cannot convert from 'List<T>::Iterator *const ' to 'const List<T>::Iterator'
        with
        [
            T=int
        ]
        No constructor could take the source type, or constructor overload resolution was ambiguous
        g:\entwicklung\vc++2005\doublelinkedlist\DoubleLinkedList.h(38) : while compiling class template member function 'List<T>::Iterator List<T>::begin(void) const'
        with
        [
            T=int
        ]
        .\main.cpp(10) : see reference to class template instantiation 'List<T>' being compiled
        with
        [
            T=int
        ]

So vielleicht? Sind aber noch viele andere Fehler drinn, btw!

- wenn du eine Vordeklaration von struct Element in public machst, darfst du die eigentliche Deklaration danach nicht in private machen. Sondern die muß auch in public sein.

- auch in Header-Dateien müßen Codezeilen mit einem Semikolon getrennt werden, zum Beispiel hier

Iterator operator++ ()                {e = e->next; /* Semikolon */ return *this;}

danach läßt sich das bei mir kompilieren.

bis bald
akari

Entweder:

List<int>::Iterator *k;
    k = l.begin();

oder:

Iterator &begin() const        {return *first;}

Edit:

template<class T>
class List
{
    public:
        struct Element;

        class Iterator
        {
            private:
                Element *e;

            public:
                Iterator            ()                {e = NULL;} // hier könntest du die initialisierungsliste verwenden
                bool operator!=        (Iterator i)    {e != i.e;} // fkt konstant machen
                bool operator==        (Iterator i)    {e == i.e;} // fkt konstant machen
                Iterator operator++ ()                {e = e->next, return *this;} // semikolon, wie akari schon sagte ;) und referenz auf nen Iterator zurückgeben
                Iterator operator++    (int)            {Iterator i = *this, ++*this, return i;} // semikolon usw
                Iterator operator--    ()                {e = e->prev, return *this;} // semikolon, ...
                Iterator operator--    (int)            {Iterator i = *this, --*this, return i;} // bla
                T& operator*        () const        {return e->data;} 
                T* operator->        () const        {return &(e->data);}
                //Iterator &operator=    (Iterator &i)    {e = i.e, return *this;}
                //Iterator &operator=    (T t)            {e->data = t, return *this;}
                friend class List<T>; // sollte immer ganz oben stehn, der übersicht halber 
        };

        List<T>                ();
        List<T>                (const List<T> &l);
        ~List<T>            ()                    {while(size()) pop_front(), elements = 0;} 
        List<T>& operator=    (const List<T> &l);
        int size() const    {return elements;}
        void push_back        (T t); // übergib ne konstante referenz, das kann vieeel Zeit sparen
        void push_front        (T t); // genauso hier
        T pop_back            ();
        T pop_front            ();
        void erase            ()        {while(size()) pop_front(), elements = 0;} 

        Iterator begin() const        {return first;} // s.o.
        Iterator end() const        {Iterator i, return i;} // semikolon, ...
        Iterator rbegin() const        {return last;} // referenz zurückgeben
        Iterator rend() const        {Iterator i, return i;} // referenz zurückgeben
        Iterator insert_before(Iterator i, T t); // konstante referenz übergeben
        Iterator insert_after(Iterator i, T t); // s.o.
        void erase(Iterator i); // ...

    private:
        struct Element
        {
            Element *next; // eigentlich sollte das alles privat sein, von wegen kapselung
            Element *prev;
            T data;
            Element ()        {next = NULL, prev = NULL;} // warum keine initalisierungsliste?
            Element (T &t)    {next = NULL, prev = NULL, data = t;} // const vor T &t
        };

        Iterator *first;
        Iterator *last;
        Element *head;
        Element *tail;
        int elements; // warum nich unsigned long? ;-P weniger als 0 Elemente wirst du nich haben :)
};

grüße

@david_pb
doch, den code versteh ich schon, nur in meinem bsp-source funktioniert es ja auch???

edit:
hab deine varianten probiert und gehen nicht. ich denke es hat was mit 'const' irgendow zu tun, denn soweit kann ich die meldung noch interpretieren...

template<class T>
class List
{
	private:
		struct Element;

	public:
		class Iterator
		{
			private:
				Element *e;

			public:
				Iterator			()				{e = NULL;}
				bool operator!=		(Iterator i)	{e != i.e;}
				bool operator==		(Iterator i)	{e == i.e;}
				Iterator operator++ ()				{e = e->next; return *this;}
				Iterator operator++	(int)			{Iterator i = *this; ++*this; return i;}
				Iterator operator--	()				{e = e->prev; return *this;}
				Iterator operator--	(int)			{Iterator i = *this; --*this; return i;}
				T& operator*		() const		{return e->data;}
				T* operator->		() const		{return &(e->data);}
				//Iterator &operator=	(Iterator &i)	{e = i.e, return *this;}
				//Iterator &operator=	(T t)			{e->data = t, return *this;}
				friend class List<T>;
		};

		List<T>				();
		List<T>				(const List<T> &l);
		~List<T>			()					{while(size()) pop_front(), elements = 0;}
		List<T>& operator=	(const List<T> &l);
		int size() const	{return elements;}
		void push_back		(T t);
		void push_front		(T t);
		T pop_back			();
		T pop_front			();
		void erase			()		{while(size()) pop_front(); elements = 0;}

		Iterator begin() const		{return first;}
		Iterator end() const		{Iterator i; return i;}
		Iterator rbegin() const		{return last;}
		Iterator rend() const		{Iterator i; return i;}
		Iterator insert_before(Iterator i, T t);
		Iterator insert_after(Iterator i, T t);
		void erase(Iterator i);

	private:
		struct Element
		{
			Element *next;
			Element *prev;
			T data;
			Element ()		{next = NULL; prev = NULL;}
			Element (T &t)	{next = NULL; prev = NULL; data = t;}
		};

		Iterator *first;
		Iterator *last;
		Element *head;
		Element *tail;
		int elements;
};

//List
template<class T>
List<T>::List()
{
	head = NULL;
	tail = NULL;
	elements = 0;
}

template<class T>
List<T>::List(const List<T> &l)
{
	head = NULL;
	tail = NULL;
	elements = 0;

	//TODO
}

template<class T>
void List<T>::push_back(T t)
{
	Element *e = new Element;
	e->next = NULL;
	e->prev = NULL;
	e->data = t;

	if(head == NULL)
	{
		head = e;
		tail = e;
		++elements;
	}
	else
	{
		Element *tail_old = tail;
		tail = e;
		tail->prev = tail_old;
		tail->prev->next = e;
		++elements;
	}
}

template<class T>
void List<T>::push_front(T t)
{
	Element *e = new Element;
	e->next = NULL;
	e->prev = NULL;
	e->data = t;

	if(head == NULL)
	{
		head = e;
		tail = e;
	}
	else
	{
		Element *head_old = head;
		head = e;
		head->next = head_old;
		head->next->prev = e;
	}
	++elements;
}

template<class T>
T List<T>::pop_back()
{
	if(tail != NULL)
	{
		T t = tail->data;
		Element *e = tail;
		if(tail->prev != NULL)
		{
			tail = tail->prev;
			tail->next = NULL;
		}
		else
		{
			head = NULL;
			tail = NULL;
		}
		delete e;
		--elements;
		return t;
	}
	throw "Invalid call! " __FUNCSIG__ ". List is empty.";
}

template<class T>
T List<T>::pop_front()
{
	if(head != NULL)
	{
		T t = head->data;
		Element *e = head;
		if(head->next != NULL)
		{
			head = head->next;
			head->prev = NULL;
		}
		else
		{
			head = NULL;
			tail = NULL;
		}
		delete e;
		--elements;
		return t;
	}
	throw "Invalid call! " __FUNCSIG__ ". List is empty.";
}

und main...

int main()
{
	List<int> l;
l.push_back(10);
	l.push_front(20);
	l.push_back(30);
	l.push_back(40);
	l.push_front(50);

try
	{

		while(l.size())
			cout << l.pop_front() << endl;
	}
	catch(char *msg)
	{
		MessageBox(NULL, msg, "Error!", NULL);
	}
	catch(...)
	{
		MessageBox(NULL, "Unknown exception!", "Error!", NULL);
	}

	system("pause");

	return 0;
}

bei gehts einwandfrei... soweit ^^ :p

grüße

es läßt sich kompilieren ^^ dein vorschlag hat geholfen

Iterator &begin() const		{return *first;}

Man lernt nie aus =)) Danke für die Hilfe

edit2
Ist das so ok?

Iterator &operator++(int)				{Iterator i = *this; ++*this; return *i;}

Und wenn du die Methode begin() so änderst klappts auch mit der Zuweisung:

Iterator &begin() const        {return *first;}

grüße