Warum eigentlich 'break' in 'case' ?? | aus Forum Java

Warum eigentlich 'break' in 'case' ??

Von: , Frage gestellt am Fr, 11. Jun 2004

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

4 Antworten zu dieser Frage

Antwort von nach 31 Minuten 0 hilfreich

Re: Warum eigentlich 'break' in 'case' ??

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.

3. 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 (c)
{
case 'a': c = tooupper(c);
case 'A': execute_befehl_A();
break;
case 'b': c = tooupper(c);
case 'B': execute_befehl_B();
break;
case 'c': execute_befehl_c();
break;
case 'c': execute_befehl_C();
break;
}

MfG Peter(TOO)

Antwort von nach einer Stunde 0 hilfreich

Re^2: Warum eigentlich 'break' in 'case' ??

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.
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 (c)
{
case 'a': c = tooupper(c);
case 'A': execute_befehl_A();
break;
case 'b': c = tooupper(c);
case 'B': execute_befehl_B();
break;
case 'c': execute_befehl_c();
break;
case 'c': execute_befehl_C();
break;
}
```
Ja, das macht Sinn.

Danke.
Markuss
- Antwort von nach einer Stunde 0 hilfreich
  
  Re^3: Warum eigentlich 'break' in 'case' ??
  
  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)
  - Antwort von nach einer Stunde 0 hilfreich
    
    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)

Keine passende Antwort gefunden? Jetzt eigene Frage stellen!