Ich hab hier eine Methode, die mir eine Ringliste ausgeben soll. Leider endet dies immer in eine Endlosschleife und ich weiß nicht woran es liegt. Es kann aber nur an der Methode liegen:

void ringlist::Print()
{
	element *curr = head;

	cout << "Ringliste: ";
	do
	{
		cout << curr->val << " ";
		curr = curr->next;
	}
	while(curr != head);

	cout << endl;
}

Vielleicht kann mal einer von euch Prof's ein Auge drauf werfen.

void ringlist::Append(int val)
{
	element* elem = new element;

	elem->val = val;
	elem->next = head;

	element* head_temp = head;

	if(head == NULL)
	{
		head = elem;
		head->next = elem;
	}
	else
	{
		while(head_temp->next != head)
		{
			head_temp = head_temp->next;
		}

		head_temp->next = elem;
	}
}

Die Methode die mir den Ring erzeugt, hab ich Append() genannt. Der else-Zweig sollte eigentlich den Ring schließen...; was aber anscheinend nicht tut. Weshalb er das nicht tut, bin ich aber überfragt.

Ich rufe aus der main die append() so auf:

for(int i=1; i<=6; i++)
	{
		myRingList.Append(i);
	}

dann kommt die Print() wie oben zum Einsatz.

Hier funktioniert dann noch alles.

Ich hab dann noch eine Methode die mir bestimmte values aus der Liste löscht.

if(curr->val == gZ [i])
			{
				temp = curr->val;

				if(prev == NULL)
				{
					head = curr->next;
				}
				else
				{
					prev->next = curr->next;
				}
			}
			else
			{
				prev = curr;
				curr = curr->next;
			}

Die wird jetzt aufgerufen. Danach geht es nicht mehr. Wenn ich nun bspw. das element mit dem value 1 lösche, ich mir dann das ehemalige head-Element lsöche?

#ifndef RINGLIST__H
#define RINGLIST__H
#include"element.h"

class ringlist
{
private:
	element *head;

public:
	ringlist();
	~ringlist();

	element* GetFirstElement();	//Gibt erstes Element zurück
	void Append(int value);	//Fügt Element hinzu
	void DeleteElement(element* first, int gZ[]);	//Löscht Element anhand von gZ
	void Print();	//Gibt Ringliste aus
};

#endif

void ringlist::DeleteElement(element* f)	//f=firstElement: bekommt man durch GetFirstElement()
{
	element* curr = head;
	element* prev = head->next;
	int temp = 0;

		if(curr->val == 1)   //ab hier wird nun das Element mit val=1 gelöscht...
		{
			temp = curr->val;

			if(prev == NULL)
			{
				head = curr->next;
			}
			else
			{
				prev->next = curr->next;
			}
		}
		else
		{
			prev = curr;
			curr = curr->next;
		}
}

#include<iostream>
#include"ringlist.h"
using namespace std;

int main()
{
	ringlist myRingList;

	for(int i=1; i<=6; i++)
	{
		myRingList.Append(i);
	}

	myRingList.Print();  //bis hierhin funktioniert das Programm

	myRingList.ReturnDeleteElement(myRingList.GetFirstElement());  

	myRingList.Print();  //...und jetzt bekomm ich als Ausgabe eine Endlosschleife

return 0;
}

void DeleteElement(element* first, int gZ[]);	//Löscht Element anhand

void ringlist::DeleteElement(element* f)

Wie denn nun? Außerdem fehlt die Hälfte. So geht das durch keinen Compiler.

Übrigens sind deine Include-Guards reservierte Bezeichner (enthalten __).