Zum Inhalt springen
Frage 11. Juni 2004 · 4 Antworten

Warum eigentlich 'break' in 'case' ?

Hi.

Ja, gut, damit er nicht ins nächste ‚case‘ hineinläuft. Weiss ich.
Was ich meine:
Warum ist Java nicht so gestaltet, dass nach Ausführen eines ‚case‘ automatisch der ‚switch‘ verlassen wird?
Mir ist kein Fall bekannt, wo man das ‚break‘ bewusst weglässt, damit er ins nächste ‚case‘ hineinläuft.
Einzige sinnvolle Möglichkeit: Für einen Dominoeffekt mit beliebiger Einbstiegsstelle. Aber das wäre ein seltener Fall.
Warum dreht man nicht den Spieß um und sagt: Am Ende eines ‚case‘ wird der ‚switch‘ automatisch verlassen, es sei denn, ein spezielles Schlüsselwort steht dort (z.B. ‚next‘).
Dadurch würden doch weniger Fehler und weniger Quellcodezeilen entstehen, oder?

Markuss

Diese Frage stammt aus dem Jahr 2004. Weißt du es heute besser?

Aktuelle Antwort ergänzen

4 Antworten

Hallo Markuss,

Warum ist Java nicht so gestaltet, dass nach Ausführen eines
‚case‘ automatisch der ‚switch‘ verlassen wird?
Mir ist kein Fall bekannt, wo man das ‚break‘ bewusst
weglässt, damit er ins nächste ‚case‘ hineinläuft.
Einzige sinnvolle Möglichkeit: Für einen Dominoeffekt mit
beliebiger Einbstiegsstelle. Aber das wäre ein seltener Fall.
Warum dreht man nicht den Spieß um und sagt: Am Ende eines
‚case‘ wird der ‚switch‘ automatisch verlassen, es sei denn,
ein spezielles Schlüsselwort steht dort (z.B. ‚next‘).
Dadurch würden doch weniger Fehler und weniger Quellcodezeilen
entstehen, oder?

Antwort A:
Weil Java hier von C abgekupfert hat, dort ist das auch so.

Antwort B:

  1. Der Compiler/Interpreter wird etwas einfacher „case x“ ist einfach eine Sprungmarke, damit ist das Handling für den Compiler/Interpreter abgeschlossen. In deinem Fall müsste man zuerst abchecken ob da vorher schon ein case-Zweig war oder nicht um dann einen Sprung an das Ende einzufügen.

  2. Wie willst du folgendes Handhaben:

    switch ( x)
    {
    case 1:
    case 2: mach_da_was;
    break;
    case 3: mach_was_anderes;
    }

Bei deiner Variante müsste man die Syntax erweitern um die Werte „1“ und „2“ in einem einzigen „case“ zusammenzufassen.

  1. Es giebt viele sinnvole Anwendungen für das „fallthru“, hinzu kommt noch, dass es nicht übersichtlicher wird, wenn ein „Pseudobefehl“ bewirkt, dass der Programmfluss eigentlich „nicht beeinflusst“ wird.
    z.B. bei einem Commandointerpreter ist das ganz nützlich:

    switch ©
    {
    case ‚a‘: c = tooupper©;
    case ‚A‘: execute_befehl_A();
    break;
    case ‚b‘: c = tooupper©;
    case ‚B‘: execute_befehl_B();
    break;
    case ‚c‘: execute_befehl_c();
    break;
    case ‚c‘: execute_befehl_C();
    break;
    }

MfG Peter(TOO)

0 Hilfreich
Antwort auf Peter_TOOzum Beitrag ↑

Hallo Markuss, Warum ist Java nicht so gestaltet, dass nach Ausführen eines ‚case‘ automatisch der ‚switch‘ verlassen wird? Mir ist kein Fall bekannt, wo man das ‚break‘ bewusst weglässt, damit er ins nächste ‚case‘ hine …

  1. Wie willst du folgendes Handhaben:

switch ( x)
{
case 1:
case 2: mach_da_was;
break;
case 3: mach_was_anderes;
}

Bei deiner Variante müsste man die Syntax erweitern um die
Werte „1“ und „2“ in einem einzigen „case“ zusammenzufassen.

Warum eigentlich nicht??
Es hat mich sowieso gestört, dass man nicht schreiben kann:

switch ( x)
{
 case 1,2: mach\_da\_was;
 break;
 case 3: mach\_was\_anderes;
}

oder

switch ( x)
{
 case {1,2}: mach\_da\_was;
 break;
 case 3: mach\_was\_anderes;
}

Letzteres wäre in etwa analog zu:

if (bedingung)
 tu\_watt1();





if (bedingung){
 tu\_watt1();
 tu\_watt2()
}

hinzu kommt noch, dass es nicht übersichtlicher wird, wenn ein
„Pseudobefehl“ bewirkt, dass der Programmfluss eigentlich
„nicht beeinflusst“ wird.
z.B. bei einem Commandointerpreter ist das ganz nützlich:

switch ©
{
case ‚a‘: c = tooupper©;
case ‚A‘: execute_befehl_A();
break;
case ‚b‘: c = tooupper©;
case ‚B‘: execute_befehl_B();
break;
case ‚c‘: execute_befehl_c();
break;
case ‚c‘: execute_befehl_C();
break;
}

Ja, das macht Sinn.

Danke.
Markuss

0 Hilfreich
Antwort auf Markusszum Beitrag ↑

Wie willst du folgendes Handhaben: switch ( x) { case 1: case 2: mach_da_was; break; case 3: mach_was_anderes; } Bei deiner Variante müsste man die Syntax erweitern um die Werte „1“ und „2“ in einem einzigen „case“ zusam …

Hallo Markuss,

Java ist nun mal Java und C ist C.

Es stht dir aber jederzeit frei deine eigene Programmiersprache zu entwickeln und dir einen eigenen Compiler zu bauen.
N. Wirth hat da das Buch „Compilerbau“ geschrieben und mit Tools wie YACC ist soetwas rech schnell gebastelt.

Dann kannst du dann jedem Erklären wieso du entschieden hast, etwas so zu implementieren und nicht anders. Viele Features entspringen halt einfach dem persöhnlichen Geschmack des Entwicklers. Ich kann problemlos mit Java und C leben, so wie sie sind.

MfG Peter(TOO)

0 Hilfreich
Antwort auf Peter_TOOzum Beitrag ↑

Hallo Markuss, Java ist nun mal Java und C ist C. Es stht dir aber jederzeit frei deine eigene Programmiersprache zu entwickeln und dir einen eigenen Compiler zu bauen. N. Wirth hat da das Buch „Compilerbau“ geschrieben …

Nachtrag:
…Manche Dinge kommen aber auch durch Zufall oder „Dummheit“ zustande:
Bei LISP (LIStProzessing; eine alte KI-Sprache) hatten die Studenten zuerst einfach vergessen, dass nicht nur die Daten, sondern auch das Programm irgendwie im Computerspeicher abgelegt werden muss. Als Notlösung hatte man dann halt das Programm in die gleichen Strukturen abgelegt wie die Daten. Dies wurde dann zu einer der Stärken von LISP, da sich das Programm genauso leicht verändern lasst wie die Daten, was sehr Vorteilhaft bei „selbst lernenden Programmen“ ist.

MfG Peter(TOO)

0 Hilfreich

Deine Antwort

Zum Antworten bitte anmelden oder kostenlos registrieren.