lempy

Hey Hab es geschafft. Das Programm läuft wie es soll. Kann mir jetzt jemand erklären warum es so läuft? Geänderte Stellen habe ich mit Hinweisen versehen. #include "stdafx.h" using namespace System; ref class listenelement { String ^daten; listenelement ^next; listenelement ^ende; public: Void setDaten(String ^datenneu); Void anhaengen(String ^datenneu); Void ausgeben(); Void ausgaberueck(); }; Void listenelement::setDaten(String ^datenneu) { daten = datenneu; } Void listenelement::anhaengen(String ^datenneu) { if (next == nullptr) { next = gcnew listenelement; next -> daten = datenneu; ende = next; } else { ende -> anhaengen(datenneu); } Console::WriteLine("Daten {0} wurden eingfügt.\n",datenneu); } Void listenelement::ausgeben() { Console::WriteLine("{0}",daten); if (next != nullptr) next -> ausgeben(); } Void listenelement::ausgaberueck() { Console::WriteLine(); if(ende != nullptr) ende -> ausgaberueck(); Console::WriteLine("{0}",daten); [COLOR="green"]// Hier steht die Ausgabe am Ende und es[/COLOR] } [COLOR="green"]// Funktioniert!! Warum?[/COLOR] int main(array<System::String ^> ^args) { listenelement ^listenanfang; listenelement ^listenende; listenanfang = gcnew listenelement; listenanfang -> setDaten("Element: 1"); listenende = listenanfang; for (Int32 schleife = 2; schleife < 4; schleife++) listenanfang -> anhaengen("Element: " + schleife); listenanfang -> ausgeben(); listenende -> ausgaberueck(); Console::Read(); return 0; }

Hallo flashpixx Was ist den jetzt genau der Unterschied von Rekursion und Iteration? Habe ich irgendwie nicht wirklich verstanden. Dein Link zur Rekursion bringt mich für mein Programm nicht weiter. Keine Ahnung wie ich das umsetzen soll. Hier noch mal meinen etwas abgeänderten Code, der zwar 3, 2, 1 ausgibt, sondern 3, 2, 3, 3. Vielleicht kannst Du mir einen Tip geben, wie ich in so änder kann das wirklich 3, 2, 1 ausgegeben wird. #include "stdafx.h" using namespace System; ref class listenelement { String ^daten; listenelement ^next; listenelement ^ende; public: Void setDaten(String ^datenneu); Void anhaengen(String ^datenneu); Void ausgeben(listenelement ^listenanfang); /*Void ausgaberueck(listenelement ^listenede);*/ }; Void listenelement::setDaten(String ^datenneu) { daten = datenneu; } Void listenelement::anhaengen(String ^datenneu) { if (next == nullptr) { next = gcnew listenelement; next -> daten = datenneu; ende = next; } else { ende -> anhaengen(datenneu); } Console::WriteLine("Daten {0} wurden eingfügt.\n",datenneu); } Void listenelement::ausgeben(listenelement ^listenanfang) { Console::WriteLine("{0}",daten); if (next != nullptr) next -> ausgeben(listenanfang); /*ende = next;*/ if (ende != nullptr) ende -> ausgeben(listenanfang); } //Void listenelement::ausgaberueck(listenelement ^listenende) //{ // Console::WriteLine("{0}",daten); // // if(ende != nullptr) // { // ende -> ausgaberueck(listenende); // } //} int main(array<System::String ^> ^args) { listenelement ^listenanfang; listenelement ^listenende; listenanfang = gcnew listenelement; listenanfang -> setDaten("Element: 1"); listenende = listenanfang; for (Int32 schleife = 2; schleife < 4; schleife++) listenanfang -> anhaengen("Element: " + schleife); listenanfang -> ausgeben(listenanfang); /*for (Int32 schleife = 2; schleife < 4; schleife--) listenende -> anhaengen("Element: " - schleife);*/ /*listenende -> ausgaberueck(listenende);*/ Console::Read(); return 0; } Lieben Dank lempy

Sorry Läuft nicht: Heist, wenn ich aus der 3 eine 0 mache, dann läuft das Programm nur bis zu der Ausgabe "Nach dem Einschalten". Das ist die Kopie der Bildschirmausgabe. Habe das Problem jetzt mit "Label und goto" gelöst, möchte aber ungern GOTO verwenden. Hier noch mal das überarbeitete Programm. #include "stdafx.h" using namespace System; ref class TV_Klasse // Klasendefinition { Int32 an_aus; // Klassenelemente Int32 Programm; Int32 Ton; public: Void init(Int32 zustand); // Methoden der Klasse (Bekanntmachung) Void setprogramm(Int32 kanal); Void setton(Int32 aendern); Void ausgabe(); }; Void TV_Klasse::init(Int32 zustand) //Methode zur Initialisierung { if (zustand != 0) an_aus = 1; else an_aus = 0; Programm = 1; Ton = 5; } Void TV_Klasse::setprogramm(Int32 kanal) // Methode zum Programm ändern { Programm = kanal; } Void TV_Klasse::setton(Int32 aendern) // Methode um Ton zu ändern { Ton = aendern; } Void TV_Klasse::ausgabe() //Methode für die Ausgabe der Veränderung { Console::WriteLine("\n\nDas Gerät hat den Zustand {0} ",an_aus); Console::WriteLine("Aktives Programm {0}",Programm); Console::WriteLine("Die Lautsärke ist auf {0} \n\n\n",Ton); } int main(array<System::String ^> ^args) { TV_Klasse^ tivi; tivi = gcnew TV_Klasse; Int32 auswahl, x, z; Int32 y = 0; Console::WriteLine("Vor dem Einschalten.\n\n"); // Erster Aufruf der Methode Ausgabe [COLOR="red"]Label:[/COLOR]tivi -> ausgabe(); // um an zu zeigen das Gerät aus ist. Console::WriteLine("Gerät einschalten: 1"); // Einschalten des Gerätes Console::WriteLine("Gerät ausschalten: 0\n"); // Ausschalten des Gerätes auswahl = Console::Read(); Console::ReadLine(); switch (auswahl) { case '1': // Case-Zweig zum 1 Einschalten, da nur dann Änderungen möglich x = 1; tivi -> init(x); // Veränderung bei an_aus Console::WriteLine("Nach dem Einschalten \n"); tivi ->ausgabe(); // Ausgabe zeigt Änderungsstatus auf Eingeschaltet while (y != 3) // Beginn der Schleife für die Auswahl zum Ton oder Programm ändern { Console::WriteLine("Was möchten Sie tun?\n"); Console::WriteLine("Programm ändern: 1"); Console::WriteLine("Ton andern: 2"); Console::WriteLine("Gerät ausschalten: 0\n\n"); //Hier soll das Programm anders Funktionieren y = Convert::ToInt32(Console::Read()); // Erläuterung bei Bildschirm-ausgbe Console::ReadLine(); switch (y) // Programm ändern { case '1': Int32 kanal, i; Console::WriteLine("ARD: 1"); // Auswahl der Kanäle Console::WriteLine("ZDF: 2"); Console::WriteLine("NDR: 3"); Console::WriteLine("RTL: 4\n"); kanal = Convert::ToInt32(Console::Read()); Console::ReadLine(); switch (kanal) // Die Auswertungen der Kanalauswahl { // damit Methode setprogramm auch case '1': // nach dem eingegebenen Kanal umschaltet i = 1; tivi -> setprogramm(i); break; case '2': i = 2; tivi -> setprogramm(i); break; case '3': i = 3; tivi -> setprogramm(i); break; case '4': i = 4; tivi -> setprogramm(i); break; } // Kanal Auswahl ende break; // stop von Kanal Auswahl case '2': // Hir beginnt Zweit Ton ändern im Auswahlmenü nach Wihle z = 0; Console::WriteLine("Um die Lautstärke zu änder eine Zahl eingeben.\n"); z = Convert::ToInt32(Console::ReadLine()); tivi -> setton(z); // damit Methode setton geändert wird break; case '0': // Hier wird ein_aus zwar auf Null gesetzt // aber Programm nicht beendet z = 0; tivi -> init(z); [COLOR="red"]goto Label;[/COLOR] break; default: Console::WriteLine("Falsche Auswahl."); } tivi -> ausgabe(); // Ausgabe nach Änderungen oder Änderung } } Console::ReadKey(); return 0; } Hier noch mal die Bildschirmausgabe dazu: Vor dem Einschalten. Das Gerät hat den Zustand 0 Aktives Programm 0 Die Lautsärke ist auf 0 Gerät einschalten: 1 Gerät ausschalten: 0 1 Nach dem Einschalten Das Gerät hat den Zustand 1 Aktives Programm 1 Die Lautsärke ist auf 5 Was möchten Sie tun? Programm ändern: 1 Ton andern: 2 Gerät ausschalten: 0 2 Um die Lautstärke zu änder eine Zahl eingeben. 9 Das Gerät hat den Zustand 1 Aktives Programm 1 Die Lautsärke ist auf 9 Was möchten Sie tun? Programm ändern: 1 Ton andern: 2 Gerät ausschalten: 0 1 ARD: 1 ZDF: 2 NDR: 3 RTL: 4 3 Das Gerät hat den Zustand 1 Aktives Programm 3 Die Lautsärke ist auf 9 Was möchten Sie tun? Programm ändern: 1 Ton andern: 2 Gerät ausschalten: 0 0 Das Gerät hat den Zustand 0 // Kontrollausgabe Aktives Programm 1 Die Lautsärke ist auf 5 Gerät einschalten: 1 Gerät ausschalten: 0 // Jetzt erscheint Abfrage ein_aus wieder, also der Anfang zum erneuten Einschalten. Genauso möchte ich es haben. Wenn möglich ohne GOTO. Gruß lempy

Hallo Klotzlkopp Wegen dieser Ausgabe. Vor dem Einschalten. Das Gerät hat den Zustand 0 Aktives Programm 0 Die Lautsärke ist auf 0 Gerät einschalten: 1 Gerät ausschalten: 0 1 Nach dem Einschalten Das Gerät hat den Zustand 1 Aktives Programm 1 Die Lautsärke ist auf 5 Weiter läuft es nicht Gruß lempy

Hallo Noch mal meine Klasse und die Bildschirmausgabe mit Anmerkungen dazu. Wir funktioniert mein Gedanke richtig? #include "stdafx.h" using namespace System; ref class TV_Klasse // Klasendefinition { Int32 an_aus; // Klassenelemente Int32 Programm; Int32 Ton; public: Void init(Int32 zustand); // Methoden der Klasse (Bekanntmachung) Void setprogramm(Int32 kanal); Void setton(Int32 aendern); Void ausgabe(); }; Void TV_Klasse::init(Int32 zustand) //Methode zur Initialisierung { if (zustand != 0) an_aus = 1; else an_aus = 0; Programm = 1; Ton = 5; } Void TV_Klasse::setprogramm(Int32 kanal) // Methode zum Programm ändern { Programm = kanal; } Void TV_Klasse::setton(Int32 aendern) // Methode um Ton zu ändern { Ton = aendern; } Void TV_Klasse::ausgabe() //Methode für die Ausgabe der Veränderung { Console::WriteLine("\n\nDas Gerät hat den Zustand {0} ",an_aus); Console::WriteLine("Aktives Programm {0}",Programm); Console::WriteLine("Die Lautsärke ist auf {0} \n\n\n",Ton); } int main(array<System::String ^> ^args) { TV_Klasse^ tivi; tivi = gcnew TV_Klasse; Int32 auswahl, x, z; Int32 y = 0; Console::WriteLine("Vor dem Einschalten.\n\n"); // Erster Aufruf der Methode Ausgabe tivi -> ausgabe(); // um an zu zeigen das Gerät aus ist. Console::WriteLine("Gerät einschalten: 1"); // Einschalten des Gerätes Console::WriteLine("Gerät ausschalten: 0\n"); // Ausschalten des Gerätes auswahl = Console::Read(); Console::ReadLine(); switch (auswahl) { case '1': // Case-Zweig zum 1 Einschalten, da nur dann Änderungen möglich x = 1; tivi -> init(x); // Veränderung bei an_aus Console::WriteLine("Nach dem Einschalten \n"); tivi ->ausgabe(); // Ausgabe zeigt Änderungsstatus auf Eingeschaltet while (y != 3) // Beginn der Schleife für die Auswahl zum Ton oder // Programm ändern { Console::WriteLine("Was möchten Sie tun?\n"); Console::WriteLine("Programm ändern: 1"); Console::WriteLine("Ton andern: 2"); Console::WriteLine("Gerät ausschalten: 0\n\n"); //Hier soll das Programm anders Funktionieren y = Convert::ToInt32(Console::Read()); // Erläuterung bei Bildschirmausgabe Console::ReadLine(); switch (y) // Programm ändern { case '1': Int32 kanal, i; Console::WriteLine("ARD: 1"); // Auswahl der Kanäle Console::WriteLine("ZDF: 2"); Console::WriteLine("NDR: 3"); Console::WriteLine("RTL: 4\n"); kanal = Convert::ToInt32(Console::Read()); Console::ReadLine(); switch (kanal) // Die Auswertungen der Kanalauswahl { // damit Methode setprogramm auch case '1': // nach dem eingegebenen Kanal umschaltet i = 1; tivi -> setprogramm(i); break; case '2': i = 2; tivi -> setprogramm(i); break; case '3': i = 3; tivi -> setprogramm(i); break; case '4': i = 4; tivi -> setprogramm(i); break; } // Kanal Auswahl ende break; // stop von Kanal Auswahl case '2': // Hir beginnt Zweit Ton ändern im Auswahlmenü nach Wihle z = 0; Console::WriteLine("Um die Lautstärke zu änder eine Zahl eingeben.\n"); z = Convert::ToInt32(Console::ReadLine()); tivi -> setton(z); // damit Methode setton geändert wird break; case '0': // Hier wird ein_aus zwar auf Null gesetzt // aber Programm nicht beendet z = 0; tivi -> init(z); break; default: Console::WriteLine("Falsche Auswahl."); } tivi -> ausgabe(); // Ausgabe nach Änderungen oder Änderung } } Console::ReadKey(); return 0; } Bildschirmausgabe: Vor dem Einschalten. Das Gerät hat den Zustand 0 ( Ausgabe OK ) Aktives Programm 0 Die Lautsärke ist auf 0 Gerät einschalten: 1 (Auswahlmenü OK) Gerät ausschalten: 0 1 Nach dem Einschalten ( Ausgabe OK) Das Gerät hat den Zustand 1 Aktives Programm 1 Die Lautsärke ist auf 5 Was möchten Sie tun? Programm ändern: 1 ( Menüausgabe OK) Ton andern: 2 Gerät ausschalten: 0 1 ARD: 1 (Menüausgabe OK) ZDF: 2 NDR: 3 RTL: 4 2 Das Gerät hat den Zustand 1 ( Ausgabe OK) Aktives Programm 2 Die Lautsärke ist auf 5 Was möchten Sie tun? ( Nochmalige Frage OK) Programm ändern: 1 ( Menü OK) Ton andern: 2 Gerät ausschalten: 0 2 Um die Lautstärke zu änder eine Zahl eingeben. (Aufforderung OK) 3 Das Gerät hat den Zustand 1 (Ausgabe OK) Aktives Programm 2 Die Lautsärke ist auf 3 Was möchten Sie tun? (Menüabfrage OK) Programm ändern: 1 Ton andern: 2 Gerät ausschalten: 0 0 Das Gerät hat den Zustand 0 (Kontrollausgabe ob Gerät aus OK) Aktives Programm 1 Die Lautsärke ist auf 5 Was möchten Sie tun? :confused: ( Nicht mehr OK) Programm ändern: 1 (Hier möchte einen Programmende. Entweder schließen des Ton andern: 2 (Programm oder die Abfrage Gerät einschalten bzw. Gerät ausschalten: 0 ( ausschalten Wie kann ich das Programm ansonsten so behalten, aber ohne die jetzige letzte Auswahl? Für Eure Hilfe lieben Dank lempy

Sorry. Mit dem Code-Schnipsel kann ich nichts anfangen. Keine Ahnung was Du mir damit sagen willst. Klar ist mir, dass die Methode ausgeben() durch nochmaligen Aufruf das ganze Rückwärts ausgeben soll. Dazu verstehe ich Deinen Hinweis nicht. Gruß lempy

Hallo Bei einem rekursiven Aufruf, ruft eine sich eine Funktion oder Methode selber wieder auf. Richtig? Wie aber kann ich einen solchen Aufruf mit Rückwärtsausgabe schreiben? Noch einmal die verkettete Liste in Klasse: [code#include "stdafx.h" using namespace System; ref class listenelement { String ^daten; listenelement ^next; listenelement ^ende; public: Void setDaten(String ^datenneu); Void anhaengen(String ^datenneu); Void ausgeben(); }; Void listenelement::setDaten(String ^datenneu) { daten = datenneu; } Void listenelement::anhaengen(String ^datenneu) { if (next == nullptr) { next = gcnew listenelement; next -> daten = datenneu; ende = next; } else { ende -> anhaengen(datenneu); } Console::WriteLine("Daten {0} wurden eingfügt.\n",datenneu); } Void listenelement::ausgeben() { Console::WriteLine("\n{0}",daten); if (next != nullptr) next -> ausgeben(); Console::WriteLine("\n\n"); /*if (next != nullptr) next - next; next -> ausgeben();*/ } int main(array<System::String ^> ^args) { listenelement ^listenanfang; listenelement ^listenende; listenanfang = gcnew listenelement; listenanfang -> setDaten("Element: 1"); listenende = listenanfang; for (Int32 schleife = 2; schleife < 4; schleife++) listenanfang -> anhaengen("Element: " + schleife); listenanfang -> ausgeben(); listenende -> ausgeben(); Console::WriteLine(); Console::Read(); return 0; } ] Bei diesem Versuch gibt mir das Programm das ganze noch mal in 1, 2, 3 aus und so soll es ja auch nicht sein. Bedingung ist ein Rekursiver Aufruf der Methode ausgeben(); next-- oder --next werden die Minuszeichen mukiert und mit nullptr das selbe. Im Moment keinen Plan. Danke lempy

Hallo Mein Programm gefällt mir so, wie es ist nicht wirklich. Wie kann man das hinbekommen, dass ich keine Zahl bei tivi -> Kanal(z. B. 3) angeben muss, sondern diese durch eine Eingabe geändert wird? Ich gebe die Zahl 3 nach Aufforderung ein und der Aufruf erfolgt dann so: tivi -> Kanal( i )? Die Ausgaben soll dann so aussehen: Gerät ist aus!! Das Gerät hat den Zustand: 0 (für aus) Aktives Programm: 0 Die Lautstärke ist auf: 0 Gerät ist an!! Das Gerät hat den Zustand: 1 (für an) Aktives Programm: 1 (für z. B. ARD) Die Lautstärke ist auf: 5 Nach dem Ändern des Programms!! Das Gerät hat den Zustand: 1 (für aus) Aktives Programm: 3 (für z. B. NDR) Die Lautstärke ist auf: 5 Nach dem Ändern der Lautstärke!! Das Gerät hat den Zustand: 1 (für aus) Aktives Programm: 3 (für z. B. ARD) Die Lautstärke ist auf: 9 Wie kann ich diese Ausgabe so hinbekommen, dass ich dafür in einem Menü oder ähnliches nur die entsprechende Zahl eingeben brauche und diese dann an Ausgabe gegeben wird? Lieben Dank lempy

Hallo Glaube es so auch geschafft zu haben. Währe nett, wenn Ihr mich informiert, wenn die Anforderungen nicht korrekt sind. // Test.cpp: Hauptprojektdatei. #include "stdafx.h" using namespace System; ref class TV_Klasse { Int32 an_aus; Int32 programm; Int32 ton; public: Void init(Int32 zustand); Void Kanal(Int32 waehlen); Void lautstaerke(Int32 aendern); Void ausgabe(); }; Void TV_Klasse::ausgabe() { //TV_Klasse::init(); Console::WriteLine("\n\nDas Gerät hat den Zustand {0}\n ",an_aus); Console::WriteLine("Aktives Programm {0}\n",programm); Console::WriteLine("Die Lautsärke ist auf {0} \n\n\n",ton); } Void TV_Klasse::init(Int32 zustand) { an_aus = 1; programm = 1; ton = 5; } Void TV_Klasse::Kanal(Int32 waehlen) { //programm = waehlen; //Int32 i; if ((programm + waehlen) > 1) { programm = programm + waehlen - 1; } else { programm = programm - waehlen; } } Void TV_Klasse::lautstaerke(Int32 aendern) { if ((ton + aendern) > 5) { ton = ton + aendern - 5; } else { ton = ton - aendern; } } int main(array<System::String ^> ^args) { TV_Klasse^ tivi; tivi = gcnew TV_Klasse; Int32 auswahl; Console::WriteLine("Vor dem Einschalten.\n\n"); tivi -> ausgabe(); Console::WriteLine("Gerät einschalten: 1\n"); Console::WriteLine("Gerät ausschalten: 0\n"); auswahl = Console::Read(); Console::WriteLine("\n\nNach dem Einschalten \n"); switch(auswahl) { case '1': tivi -> init(1); tivi ->ausgabe(); Console::WriteLine("\n\nJetzt wird das Progamm geändert\n\n"); tivi -> Kanal(3); tivi -> ausgabe(); Console::WriteLine("\n\nJetzt der Ton"); tivi -> lautstaerke(9); tivi -> ausgabe(); break; case '0': Console::WriteLine("Das Gerät ist ausgeschlatet"); break; default: Console::WriteLine("Falsche Taste gewählt"); } Console::ReadKey(); return 0; } lieben Dank lempy

Hey!! Bin leider noch nicht zur Änderung gekommen, aber den enum-Hinweis finde ich super. Melde mich dann wieder, wenn ich Programm geändert habe. Hoffe ja, dass ich das ganze nachher besser verstehe, wenn es tiefer in den Bereich der Klassen geht. lieben Dank lempy

Hallo Das war doch mal eine ganz große Hilfe!! Also wenn möglich alles in main schreiben und ändern, so das die Ausgabe nur noch die Änderungen anzeigt. Programm ist im Grunde noch so geblieben, aber werde heute Abend daran arbeiten und hoffe, das ich morgen Abend eine andere "Version" fertig habe. Aber erst nach der Schule. Ist es generell so, dass man in Klassen diese Änderungen und Eingaben in main verfasst? Oder ist zu Anfang nur leichter zu lernen? Danke lempy

Lieben Dank. "tivi" raus. OK funktioniert auch ohne. Mein Problem besteht aber immer noch. Wenn ich in dem Auswahlmenüh die 2 wähle, dann springt das Programm raus. Ruft also nicht die Methode (Funktion) Programmaendern auf. Habe die Methode Programmaendern so aufgebaut: Void TV_klasse::programmaendern(Int32 waehlen) (Programmaendern(Int32 waehlen) { Console::WriteLine("Das Programm ändern.\n\n"); Console::WriteLine("ARD: 1\n"); Console::WriteLine("ZDF: 2\n"); Console::WriteLine("NDR: 3\n"); Console::WriteLine("RTL: 4\n"); waehlen = Console::Read(); switch (waehlen) { case '1': Console::WriteLine("Sie sehen jetzt ARD."); break; case '2': Console::WriteLine("Sie sehen jetzt ZDF."); break; case '3': Console::WriteLine("Sie sehen jetzt NDR."); break; case '4': Console::WriteLine("Sie sehen jetzt RTL."); default: Console::WriteLine("Falsche Auswahl."); break; } } Ungefär so sollte die Auswahl aussehen, aber ich denke es würde eher funktonieren wenn ich den Aufruf so schreiben würde "programmaendern(2)" die zwei würde dann für ARD oder so stehen. Nur so würde ich die Zahl ja nicht eingeben können, weil sie ja im Programm schon vorgegeben ist. Wie würde das ganze mit "get" und "set" aussehen? Könnte man damit eine Auswahl für Tastatureingabe aufbauen? Habe dazu noch nichts verständliches gefunden. Oder muss ich mir etwas ausdenken, wo ich das ganze über "main" steuern kann? Mit Auswahlmenü würde ich das ganze für mich irgendwie sinnvoller laufen. Lieben Dank und Gruß lempy

Hallo, ich mal wieder Ich soll ein Programm entwickeln in dem ich ein Fernsehgerät mindestens einmal einschalte und nur im eingeschalteten Zustand das Programm und die Lautstärke ändern kann. Der jeweilige Zustand soll in der "Funktion?" ausgabe() ausgegeben werden. Mein Programm sieht bis jetzt so aus, ist aber nur ein erster Gehversuch. #include "stdafx.h" using namespace System; ref class TV_klasse { Int32 ein_aus; Int32 programm; Int32 ton; TV_klasse^ tivi; public: //Void init(Int32 zustand); //Void ein_aus(Int32 zustand); Void programmaendern(Int32 waehlen); Void lautstaerke(Int32 aendern); Void ausgabe(); }; //Void TV_klasse::init(Int32 zustand) //{ // ein_aus = zustand; //} Void TV_klasse::programmaendern(Int32 waehlen) { Console::WriteLine("Das Programm ändern."); } Void TV_klasse::lautstaerke(Int32 aendern) { Console::WriteLine("Die Lautstärke ändern."); } Void TV_klasse::ausgabe() { Int32 aendern; Console::WriteLine("Gerät ist eingeschaltet.\n\n\n\n"); Console::WriteLine("Was möchten Sie ändern?\n\n"); Console::WriteLine("Gerät ausschalten: 0\n"); Console::WriteLine("Programm: 2\n"); Console::WriteLine("Lautstärke: 3\n"); aendern = Console::Read(); switch (aendern) { case '2': tivi -> programmaendern(programm); break; case '3': tivi -> lautstaerke(ton); break; case '0': Console::WriteLine("Das Gerät ist ausgeschaltet worden."); break; default: Console::WriteLine("Falsche Taste gedrückt."); } } n "main" rufen ich in dem Case-Zweig die "Funktion" ausgabe auf, um das nächste Auswahlmenüh zu erhalten. Das klappt. Nur, wenn ich dann die 2 wähle um das Programm zu ändern springt es raus und zeigt mir wieder meinen geschriebenen Code an. Also nicht die Funktion zum Ändern des Programms. Aufgaben Hinweise sind folgende: Eigenschaften: Lautstärke, Programm und ein- bzw. ausgeschaltet Alle drei Eigenschaften sollen geändert werden können. 1. Änder von Programm und Lautstärke nur dann möglich, wenn Gerät eingeschaltet ist. 2. Gerät mindestens einmal einschalten umd Programm und Lautstärke zu ändern. Dan Gerät wieder ausschalten. 3. Änderung des aktuellen Zustandes auf dem Bildschirm ausgeben 4. Instand auf dem verwalteten Heap erstellen (Bei mir in main TV) 5. Nur über die Methoden ("Funktionen") der klasse auf die Attribute zugreifen. Auch bei der Ausgabe der Werte. Genau dass schien ich nicht zu verstehen. Denke ich zumindest. Warum ruft mein Programm nicht die Methode Programmaendern auf, sonder bricht ab? Kann ich in den Methoden wie in den vor Programmen der Structuren arbeiten. Mit Hilfshandle usw.? Wie würde das mit "get" und "set" funktionieren? Habe ich nicht so ganz verstanden. Ach so Kapselung, Vererbung und was noch kommen mag war noch nicht. Das letzte im Heft war die Instanz, also quasi Klasse in Form von Strukturen? Kann man das so ausdrücken? Bin für Eure Hilfestellung sehr dankbar lieber Gruß lempy int main(array<System::String ^> ^args) { TV_klasse^ TV; TV = gcnew TV_klasse; Int32 auswahl; Console::WriteLine(" Einschalten: 1"); Console::WriteLine("\n Ausschlaten: 0"); auswahl = Console::Read(); switch(auswahl) { case '1': //TV -> ein_aus(); TV -> ausgabe(); //Console::WriteLine("Test"); break; case '0': //TV -> ein_aus(); Console::WriteLine("TV ist aus"); break; default: Console::WriteLine("Sie haben die falsche Taste gedrückt"); } Console::ReadKey(); return 0; }

Aha!! Jetzt noch mal die Frage. Es kann so beleiben wie es jetzt ist? Antwort währe nett, da ich das ganze dann doch verstanden habe Lieben Gruß und besten Dank lempy

Hallo Rekon1602 Danke erst ein mal. ^start und ^prev muss ich sicherlich noch in das Programm mit einbauen? Nur wie und wo? Verwirrt mich ein wenig, denn aus der Aufgabenstellung geht das für mich nicht hervor und die doppelt verkettete Liste wurde auch nicht näher behandelt. Ich gebe die Angaben dazu. "Erweitern Sie die einfach verkettete Liste so, dass sie zu einer doppelt verketteten Liste wird. Ergänzen Sie das Programm außerdem um eine Funktion, die die Liste rückwärts ausgibt. 1. Hilfestellung: Sie benötigen einen neuen Handle in der Struktur, der die Adresse des Vorgängers aufnehmen kann. Das soll bei listen ^ende sein 2. Hilfestellung: Die wichtigste Änderung müssen Sie beim Anhängen des neuen Elements vornahmen. Hier müssen Sie die Adresse des Vorgängers in Sicherheit bringen " Das soll bei mir listenelement ^listenende sein. z. B. listenende = hilfsHandle und dann hilfsHandle -> next -> ende bei mir. Vielleicht kannst Dur mir mit einer Erklärung, warum doch nicht nur ^ende, sondern auch noch ^start und ^prev Licht in die Dunkelheit bringen. Mit lieben Dank lempy

Hallo Leute Nach der einfachen verketteten Liste nun die doppelt verkettete Liste mit der Ausgabe Rückwärts. Die Ausgabe Rückwärts klappt aber ich glaube, ich habe die doppelt verkettete Liste nicht verstanden. Sieht in den bildlichen Darstellung ganz logisch aus, aber mit dem ins Programm umsetzen tue ich mich recht schwer. Währe nett, wenn einer von Euch mal in paar verständliche Anmerkungen dazu machen könnte, wie bei der einfach verketteten Liste. Hier mein Code: // Test zu 5_2.cpp: Hauptprojektdatei. #include "stdafx.h" using namespace System; ref struct listenelement { String ^daten; listenelement ^next; listenelement ^ende; }; // neues Element am Ende der Liste anhängen Void anhaengen (String ^datenneu, listenelement ^listenanfang) { // ein Hilfshandle zum Wandern in der Liste listenelement ^hilfsHandle; // HilfsHandle an den Anfang der Liste setzen hilfsHandle = listenanfang; // Hilfshandle zum Speichern des Vorgängers listenelement ^listenende; // Durch die Liste gehen, bis das letzte Element erreicht ist while (hilfsHandle -> next != nullptr) { hilfsHandle = hilfsHandle -> next; } // Aktuelle Adresse im Listenende speichern listenende = hilfsHandle; // Neues Element am Ende der Liste anhängen hilfsHandle -> next = gcnew listenelement; // Hilfshandle auf das neue Element setzen hilfsHandle = hilfsHandle -> next; // Vorgänger in letzte Adresse speichern hilfsHandle -> ende = listenende; // Zeichenkette im neuen Element eintragen hilfsHandle -> daten = datenneu; // nullptr wird automatisch zugewiesen! } // Alle Elemente der Liste ausgeben Void ausgaberueckwaerts ( listenelement^ listenende) { Console::WriteLine("{0}",listenende->daten) ; while (listenende->ende != nullptr) { listenende = listenende->ende; Console::WriteLine("{0}",listenende->daten) ; } //Eine leere Zeile ausgeben Console::WriteLine(); } Void ausgeben (listenelement ^listenanfang) { // ein Hilfshandle zum Wandern in der Liste listenelement ^hilfsHandle; hilfsHandle = listenanfang; // erstes Element ausgeben Console::WriteLine("{0}", hilfsHandle -> daten); // Solange das Ende der Liste noch nicht erreicht ist: // hilfshandle auf das nächste Element setzen und die Daten ausgeben while (hilfsHandle -> next != nullptr) { hilfsHandle = hilfsHandle -> next; Console::WriteLine("{0}", hilfsHandle -> daten); } Console::WriteLine("\n\n\n"); ausgaberueckwaerts (hilfsHandle); } int main(array<System::String ^> ^args) { // Handle auf den Anfang der Liste listenelement ^listenanfang; //listenelement ^listenende; // das erste Element per Hand erzeugen listenanfang = gcnew listenelement; // Zeichenkette in das erste Element schreiben // nullptr wird automatisch gesetzt listenanfang -> daten = "Element 1"; // in einer Schleife mehrere Elemente einfügen for (Int32 schleife = 2; schleife < 5; schleife++) anhaengen("Element " + schleife, listenanfang); // die Liste ausgeben ausgeben(listenanfang); //ausgaberueckwaerts(listenende); Console::Read(); return 0; } Lieben Dank Lempy

Hallo Klotzkopp Schöne Weihnachten gehabt? Habe die Tage über mein Problem nachgedacht und bin zu dem Ergebnis gekommen, dass ich das mit der verketten Liste noch nicht so ganz verstanden habe. Obwohl das auf den Zeichnungen recht einfach und verständlich dargestellt wurde. Doch wie setze ich diese Zeichnungen in Code um??? Hatte ich mir fast gedacht. Währe auch ein wenig zu Einfach. Was ist der Rückgabetyp? Was ist der passende Wert? Ist der Wert listenanfang? Die Aufgabe lautet so: Das listenende soll nicht nach jedem neuen Anhängen erst neu ermittelt werden, sondern es soll in einen eigenen Handle gespeichert werden. Danach müsste ich einen zweiten Handle in der Funktion Anhaengen haben. Es sollte so aussehen das ich einen Speicher für listenangang und einen für listenende habe. Nur habe ich im Moment nicht den geringsten Schima, wie ich das umsetzen soll. Vielleicht kannst Dur mir noch mal eine Erklärung für Dumies zu Teil werden lassen. Gruß lempy

Hallo Klotzkopp erstmal lieben Dank für Deine Antwort. Also kann ich davon ausgehen, dass die Angabe in der Hausaufgabe "***, dass das Listenende nach jedem Anhängen ermittelt wird und auch an die Funktion main() zurückgeliefert wird." nicht wie bei Variablen passiert. Habe hier noch einmal nur die Funktion anhaengen() kopiert und dazu noch ein paar Verständnis Fragen. Void anhaengen (String ^datenneu, listenelement ^listenanfang) { // ein Hilfshandle zum Wandern in der Liste listenelement ^hilfsHandle; // HilfsHandle an den Anfang der Liste setzen hilfsHandle = listenanfang; // Hilfshandle zum Speichern des Vorgängers [COLOR="green"]listenelement ^listenende; [/COLOR][COLOR="blue"]// Deklaration des Zeigers Listenende[/COLOR] // Durch die Liste gehen, bis das letzte Element erreicht ist while (hilfsHandle -> next != nullptr) { hilfsHandle = hilfsHandle -> next; } // Aktuelle Adresse im Listenende speichern [COLOR="green"]listenende = hilfsHandle; [/COLOR][COLOR="blue"]// Hier wird dem Hilfhandle das Listende zugewiesen? [/COLOR] // Neues Element am Ende der Liste anhängen [COLOR="green"]hilfsHandle -> next = gcnew listenelement;[/COLOR] [COLOR="blue"]// Neue daten an das Listenende anhängen und weil HilfsHandle jetzt listenende zugewiesen am Ende?[/COLOR] // Hilfshandle auf das neue Element setzen [COLOR="green"]hilfsHandle = hilfsHandle -> next;[/COLOR] [COLOR="blue"]// Weil Listenhandle hilfsHandle zugewiesen wurde zeigt der Zeiger jetzt an das Ende[/COLOR] // Zeichenkette im neuen Element eintragen hilfsHandle -> daten = datenneu; // nullptr wird automatisch zugewiesen! } Reicht in der Funktion main() wirklich nur der Zeiger ^listenanfang oder müsste ich noch einen für ^listenende haben? und sind meine Anmerkungen richtig? Wenn nicht, dann bitte ich Euch mich zu verbessern. Dann habe ich noch ne zweite Aufgabe, aber die kommt erst, wenn diese zu meiner Zufriedenheit gelöst ist. Danke lempy

Hallo Leute, Bin neu hier und mache nebenbei einen Fernlehrgang in C++/CLI. Hauptberuflich bin ich momentan Umschüler und habe für das Programmieren etwas weniger Zeit. Habe mein Heftchen durchgearbeitet und habe da zu der ersten Hausaufgabe ein paar Fragen. Diese Aufgabe wurde hier schon mal aufgegriffen, aber aus dem Jahr 2009. Ich muss ein neues Hilfshandle erstellen, dass nicht mehr den Listen Anfang sondern das Listen Ende an main() übergibt. Hier erst mal mein Code, der soweit funktioniert: // Einsendeaufgabe 5.1.cpp: Hauptprojektdatei. #include "stdafx.h" using namespace System; ref struct listenelement { String ^daten; listenelement ^next; }; // neues Element am Ende der Liste anhängen Void anhaengen (String ^datenneu, listenelement ^listenanfang) { // ein Hilfshandle zum Wandern in der Liste listenelement ^hilfsHandle; // HilfsHandle an den Anfang der Liste setzen hilfsHandle = listenanfang; // Hilfshandle zum Speichern des Vorgängers listenelement ^listenende; // Durch die Liste gehen, bis das letzte Element erreicht ist while (hilfsHandle -> next != nullptr) { hilfsHandle = hilfsHandle -> next; } // Aktuelle Adresse im Listenende speichern listenende = hilfsHandle; // Neues Element am Ende der Liste anhängen hilfsHandle -> next = gcnew listenelement; // Hilfshandle auf das neue Element setzen hilfsHandle = hilfsHandle -> next; // Vorgänger in letzte Adresse speichern //hilfsHandle -> ende = listenende; // Zeichenkette im neuen Element eintragen hilfsHandle -> daten = datenneu; // nullptr wird automatisch zugewiesen! } // Alle Elemente der Liste ausgeben Void ausgeben (listenelement ^listenanfang) { // ein Hilfshandle zum Wandern in der Liste listenelement ^hilfsHandle; hilfsHandle = listenanfang; // erstes Element ausgeben Console::WriteLine("{0}", hilfsHandle -> daten); // Solange das Ende der Liste noch nicht erreicht ist: // hilfshandle auf das nächste Element setzen und die Daten ausgeben while (hilfsHandle -> next != nullptr) { hilfsHandle = hilfsHandle -> next; Console::WriteLine("{0}", hilfsHandle -> daten); } } int main(array<System::String ^> ^args) { // Handle auf den Anfang der Liste listenelement ^listenanfang; //listenelement ^listenende; // das erste Element per Hand erzeugen listenanfang = gcnew listenelement; // Zeichenkette in das erste Element schreiben // nullptr wird automatisch gesetzt listenanfang -> daten = "Element 1"; // in einer Schleife mehrere Elemente einfügen for (Int32 schleife = 2; schleife < 4; schleife++) anhaengen("Element " + schleife, listenanfang); // die Liste ausgeben ausgeben(listenanfang); Console::Read(); return 0; } Jetzt meine Fragen: Normalerweise werden Variablen doch mit return an main weiter gegeben, oder? Void übergibt doch eigentlich keine Werte. Warum, funktioniert dieser Code? Läuft das bei verketteten Listen etwas anders? Habe schon in meinen zusätzlichen Büchern versucht was zu finden, aber das war eher verwirrend, weil der dort enthaltende Code wohl eher für Fortgeschrittene verständlich ist als für einen Anfänger. Währe nett, wenn mir einer von Euch erklären kann, wie das mit der Übergabe von Werten bei verketteten Listen Funktioniert. Lieben Dank lempy