Ich habe es mit jemanden zusammen gemacht, aber verstehe es nicht (C++ kann ich, nur dieses Thema ist nur schwer ).
Das Thema ist halt Zeiger und Verkettete Listen.

Könnt ihr mir vielleicht das erklären?
(Ob ihr mir ALLES erklärt oder nur ein Teil, bleibt euch überlassen, wobei ich mich freuen würden, wenn ich ALLES verstehen würde.)

Was da passiert, wieso es passiert usw,... Ich MUSS es verstehen, weil ich es erklären muss.
Achja, das Programm ist fertig, da muss nichts bearbeitet werden oder so, sondern NUR erklären.
Ich muss ja auch verstehen, was da passiert, ansonsten wird das schwer mit dem eigenen Programm schreiben, irgendwann später mal.

Hier der Code:

Danke im voraus

#include <iostream>
#include <string>
using namespace std;

struct Event
{
	string Name;
	int Sitzplätze;
	int leereSitzplätze;
	Event *next;
};

void ausgabe(Event ev)
{
	cout << "Event: " << ev.Name << endl << "Sitzplaetze: " << ev.Sitzplätze << endl 
	<< "Leere Sitzplaetze: " << ev.leereSitzplätze << endl << endl;
}

void ausgabeListe(Event* startKnoten)
{
	Event* aktuellerKnoten = startKnoten;
 while (aktuellerKnoten!=0)
	{
		ausgabe((*aktuellerKnoten));
		aktuellerKnoten = aktuellerKnoten->next;
	}
}

Event* neuesEvent(string NameDesEventes,int sitzplätze, int leeresitzplätze)
{
	Event* neu = new Event;
	neu->Name = NameDesEventes;
	neu->leereSitzplätze=leeresitzplätze;
	neu->Sitzplätze = sitzplätze;
	return neu;
}

int main() 
{	
	Event *StartZeiger = NULL, *EndZeiger = NULL, *AktuellerZeiger;

	StartZeiger = neuesEvent("Romeo & Julia [Tanzstueck]",1000,580);
	AktuellerZeiger = StartZeiger;

	AktuellerZeiger->next = neuesEvent("Engel der Armen [Komoedie]",1000,450);
	AktuellerZeiger = AktuellerZeiger->next;

	AktuellerZeiger->next = neuesEvent("Sandmann [Nachtstueck]",1000,690);
	AktuellerZeiger = AktuellerZeiger->next;

	AktuellerZeiger->next = neuesEvent("Hoerbar [Kammerspiele] ",1000,600);
	AktuellerZeiger = AktuellerZeiger->next;

	AktuellerZeiger->next = EndZeiger;

	ausgabeListe(StartZeiger);

	system("pause");

	return 0;

}

Also, wo hakt's denn jetzt genau?

Übrigens: Umlaute sind bei Bezeichnern nicht standardkonform.

Ich habe es mit jemanden zusammen gemacht, aber verstehe es nicht

Wie geht das denn?

chestor00 schrieb:

Ich habe es mit jemanden zusammen gemacht, aber verstehe es nicht

Wie geht das denn?

Hast du in der Schule nie Gruppenarbeit gemacht? Unsere Lehrer waren da ganz heiß drauf. Und ich habe auch artig gelernt, dass dann der Beste (meistens ich) alles macht und der Rest die Note teilt. Und daraus Konsequenzen gezogen. Ich bin mir jedoch nicht ganz sicher, ob das die Lektion war, die vermittelt werden sollte.

Ich hab schon gegooglet nach verketteten listen, leider gibts da keine guten Erklärungen speziell auf mein Programm. Allgemein verstehe ich auch die verkettete liste nicht, auch wenn ich mir das durchlese.
Leute, die C++ können und mir helfen, kenn ich fast keine.

Ich schreib ma auf, was ich verstanden hab und was nicht:
Den Teil mit Struct Event und Void Ausgabe (event ev) verstehe ich komplett (bis zeile 20).

(1) Das mit VoidAusgabeListe und den Knoten verstehe ich wirklich 0.
Das würd ich gerne verstehen, was da passiert und wieso

(2) Was macht dieses ,,Next->'' da? (3) Was macht das ,,neu->'' da? Wieso?

(4) oder den Teil mit Event * neuesEvent.
(5) Event* neu = new Event; <-- Was passiert hier? Wieso?

(6) neu->Sitzplätze = sitzplätze; <-- Was macht der hier da?

(7) Event *StartZeiger = NULL, *EndZeiger = NULL, *AktuellerZeiger; <-- Wieso??

7 Fragen über fragen,...

Das mit AusgabeListe(Starzeiger) (3. letzte zeile) verstehe ich glaube ich, der fängt mit den Startzeiger an und macht das solange, bis diese verkettete Liste nacheinander alles ausgegeben hat. oder????

struct MyStruct
{
  MyStruct* next; // Jedes Objekt vom Typ "MyStruct" enthält jetzt einen Zeiger auf MyStruct.
};

int main()
{
  MyStruct* p = new MyStruct;
  p->next = new MyStruct;
  p->next->next = new MyStruct;
  p->next->next->next = new Mystruct;
}

Eine Liste funktioniert also so, dass du weißt wo das erste Element liegt, und jedes Element einen Zeiger auf das nächste Element hält. Damit man weiß, wo die Liste zu Ende ist, hält das letzte Element einen Nullzeiger. So kann man sich durch die gesamte Liste hangeln.

Und was heißt du hast den einfachen Teil gemacht? Das ist alles einfach, zumal du deinen Fragen nach zu urteilen überhaupt nichts verstanden hast. Das hat SeppJ schon ganz richtig beschrieben.

chestor00 schrieb:

(6) neu->Sitzplätze = sitzplätze; <-- Was macht der hier da?

Ist die Frage ernst gemeint? Das ist eine Zuweisung. oO

Oder verstehst du einfach den Pfeil nicht? Der Pfeil ist eine gleichzeitige Dereferenzierung:

struct A
{
  A* next;
};

int main()
{
  A* a = new A;

  a->next = 0;
  // Äquivalent zu:
  (*a).next = 0;
}

PS: Da ihr ja scheinbar einfach mal ganz galant auf ein delete verzichtet habt mache ich das auch mal so, Speicher wieder freigeben ist eh uncool.

@chestor00: Ich hoffe meine Kommentare können dir die Sache ein wenig erhellen. Frag sonst einfach noch einmal nach! Vielleicht kann auch noch jemand anders die Sache noch besser erklären.

Willi ...

#include <iostream>
#include <string>
using namespace std;

struct Event
{
    string Name;
    int Sitzplätze;
    int leereSitzplätze;
    Event *next;	// das sternchen heisst: Zeiger
					// "next" ist ein Zeiger auf eine "struct Event" 
};

void ausgabe(Event ev)
{
    cout << "Event: " << ev.Name << endl << "Sitzplaetze: " << ev.Sitzplätze << endl
    << "Leere Sitzplaetze: " << ev.leereSitzplätze << endl << endl;
}

void ausgabeListe(Event* startKnoten)		// "startKnoten" ist auch ein Zeiger auf "struct Event"
{
    Event* aktuellerKnoten = startKnoten;	// hier wird eine neue Variable mit namen "aktuellerKnoten" vereinbart
											// sie ist vom Typ "Zeiger auf struct Event"

 while (aktuellerKnoten!=0)		// das ist eine Programm-Schleife
								// solange wie "aktuellerKnoten" nicht gleich null ist wird der folgende
								// Block ausgeführt
    {
        ausgabe((*aktuellerKnoten));	// Das sternchen hier ist eine dereferenzierung. Die Funktion ausgabe()
										// verlangt eine "struct Event", mit dem sternchen bekommen wir vom "Zeiger
										// auf struct Event" die "struct Event". 
										// du kannst das sternchen hier auch als "inhalt von..." lesen.

        aktuellerKnoten = aktuellerKnoten->next;	// hier wird die Variable "aktuellerKnoten" auf den nächsten Knoten
													// gesetzt. 
    }
}

Event* neuesEvent(string NameDesEventes,int sitzplätze, int leeresitzplätze)
{
    Event* neu = new Event;		// hier wird Speicher für eine neue "struct Event" angefordert.
								// (eine generelle Beschreibung kannst du hier finden: 
								// http://ladedu.com/cpp/kapitel3_dynamische_speicherverwaltung
								// "neu" ist ein Zeiger auf die neu angeforderte struktur.

	// in den folgenden drei linien wird die struktur mit inhalt gefüllt.
    neu->Name = NameDesEventes;				
    neu->leereSitzplätze=leeresitzplätze;
    neu->Sitzplätze = sitzplätze;

    return neu;	// die neue struktur zurückgeben.
}

int main()
{   
	// zuerst werden drei Variablen vereinbart: StartZeiger, EndZeiger und AktuellerZeiger. 
	// StartZeiger und EndZeiger werden sofort mit 0 beschrieben.
    Event *StartZeiger = NULL, *EndZeiger = NULL, *AktuellerZeiger;

	// die Funktion "neuesEvent" generiert eine neue "struct Event" und liefert einen Zeiger darauf.
	// diese neue struktur wird der Variable "StartZeiger" zugewiesen. 
    StartZeiger = neuesEvent("Romeo & Julia [Tanzstueck]",1000,580);
    AktuellerZeiger = StartZeiger;	// damit zeigt "AktuellerZeiger" auf das Ende der Liste.

	// die Funktion "neuesEvent" generiert eine neue "struct Event" und liefert einen Zeiger darauf.
	// diese neue struktur wird der Variable "AktuellerZeiger->next" zugewiesen. Damit wird die
	// eigentliche verkettung durchgeführt.
    AktuellerZeiger->next = neuesEvent("Engel der Armen [Komoedie]",1000,450);
    AktuellerZeiger = AktuellerZeiger->next;	// damit zeigt "AktuellerZeiger" auf das Ende der Liste.

	// die Funktion "neuesEvent" generiert eine neue "struct Event" und liefert einen Zeiger darauf.
	// diese neue struktur wird der Variable "AktuellerZeiger->next" zugewiesen. Damit wird die
	// eigentliche verkettung durchgeführt.
    AktuellerZeiger->next = neuesEvent("Sandmann [Nachtstueck]",1000,690);
    AktuellerZeiger = AktuellerZeiger->next;	// damit zeigt "AktuellerZeiger" auf das Ende der Liste.

	// die Funktion "neuesEvent" generiert eine neue "struct Event" und liefert einen Zeiger darauf.
	// diese neue struktur wird der Variable "AktuellerZeiger->next" zugewiesen. Damit wird die
	// eigentliche verkettung durchgeführt.
    AktuellerZeiger->next = neuesEvent("Hoerbar [Kammerspiele] ",1000,600);
    AktuellerZeiger = AktuellerZeiger->next;	// damit zeigt "AktuellerZeiger" auf das Ende der Liste.

	// Der Letzte Eintrag der Liste muss ein 0 bekommen! Das ist wichtig weil sonst die schleife oben 
	// in der funktion "ausgabeListe()" einfach weiterlaufen würde.
    AktuellerZeiger->next = EndZeiger;

    ausgabeListe(StartZeiger);

    system("pause");

    return 0;

}

int Sitzplätze; 
    int leereSitzplätze;

Ihr solltet euch auf eine Konvention einigen (Stichworte zum googeln: Camel Case / Pascal Case), sowas geht in der beruflichen Praxis später mal gar nicht. Und Umlaute sollten in den Bezeichnern nicht verwendet werden.

Ich habe mich stundenlang intensiv mit Zeigern beschäftigt und viel gegoogelt, und nun, wo ich das mit den Zeigern verstanden habe, verstehe ich jetzt auch das meiste von diesem Programm.
Dieses Programm besteht ja fast nur davon.

@Willi Burkhardt: Dankeschön, dass du dir soviel mühe gemacht hast.

Auch an den Rest danke