ich bin gerade dabei Listen für ein Rechenprogramm zu implementieren.
Dabei kommt immer folgende Fehlermeldung:

error C2143: Syntaxfehler: Es fehlt ';' vor '*'

und einige Folgefehler.

Es geht um die Zeile 48:

sItem* cList::GetLastItem()

(Ist unten auch markiert)

Sieht Jemand, wo das ';' fehlt, oder ob es vlt einen anderen Grund hat?

namespace ListHandler {

	public class cList
	{
	public:
		struct sItem
		{
			float Value;

			sItem* NextItem;
		};

		cList(float fValue);
		~cList();

		void AddItem(float Value);
		sItem* GetLastItem(void);
		float GetItem(int ItemIndex);
		void ClearList(void);

	private:
		sItem ListHeader;

	};

	cList::cList(float fValue)	
	{	
		ListHeader.Value = fValue;
	}

	cList::~cList()	
	{	
		cList::ClearList();
	}

	float cList::GetItem(int ItemIndex)
	{
		sItem* NewItem = &ListHeader;

		for (int i = 0; i < ItemIndex - 1; i++)
		{
			NewItem = NewItem->NextItem;
		}

		return NewItem->Value;
	}

	sItem* cList::GetLastItem()     //Fehler tritt hier auf
	{
		sItem* nextItem = &ListHeader;

		while(NULL != nextItem->NextItem)
		{
			nextItem = nextItem->NextItem;
		}

		return nextItem;
	}

//	...  code geht noch weiter

}

Ich studiere ab dem nächsten monat softwaretechnik und diese listen kommen auch irgendwann dran. Deshalb schau ich sie mir lieber jetzt genauer an. Selbermachen ist besser als fertiges nutzen

Ich studiere ab dem nächsten monat softwaretechnik und diese listen kommen auch irgendwann dran. Deshalb schau ich sie mir lieber jetzt genauer an.

Das akzeptiere ich...

KillerPille schrieb:

Selbermachen ist besser als fertiges nutzen

Aber diese Aussage ist im Softwareumfeld, bei dem es auch um Entwicklungszeit geht, einfach Unsinn.

KillerPille schrieb:

Selbermachen ist besser als fertiges nutzen

Aber diese Aussage ist im Softwareumfeld, bei dem es auch um Entwicklungszeit geht, einfach Unsinn.

Es geht mir dabei ums Lernen. Und im Moment habe ich ja noch Zeit dafür.

asc schrieb:

KillerPille schrieb:

Selbermachen ist besser als fertiges nutzen

Aber diese Aussage ist im Softwareumfeld, bei dem es auch um Entwicklungszeit geht, einfach Unsinn.

Es geht mir dabei ums Lernen. Und im Moment habe ich ja noch Zeit dafür.

Das hat er ja auch akzeptiert und wir alle finden das vollkommen in Ordnung. Er wollte dir damit nur sagen, dass das aber später im "echten Leben" so nicht mehr gemacht wird bzw. werden kann, weil einfach die Zeit fehlt. Man muss es schließlich nicht nur programmieren, sondern auch planen und genaustens testen. Da ist man mit fertigen Klassen, die es schon über Jahre hinweg gibt besser dran.

Hast du das Problem jetzt gelöst? Der Titel deutet das zumindest an.

for (int i = 0; i < ItemIndex - 1; i++)
{
 if (!NewItem)
 {
  break;
 }

 NewItem = NewItem->NextItem;
}

Ungetestet, aber vermutlich besser.

namespace ListHandler {

	/*public*/ class cList //das public hat hier nix zu suchen
	{
	public:
		struct sItem
		{
			float Value;

			sItem* NextItem;
		};
		
		cList(float fValue);
		~cList();

		void AddItem(float Value);
		sItem* GetLastItem(/*void*/); //es ist unüblich in C++ (void) zu schreiben - man schreibt statt dessen ()
		float GetItem(int ItemIndex) /**/const/**/; //google mal nach const correctness
		void ClearList(void);

	private:
		/*sItem ListHeader;*/ //wie möchtest du so eine leere Liste bewerkstelligen? Wenn ich du wäre, würde ich einen Pointer auf das erste Element speichern:
		sItem* ListHeader;
	};

	cList::cList(float fValue)	
	{	
		ListHeader.Value = fValue;
	}

	cList::~cList()	
	{	
		/*cList::*/ClearList();
	}

	float cList::GetItem(int ItemIndex)
	{
		sItem* NewItem = &ListHeader;

		for (int i = 0; i < ItemIndex - 1; i++)
		{
			NewItem = NewItem->NextItem; //noch auf 0/NULL/nullptr testen, sonst gibts nen Knall, wenn der Benutzer nicht aufpasst
		}

		return NewItem->Value;
	}

	sItem* cList::GetLastItem()     //Fehler tritt hier auf
	{
		sItem* nextItem = &ListHeader;

		while(NULL != nextItem->NextItem)
		{
			nextItem = nextItem->NextItem;
		}

		return nextItem;
	}
	
//	...  code geht noch weiter

}

bb

PS: ungarische Notation ist out - das gilt ins besondere für Bezeichner wie sItem oder cList - 1. ist es unwichtig 2. einfach nur hässlich

ich würde so anfangen:

/*header*/
class list
{
public:
  list();
  ~list();
  clear();

  void push_front(float val);
private:
  struct item;
  item* first;
};

/*source*/
struct list::item
{
  float val;
  item* next;

  item(float val = 0.f, item* next = NULL)
  : val(val), next(next)
  {}
};

list::list()
: first(NULL)
{}

list::~list()
{
  clear();
}

list::clear()
{
  item* i(first);
  while(i != 0)
  {
    item* to_del = i;
    i = i->next;

    delete to_del;
  };
}

list::push_front(float val)
{
  item* to_add = new item(val, first);
  first = to_add;
}