Iteratorproblem bei eigner Listenklasse...

[VirtualDreams]

Kann jemand was mit dieser Fehlermeldung anfangen bzw sagen was ich falsch gemacht hab?

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
        ]

[David_pb]

Iterator *begin() const        {return first;}

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

[VirtualDreams]

Ne, das fkt auch nicht
Normalerweise müßte es fkt, da ich es nach einer Vorlage gemacht hab die noch selbst erweitert hab... Bis auf den Iterator geht ja alles bisher...

[akari]

Hallo

- 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

[David_pb]

Natürlich funktionierts nich... Weil du den Zeiger immer noch zu einem Objekt konvertieren willst... Verstehst du den Code nich?

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

[VirtualDreams]

@akari
gut zu wissen, hab ich bisher noch nicht gewußt. werd ich mal korrigieren. vlt löst sich dann das eine oder andere.

@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...

[David_pb]

Zeig her den Beispiel-Quellcode... Glaub kaum dass da was gradläuft!

[VirtualDreams]

ok, hier mal alles...

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

[David_pb]

Das bezog sich eher auf deine Iteratorgeschichte... Da fehlt noch einiges, z.B. ein "=" Operator und ein entsprechender Konstruktor mit der Liste als Parameter. Alle anderen Vorschläge stehen oben...

grüße

[VirtualDreams]

edit

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

[David_pb]

Es lässt sich nich kompilieren weil die jede Menge fehlt. Deine Liste gibt first und last niemals irgendwelche Werte, die Zeiger dümpeln also ungenutzt vor sich hin.

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

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

grüße

[VirtualDreams]

nee, ich weiß, das muß ich ja noch einbauen, dessen bin mir schon bewußt ^^
begin klappt aber jetzt perfekt ^^