Ich sitze an meiner Computeranimations-Studienarbeit und möchte die Vertex-Koordinaten plus deren Abstand zur Oberfläche des Modells in einem Struct speichern, das wiederum zum schnellen Zugriff nach Hashingart in die Liste einer von den Koordinaten abhängigen Arrayzelle eingefügt werden soll.

Die Initialisierung sieht so aus:

dlist * vertices = new dlist[x*y*z]

wobei x, y, z die maximale Ausdehnung in x-,y-,z-Richtung ist.

Der Konstruktor der DoubleLinkedList-Klasse dlist setzt die Pointer auf erstes und letztes Element (Knoten) auf NULL:

dlist::dlist()
{
this->front = NULL;
this->back = NULL;
}

Das Problem ist tritt auf, wenn ich einen Knoten bereits in die Liste einer Arrayzelle x (vertices[x]) eingefügt habe, und nun einen zweiten Knoten in eine ganz andere Arrayzelle y einfüge. Dann hat die enstsprechende Liste bereits einen front- und einen back-Pointer, der nicht auf NULL zeigt, und die beiden Pointer haben als next-Element auch noch sich gegenseitig, sodass ich beim Durchlaufen auf der Suche nach der passenden Einfügestelle (ordered list) in eine Endlosschleife gerate.

Die komplette Klasse dlist.cpp sieht folgendermaßen aus:

------------------------------------------------------------------

#include "dlist.h"

dlist::dlist()
{
	front=NULL;
	back=NULL;
}

dlist::~dlist()
{
}

//insert a node before nodeB
void dlist::insertBefore(vertexPlus * value,node *nodeB)    
{
	node *newNode;
	newNode=new node();
	newNode->prev=nodeB->prev;
	newNode->next =nodeB;
	newNode->value =value;	
	if(nodeB->prev==NULL)
	{
		this->front=newNode;	
	}
	nodeB->prev=newNode;
	removeNode(newNode);

}

//insert a node before the front node 
void dlist::insertFront (vertexPlus * value)
{
	node *newNode;
	if(this->front==NULL)
	{
		newNode=new node();
		this->front=newNode;
		this->back =newNode;
		 newNode->prev=NULL;
		 newNode->next=NULL;
		 newNode->value=value;

	}
	else
	{
		 insertBefore(value,this->front );
	}
}

//insert a node after  nodeB
void dlist::insertAfter(vertexPlus * value,node *nodeB)
{
	node *newNode;
	newNode=new node();
	newNode->next= nodeB->next ;
	newNode->prev  =nodeB;
	newNode->value =value;

	if(nodeB->next==NULL)
	{
		this->back =newNode;	
	}

	nodeB->next=newNode;
}

//insert a node after the last node 
void dlist::insertBack (vertexPlus * value)
{          
		if(this->back==NULL)
		{
			insertFront(value);
		}
		else
		{
			insertAfter(value,this->back  );
		}
}

void dlist::insert( vertexPlus * value)
{
	node * currentNode;
	currentNode = this->front;

	if( currentNode == NULL )
	{
		insertFront(value);
	}
	else
	{
		while( currentNode != NULL )
		{
			// If vertex already exists, return
			if( currentNode->value->coord == value->coord )
				return;
			else if( currentNode->value->coord > value->coord )
			{
				insertBefore(value, currentNode );
				return;
			}
			currentNode = currentNode->next;
		}
		insertBack(value);
	}

	return;
}

bool dlist::find( vertexPlus * value)
{

	node * currentNode;
	currentNode = this->front;

	if( currentNode == NULL )
	{
		return false;
	}
	else
	{
		while( currentNode != NULL )
		{
			if( currentNode->value->coord == value->coord )
				return true;
			currentNode = currentNode->next;
		}
		return false;
	}
}

und der relevante Part von der Headerdatei:

class node
{
public:
vertexPlus * value;           //value stored in the node 
node *next;          //pointer to next node 
node *prev;          //pointer to previous node 
};

class dlist
{
public:

dlist();
~dlist();

node *front;       //pointer to front of list   
node *back;        //pointer to back of list  
..
.
};

---------------------------------------------------------------------------

wobei hier im ersten Aufruf erst find() false ausgibt und dann insert() und in dessen Konsequenz insertFront() aufgerufen wird. Im zweiten Aufruf geht find() in die Endlosschleife, weil die Liste unerklärlicherweise nicht leer ist, und der currentNode-Pointer zwischen this->front und this->back springt.

Hat es was mit der Initialisierung des Arrays zu tun? Kann bei der Initialisierung von this->front und this->back mit NULL auch sowas unerklärliches rauskommen?

Bin für jede Idee dankbar. Grüßle

Ansonsten jede Funktion einzeln debuggen...