Ich hab mal angefangen mir c++ als zusätzliche Sprache anzueignen.
Dazu hatte ich jetzt ein kleines Programm mit einer Queue geschrieben. Dabei tauchen jedoch immer wieder Probleme mit den pointern auf.
Und zwar hat jedes Element der Schlange einen Zeiger auf das mächste Element.
Welches Codestück Probleme bereitet ist:

node->insert(i);
node = &node->getNext();

dem Element wird also etwas angefügt( d.h. ein neeuer Knoten erstellt.
Und anschließend soll der Zeiger node ien Element weiter vorgerückt werden
Und genau das ist der Punkt der nicht funktioniert.
Kompilieren lässt sich das ganze und auch beim Ausführen tritt an sich kein Fehler auf, nur dass eben der Zeiger nicht richtig weiter gesetz wird.

Was mir beim Debuggen aufgefallen ist, ist die Tatsache, dass der nect-Zeiger eines Elementes, nach 2 Einfügeoperationen nicht mehr auf das richtige Objekt zeigt.

Ich bim im Moment nicht dazu in der Lage meinen Fehler zu finden, obwohl ich mir extra nochmal Sachen zu Pointern durchgelesen habe.

Ich wäre auch sehr dankbar, wenn sich das mal jemand anschauen könnte.

Gruß,

Martin.

*********Klasse Queue***********

#include <assert.h>
#include "Node.h"
;

template<class T>
class Queue{
private:
	Node<T> *first,*last;
	int length;
public:
	Queue(){
		length = 0;
	}

	void insert(T v){
		if (length>0){
			last->insert(v);
			last = &(last->getNext());
		}else{
			first = new Node<T>(v);
			last = first;
		}
		length++;
	}

	T getFirst(){
		assert(length>0);

		T tmp = first->getValue();
		Node<T> *tmp2 = first;
		first = &(first->getNext());
		length--;
		delete tmp2;
		return tmp;
	}

	bool empty(){
		return (length==0);
	}

	int getLength(){
		return length;
	}
};

*********Klasse Node***********

#include <assert.h>

template<class T>
class Node{
private:
	T value;
	Node *next;
public:
	Node(T v){
		value = v;
	}

	void insert(T v){
		next = new Node(v);
	}

	T getValue(){
		return value;
	}

	Node getNext(){
		return *next;
	}
}

#include <cassert>

template<class T>
class Queue
{
private:
	class Node
	{
	private:
		T		m_data;
		Node*	m_pNext;
	public:
		Node(T const& data) : m_data(data), m_pNext(NULL) {}

	public:
		T const& data() const { return m_data; }
		T& data() { return m_data; }
		Node* next() const { return m_pNext; }

	} *m_pFirst, *m_pLast;
	std::size_t		m_size;
public:
	Queue() : m_size(0), m_pLast(NULL), m_pFirst(NULL) {}

    void push_back(T const& data)
	{
		if (m_size > 0)
		{
			Node* pNext = m_pLast->next();
			pNext = new Node(data);
			m_pLast = pNext;
		}
		else
		{
			m_pFirst = new Node(data);
			m_pLast = m_pFirst;
		}
        ++m_size;
    }

	T front()
	{ 
		if (length == 0) throw std::out_of_range("no node inserted");

		T tmp = m_pFirst->data();
		Node* ptr = m_pFirst->next();
		delete m_pFirst;
		m_pFirst = ptr;
		--m_size;
		return tmp;
	}

	T back()
	{
		Node* res = NULL;
		for (Node* ptr = m_pFirst; ptr->next(); ptr = ptr->next())
			res = ptr;
		T* last = ;

		T tmp = m_pLast->data();
		delete m_pLast;
		m_pLast = res;
		--m_size;

		return tmp;
	}

    bool empty() const{
        return (m_size == 0);
    }

	std::size_t size() const {	return m_size;	}
};

...

...

...	Node getNext(){
		return *next;
	}
}

Hier gibst Du eine KOPIE des Node-Objekts zurück !
Das dürfte etwas Anderes sein, als Du willst.

Gruß,

Simon2.

void insert(T v){
        if (length>0){
            last->insert(v);
            [i]last = &(last->getNext());[/i] [b]--> last = last->getNext();[/b]
        }else{
            first = new Node<T>(v);
            last = first;
        }
        length++;
    }

bekomme ich an der geänderten Stelle eine Fehlermeldung, weil Node* nicht in Node konv. werden könne.

@Simon2: Siehe meinen Post (der letzte vor deinem ) hab mich nur vertan ... die Funktion heißt bei ihm getNext und nicht wie in der Umänderung von mir next ...

Deinen Hinweis hatte ich nicht in dieser Richtung verstanden (weil ich das Problem nicht in der Dereferenzierung, sondern in der Übergabe via Kopie einsortiert habe) ... und da ich nicht sicher bin, ob das dem OP nicht ebenso geht, ist mein Post vielleicht nicht komplett überflüssig.
(Sein letztes Posting bestärkt mich in dieser Annahme)

Gruß,

Simon2.

Sage ich jetzt dadurch, dass ich einen Pointer zurückgebe? weil ich ja die adresse returne.

Wunderbar, danke!
das war der Fehler.

Sage ich jetzt dadurch, dass ich einen Pointer zurückgebe? weil ich ja die adresse returne.

Genau !

Node f( // gibt ein Objekt des Typs Node zurück
Node* f( // gibt einen Pointer auf ein Objekt des Typs Node zurück

... wie bei allen Anderen Typangaben auch.

Gruß,

Simon2.

hä? nochmal klar in deutsch:)

Edit: OK:)