Ich habe es heute getan. Ich schäme mich.
-
ja wir sollen das immer methoden nennen und nciht klassen keine ahnung was der lehrer da von uns will ich war auch für klassen er meinte das hieße methoden ...
-
-
Optimizer schrieb:
LOL. Zum Aufräumen sind Destruktoren und finally-Blöcke in anderen Sprachen da, aber ganz sicher nicht goto.
Dass man das mit Destruktoren unter C++ macht, ist ja klar aber wenn ich eine einzelne globale Funktion habe, dann packe ich die doch nicht extra in eine Klasse, damit mein Destruktor dort aufräumen kann.
-
Ranus.net schrieb:
ja wir sollen das immer methoden nennen und nciht klassen keine ahnung was der lehrer da von uns will ich war auch für klassen er meinte das hieße methoden ...
Dann ist der Lehrer eine Wurst, wenn er es wirklich so gesagt hat
Klassen können Methoden und Eigenschaften oder Operationen und Attribute haben. Dabei sind Methoden die Funktionen einer Klasse und Eigenschaften die öffentlichen Variablen dieser.
-
Der Grund, warum GOTOs urspruenglich verpoent waren, war ganz einfach, dass frueher in vielen Sprachen GOTO immer einen globalen Sprung erzeugt hat. (z.B. BASIC, BCPL)
In C/C++, sowie Pascal und Abkoemmlinge ist das aber unmoeglich. Bei diesen Sprachen kann man mit GOTO nur lokale Spruenge innerhalb einer Funktion machen, und auch die Regeln dafuer (bei C++) sind bestens festgelegt.
D.h. eigentlich ist die Sorge um GOTO mehr oder weniger veraltet.
In Sprachen wie BASIC gibt's unter Umstaenden (je nach Dialekt) nur GOTO, um Verzweigungen durchzufuehren. Dann muss man es praktisch benutzen.
Dort, wo es globale GOTOs gibt, kann hoechstens eine Kreuz- und Quer-Springerei den Code unlesbar machen, dort kann man GOTO ja auch lokal verwenden, und dann gibt es keine Probleme.
In BASIC kann es hoechstens ein Problem geben, wenn man mit GOTO in ein Unterprogramm springt, das auch mit GOSUB aufgerufen wird, oder man springt aus dem Kontext einer FOR-Schleife in eine andere FOR-Schleife, oder so etwas. Dann muss man schon genau wissen (und dokumentieren) was man tut.
GOTO kann in vielen Faellen sehr nuetzlich sein, und den Code sogar lesbarer machen.
-
//achtung, alles ungetestet
Zufallsgenerator: Raetselnummer=random(3); //------------------------------------------- if(Raetselnummer==0 && Raetsel1geloest==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel1; } if(Raetselnummer==0 && Raetsel1geloest==true) { goto Zufallsgenerator; } //-------------------------------------------- //-------------------------------------------- if(Raetselnummer==1 && Raetsel2geloest==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel2; } if(Raetselnummer==1 && Raetsel2geloest==true) { goto Zufallsgenerator; } //--------------------------------------------- //--------------------------------------------- if(Raetselnummer==2 && Raetsel3geloest==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel3; } if(Raetselnummer==2 && Raetsel3geloest==true) { goto Zufallsgenerator; } //---------------------------------------------mal schauen und gucken, was der code macht...
Raetselnummer=random(3);also verwendest du den BCB. und hast C-Bücher gelesen.
besser wäre es,int Raetselnummer=random(3);zu schreiben, denn vorher wird
Raetselnummer nicht gebraucht.
die verschiedenen variablen mit zahlen drin erscheinen mir kandidaten
für arrays zu sein. ich versuche es mal.Zufallsgenerator: Raetselnummer=random(3); //------------------------------------------- if(Raetselnummer==0 && Raetselgeloest[1]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[1]; } if(Raetselnummer==0 && Raetselgeloest[1]==true) { goto Zufallsgenerator; } //-------------------------------------------- //-------------------------------------------- if(Raetselnummer==1 && Raetselgeloest[2]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[2]; } if(Raetselnummer==1 && Raetselgeloest[2]==true) { goto Zufallsgenerator; } //--------------------------------------------- //--------------------------------------------- if(Raetselnummer==2 && Raetselgeloest[3]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[3}; } if(Raetselnummer==2 && Raetsel[3]geloest==true) { goto Zufallsgenerator; } //---------------------------------------------hmm. ich glaube, das war wein volltreffer.
Zufallsgenerator: Raetselnummer=random(3); //------------------------------------------- if(Raetselnummer==0 && Raetselgeloest[Raetselnummer+1]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1]; } if(Raetselnummer==0 && Raetselgeloest[Raetselnummer+1]==true) { goto Zufallsgenerator; } //-------------------------------------------- //-------------------------------------------- if(Raetselnummer==1 && Raetselgeloest[Raetselnummer+1]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1]; } if(Raetselnummer==1 && Raetselgeloest[Raetselnummer+1]==true) { goto Zufallsgenerator; } //--------------------------------------------- //--------------------------------------------- if(Raetselnummer==2 && Raetselgeloest[Raetselnummer+1]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1]; } if(Raetselnummer==2 && Raetselgeloest[Raetselnummer+1]==true) { goto Zufallsgenerator; } //---------------------------------------------jetzt steht da immer das gleiche. also für alle raetselnummern der gleiche code.
dann kann ich auch den vergleich auf die raeselnummer wegmachen und immer den selben
code aufrufen.Zufallsgenerator: Raetselnummer=random(3); //------------------------------------------- if(Raetselgeloest[Raetselnummer+1]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1]; } if(Raetselgeloest[Raetselnummer+1]==true) { goto Zufallsgenerator; }aha. noch ein else statt sich widersprechender abfragen
Zufallsgenerator: Raetselnummer=random(3); //------------------------------------------- if(Raetselgeloest[Raetselnummer+1]==false) { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1]; } else { goto Zufallsgenerator; }if-zweige vertauschen
Zufallsgenerator: Raetselnummer=random(3); //------------------------------------------- if(Raetselgeloest[Raetselnummer+1]==true) { goto Zufallsgenerator; } else { Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1]; }nach dem ausgeführten goto kann eh kein else mehr gefunden werden.
Zufallsgenerator: Raetselnummer=random(3); //------------------------------------------- if(Raetselgeloest[Raetselnummer+1]==true) { goto Zufallsgenerator; } Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1];DAS ist aber eine schleife. die do-schleife. ich erkenne sie!
do Raetselnummer=random(3); while(Raetselgeloest[Raetselnummer+1]==true); Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1];nich das ==true wegmachen
do Raetselnummer=random(3); while(Raetselgeloest[Raetselnummer+1]); Antworteingabe->Text=""; Raetsel->Lines=Raetsel[Raetselnummer+1];fazit: dieses goto war nicht unbedingt nötig.
mfg
don volkard
-
Power Off schrieb:
In BASIC kann es hoechstens ein Problem geben, wenn man mit GOTO in ein Unterprogramm springt, das auch mit GOSUB aufgerufen wird
ähm. das lernt man doch schon in den ersten paar basic-vorlesungen, daß man immer
gosub bla returndurch
goto blaersetzen sollte. und ein verketten von unterprogrammen derart, daß am ende des einen ein anderes aufgerufen wird, ist nicht gerade unüblich.
und dokumentieren muss man das auch nicht. ein goto aus einem unterprogramm heraus ist immer als gosub:return zu lesen.
-
Das ist doch ehh alles Schwachsinn. So' braucht man eine unbestimmte Zeit um eine "freie" freie Frage zu finden. Besser ist es, die Anzahl freier Frage zu zählen, dann eine Zufallszahl 0<= x < Anzahl wählen und sich dann einfach die x-te freie Frage zu suchen. Dann brauch man auch nicht nie zum rand zurückspringen...
Fazit: Keine Macht den Dummen
Bye, TGGC (Keine Macht den Dummen)
-
TGGC schrieb:
Das ist doch ehh alles Schwachsinn. So' braucht man eine unbestimmte Zeit um eine "freie" freie Frage zu finden. Besser ist es, die Anzahl freier Frage zu zählen, dann eine Zufallszahl 0<= x < Anzahl wählen und sich dann einfach die x-te freie Frage zu suchen. Dann brauch man auch nicht nie zum rand zurückspringen...
halbwissen.
du brauchst damit noch O(n^2). das eingebaute random_shuffle besogt's dir in O(n).
aber es ging hier nicht darum, ein anderes verfahen vorzuschlagen, sondern nur um das weghauen des goto.beliebt ist auch der folgende, der ohne wissen um die anzahl auskommt:
invP=0; über alle kandidaten ++invP; if(random(invP)==0) ergebnis=kandidatman nimmt ihn vor allem, wenn die daten nur einmal angefasst werden sollen (von platte lesen, anzahl der zeilen vorher unbekannt).
-
Optimizer schrieb:
Wenn man zum Beispiel aus einem größeren Schleifenwust raus möchte ohne seinen Code unnötig unlesbar zu machen, ist eine goto-anweisung recht praktisch dafür.
Nein, weil große Schleifenwuste schon unschön sind. Wenn du das in ne eigene Funktion packst, dann kannst du einfach rausreturnen.
nur um ein goto zu vermeiden eine funktion schreiben, die möglicherweise nur einmal aufgerufen wird, ist ja auch doof.
btw: leute die angst vor 'goto' haben, hassen auch mehr als ein 'return' pro funktion, benutzen weder setjmp/longjmp noch exception-handling
-
volkard schrieb:
du brauchst damit noch O(n^2). das eingebaute random_shuffle besogt's dir in O(n).
Falsch. Geh mal nicht von dir aus. Es gibt auch Leute, die das Raetsel nicht im ersten Versuch lösen.
Bye, TGGC (Wähle deine Helden)
-
net schrieb:
Optimizer schrieb:
Wenn man zum Beispiel aus einem größeren Schleifenwust raus möchte ohne seinen Code unnötig unlesbar zu machen, ist eine goto-anweisung recht praktisch dafür.
Nein, weil große Schleifenwuste schon unschön sind. Wenn du das in ne eigene Funktion packst, dann kannst du einfach rausreturnen.
nur um ein goto zu vermeiden eine funktion schreiben, die möglicherweise nur einmal aufgerufen wird, ist ja auch doof.
btw: leute die angst vor 'goto' haben, hassen auch mehr als ein 'return' pro funktion, benutzen weder setjmp/longjmp noch exception-handlingedir: und function-pointer mögen die auch nicht
sorry, doppelt.
-
net schrieb:
nur um ein goto zu vermeiden eine funktion schreiben, die möglicherweise nur einmal aufgerufen wird, ist ja auch doof.
Nö.
btw: leute die angst vor 'goto' haben,
Angst vielleicht nicht, sagen wir mal ich hasse es.
hassen auch mehr als ein 'return' pro funktion,
Stimmt nicht, sowas mach ich öfters, wanns halt Sinn macht.
benutzen weder setjmp/longjmp
Was soll das sein?
noch exception-handling
Ich benutze es. Wie kommst du überhaupt zu deinen Behauptungen?
[EDIT] Und Funktionspointer mag ich auch.
-
Schließe mich Michael E. an. Woher nimmst du eigentlich deine seltsamen Ideen?
-
Eine Einschränkung muss ich aber machen: Funktionspointer mag ich nicht. Die unterscheiden so böse zwischen Member- und nicht-Member-Funktionen. Bin mehr so der Delegate- oder Observer-Fan.
Hat aber nichts mit goto zu tun (auf welche Wege auch immer)
-
Optimizer schrieb:
Schließe mich Michael E. an. Woher nimmst du eigentlich deine seltsamen Ideen?
weil ich ein seltsamer typ bin.
nee, war schon etwas übertrieben was ich geschrieben hab. ich find's halt blöd wenn manche 'goto' generell verteufeln. zumal man ja mit goto nicht zwischen funktionen hin- und herhüpfen kann. so schlimm ist 'goto' doch gar nicht. wenn man mal ein 'goto' verwendet, entsteht noch lange kein spaghetticode dadurch. ...und so unheimlich oft benutzt man's ja nicht. geht ja meistens ohne aber wenn's mal gebrauchen kann, dann muss man doch nicht mit aller gewalt mach 'ner lösung ohne 'goto' suchen.
-
Michael E. schrieb:
benutzen weder setjmp/longjmp
Was soll das sein?
http://www.cs.utk.edu/~plank/plank/classes/cs360/360/notes/Setjmp/lecture.html
-
mastercpp schrieb:
Michael E. schrieb:
benutzen weder setjmp/longjmp
Was soll das sein?
http://www.cs.utk.edu/~plank/plank/classes/cs360/360/notes/Setjmp/lecture.html
'goto's grosser bruder
-
volkard schrieb:
halbwissen.
du brauchst damit noch O(n^2). das eingebaute random_shuffle besogt's dir in O(n).n^2? ich komme auf 0(2n)->2x komplettes durchiterieren
//edit oder denk ich grad krumm?
-
volkard schrieb:
Power Off schrieb:
In BASIC kann es hoechstens ein Problem geben, wenn man mit GOTO in ein Unterprogramm springt, das auch mit GOSUB aufgerufen wird
ähm. das lernt man doch schon in den ersten paar basic-vorlesungen, daß man immer
gosub bla returndurch
goto blaersetzen sollte. und ein verketten von unterprogrammen derart, daß am ende des einen ein anderes aufgerufen wird, ist nicht gerade unüblich.
und dokumentieren muss man das auch nicht. ein goto aus einem unterprogramm heraus ist immer als gosub:return zu lesen.Aeehhhh, ich meinte was anderes:
20 A=1 30 GOTO 100 40 A=2 50 GOSUB 100 60 ... 70 END 100 ... 110 ... 120 IF A=1 THEN 40 130 ... 140 IF A=2 THEN RETURN 150 ... 160 GOTO 100Solche Konstrukte, wenn sie haeufig vorkommen, koennen ein Programm schwerer lesbar machen.
