Ich habe es heute getan. Ich schäme mich.

Leute ich habe es heute gemacht.

Jahre lang habe ich es nicht gebraucht.

Ich habe geschworen es nie wieder zu tun.

Es war so schön

Aber heute habe ich es getan

ich wusste keinen Ausweg

es musste sein

ich bin iritiert.

kann kaum schreiben

als ich es tun wollte wusste ich nicht einmal wie ich es richtig verwende

ich musste in die Hilfe schauen

ich habe heute goto verwendet in meinem Programm

und es ist nicht mal ein Basic Programm

ES IST EINE C++ ANWENDUNG

Ich schäme mich dafür.

Aber wenn das Programm erstellt ist werde ich den Quellcode sofort löschen.

Zeig mal die Stelle. Vielleicht können wirs wegoptimieren.

eiskalt

hol dir gabel und löffel dann wirst du mit deiner spaghetti-programmierung schon fertig werden.

http://www.löffel-gabel.de

Ich würde es auch gerne sehen.
Konnte mir bis jetzt keine Situation vorstellen, in der man´s brauchen würde...

volkard

[quote="SeppSchrot"]Ich würde es auch gerne sehen.
Konnte mir bis jetzt keine Situation vorstellen, in der man´s brauchen würde...

gosu schrieb:

n kann jedes goto restart; durch return michselbst() ersetzen.

[quote="gosu"]Ich schäme mich dafür.

es gibt situationen, da ist goto einfach naheliegend. warum soll man's da nicht nehmen? aus prinzip? das wäre verfehl.
aber ich glaube schon, daß die hilfeanbiter hier eine lösung finden würden, die ohne goto das gleiche macht und nicht schlimmer zu lesen ist.

Kevinus

Also die goto würd ich, wenn es wirklich ach so schlimm ist welcher zu verwenden wegoptimieren:

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;
    }
    //---------------------------------------------

plz help me, ich bin noch am Anfang meiner "Karriere" als Programmierer

Hehe, vielleicht solltest du erstmal Funktionen lernen?? Dann erledigt sich das Problem von selbst.
Hier bietet sich natürlich ein switch oder eine if-Kaskade an.

masterofx32

Warum sollte goto absolut verboten sein? Dann wäre es ja sicherlich nicht Bestandteil des Standards?
Ich finde es absolut legitim, wenn es zum einen nur ein Vorwärtssprung ist und eindeutig erkennbar ist, welchen Sinn es hat. Damit ist man vom Spaghetti-Code ja noch weit entfernt und braucht Goto-Statements nicht nach der Gebranntes-Kind-scheut-das-Feuer-Logik fürchten.
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. Oder wenn man am Ende einer Funktion den Aufräumteil platziert, der auch ausgeführt werden soll, wenn unterwegs ein Fehler aufgetreten ist, dann returnt man bei dem Fehler nicht sondern springt zum Ende der Funktion und räumt dort auf.

Ranus.net

in ne klasse schreiben und diese wieder neuaufrufen lassen ?

-.-

//edit :
hatte ausversehen (wegn java) methode anstatt klasse geschrieben

masterofx32 schrieb:

Warum sollte goto absolut verboten sein? Dann wäre es ja sicherlich nicht Bestandteil des Standards?

Vielleicht ist es Teil des Standards, weil C ein goto hatte?

Ich finde es absolut legitim, wenn es zum einen nur ein Vorwärtssprung ist und eindeutig erkennbar ist, welchen Sinn es hat. Damit ist man vom Spaghetti-Code ja noch weit entfernt und braucht Goto-Statements nicht nach der Gebranntes-Kind-scheut-das-Feuer-Logik fürchten.

Ist sicher nicht falsch. Eigentlich hat volkard alles gesagt. Manchmal ist ein goto vielleicht nicht verkehrt aber es gibt immer ne ebenso schöne Lösung ohne.

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.

Oder wenn man am Ende einer Funktion den Aufräumteil platziert, der auch ausgeführt werden soll, wenn unterwegs ein Fehler aufgetreten ist, dann returnt man bei dem Fehler nicht sondern springt zum Ende der Funktion und räumt dort auf.

LOL. Zum Aufräumen sind Destruktoren und finally-Blöcke in anderen Sprachen da, aber ganz sicher nicht goto.

masterofx32

Ranus.net schrieb:

in ne klasse schreiben und diese wieder neuaufrufen lassen ?

-.-

//edit :
hatte ausversehen (wegn java) methode anstatt klasse geschrieben

wegen Java?

Ranus.net

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

http://de.wikipedia.org/wiki/Objektorientierte_Programmierung

masterofx32

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.

masterofx32

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.

Power Off

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.

volkard

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

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
return

durch

goto bla

ersetzen 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.

TGGC

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)

volkard

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=kandidat

man nimmt ihn vor allem, wenn die daten nur einmal angefasst werden sollen (von platte lesen, anzahl der zeilen vorher unbekannt).

net 0

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