Programm erklären

chestor00

Wenn ich es geschafft hätte, es mir zu erklären, hätte ich hier nicht gefragt, aber ich habs doch versucht, mir selber das beizubringen, aber ich finde dieses Thema schon sehr schwer.

krümelkacker

Es sieht nur so aus, als ob Du hier fragst, weil Du kein Bock hast, dich in das Thema selbst reinzuarbeiten. Es sieht so aus, als würdest Du lieber den Weg des geringsten Widerstands gehen und darauf hoffen, dass Dir jemand die Arbeit abnimmt, während Du Dir hier und da noch ein YouTube Video reinziehst oder ein Browserspiel zockst. So kommt Deine Frage bei mir an. Und das motiviert mich natürlich nicht dazu, Dir zu helfen. Ich helfe gerne, wenn ich sehe, dass jemand versucht, sein Problem selbst zu lösen aber an bestimmten Stelle nicht weiterkommt und konkrete Fragen dazu stellt. Zum Beispiel könntest Du versuchen, soweit es geht, dieses Programm mit eigenen Worten hier zu erklären. Fehler und Lücken kann man dann hier im Rahmen einer Diskussion korrigieren bzw auffüllen. Wenn das bei Dir nicht drin ist, bist Du hier falsch. Schnapp Dir ein schlaues C++ Buch und lerne.

Ich bin Matrix...

Sieht für mich aus wie eine verkettete Liste, aber eigentlich recht "primitiv" gelöst. Heutzutage macht man sowas doch mit Klassen :o
Mir scheint, als hättest du das Programm nicht wirklich selbst geschrieben, denn wenn man im Team zusammenarbeitet, sollte schon jeder, der mitmacht das Thema auch vollständig verstehen.
Btw... Das ist eine verkettete Liste, die in der main-Funktion 4 Knoten erstellt und die aneinander hängt. Jeder, der was von C++ versteht, sollte jetzt auf den Rest schließen können

chestor00 schrieb:

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

Wie geht das denn?

SeppJ

manni66 schrieb:

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.

chestor00

@manni66: Ich hab den leichten Teil gemacht (bis Zeile 20) und er den schwierigen.

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????

cooky451

Hast du Pointer und/oder dynamische Speicherverwaltung denn verstanden? Falls nicht: Google.

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.

krümelkacker

chestor00, Dir fehlt viel zu viel an Grundlage.
Schnapp Dir ein schlaues C++ Buch und lerne!
So hat das keinen Zweck.

Jungs, lasst doch den armen Kerl nicht einfach im Regen stehen. Gebt doch vielmehr eine "gescheite" erklärung.

@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;

}

Mal 2 kleine Tipps am Rande:

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.

chestor00

Ihr habt recht, mir haben einfach die Grundlagen gefehlt.

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