Discussion:
Spielereien mit switch (...)
(zu alt für eine Antwort)
Rainer Weikusat
2015-11-16 21:01:56 UTC
Permalink
Raw Message
In nicht allzu ferner Vergangenheit ist mir beim Betrachten von

switch (expression) statement

und gleichzeitigem Nachdenken uber Duffs Geraet der Gedanke gekommen,
dass switch eigentlich keine grosse Aehnlichkeit mit einer
Mehrwegeverzweigung a la "Pascal case" hat sondern einfach nur
ermoeglicht, die Ausfuehrung von statement an der Position einer
bestimmte Sprungmarke im Inneren davon beginnen zu lassen. ZB mit
folgendem, etwas widersinnig anmutendem Konstrukt:

---------
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char **argv)
{
int i;

if (argc != 2) return 0;

i = atoi(argv[1]);
switch (i - 1)
if (i == 1) {
default:
puts("Im Labyrinth des Irrsinns");
} else if (i == 3) {
case 0:
puts("Oder in der Naehe davon");
} else {
case 2:
puts("Faellt nichts durch");
}

return 0;
}
----------

oder als Alternativmethode um eine Schleife in der Mitte zu beginnen:

----------
#include <stdio.h>

int main(int argc, char **argv)
{
if (!*++argv) return 0;

switch (0) do {
fputs(", ", stdout);

default:
fputs(*argv, stdout);
} while (*++argv);

fputc('\n', stdout);

return 0;
}
----------
Juergen Ilse
2015-11-16 22:16:24 UTC
Permalink
Raw Message
Hallo,
Post by Rainer Weikusat
In nicht allzu ferner Vergangenheit ist mir beim Betrachten von
switch (expression) statement
und gleichzeitigem Nachdenken uber Duffs Geraet der Gedanke gekommen,
dass switch eigentlich keine grosse Aehnlichkeit mit einer
Mehrwegeverzweigung a la "Pascal case" hat
Stimmt. "switch" ist in C eigentlich eher etwas wie ein "berechnetes goto".
Das ist aber nichts neues, sondern bereits seit ewigkeiten allgemein be-
kannt ...

Tschuess,
Juergen Ilse (***@usenet-verwaltung.de)
--
Ein Domainname ist nur ein Name, nicht mehr und nicht weniger.
Wer mehr hineininterpretiert, hat das Domain-Name-System nicht
verstanden.
Rainer Weikusat
2015-11-16 22:31:08 UTC
Permalink
Raw Message
Post by Juergen Ilse
Post by Rainer Weikusat
In nicht allzu ferner Vergangenheit ist mir beim Betrachten von
switch (expression) statement
und gleichzeitigem Nachdenken uber Duffs Geraet der Gedanke gekommen,
dass switch eigentlich keine grosse Aehnlichkeit mit einer
Mehrwegeverzweigung a la "Pascal case" hat
Stimmt. "switch" ist in C eigentlich eher etwas wie ein "berechnetes goto".
Das ist es nun allerdings wirklich nicht denn ein 'berechnetetes goto'
koennte zu einer beliebigen Sprungmarke irgendwo im Programm verzweigen
waehrend switch lediglich die Ausfuehrung der von ihm kontrollierten
Anweisung beeinflusst.
Helmut Schellong
2015-11-17 09:19:29 UTC
Permalink
Raw Message
Post by Rainer Weikusat
Post by Juergen Ilse
Post by Rainer Weikusat
In nicht allzu ferner Vergangenheit ist mir beim Betrachten von
switch (expression) statement
und gleichzeitigem Nachdenken uber Duffs Geraet der Gedanke gekommen,
dass switch eigentlich keine grosse Aehnlichkeit mit einer
Mehrwegeverzweigung a la "Pascal case" hat
Stimmt. "switch" ist in C eigentlich eher etwas wie ein "berechnetes goto".
Das ist es nun allerdings wirklich nicht denn ein 'berechnetetes goto'
koennte zu einer beliebigen Sprungmarke irgendwo im Programm verzweigen
waehrend switch lediglich die Ausfuehrung der von ihm kontrollierten
Anweisung beeinflusst.
Er wird wohl nicht den Sprungraum meinen, sondern das Prinzip
eines 'switch (integer) case integer-const' (, in Verbindung damit, daß
auf Assembler-Ebene oft eine Sprungtabelle verwendet wird, die
direkt den Steuer-Integer verwendet).
--
Mit freundlichen Grüßen
Helmut Schellong ***@schellong.biz
www.schellong.de www.schellong.com www.schellong.biz
http://www.schellong.de/c.htm
Rainer Weikusat
2015-11-17 16:14:02 UTC
Permalink
Raw Message
Post by Helmut Schellong
Post by Rainer Weikusat
Post by Juergen Ilse
Post by Rainer Weikusat
In nicht allzu ferner Vergangenheit ist mir beim Betrachten von
switch (expression) statement
und gleichzeitigem Nachdenken uber Duffs Geraet der Gedanke gekommen,
dass switch eigentlich keine grosse Aehnlichkeit mit einer
Mehrwegeverzweigung a la "Pascal case" hat
Stimmt. "switch" ist in C eigentlich eher etwas wie ein "berechnetes goto".
Das ist es nun allerdings wirklich nicht denn ein 'berechnetetes goto'
koennte zu einer beliebigen Sprungmarke irgendwo im Programm verzweigen
waehrend switch lediglich die Ausfuehrung der von ihm kontrollierten
Anweisung beeinflusst.
Er wird wohl nicht den Sprungraum meinen, sondern das Prinzip
eines 'switch (integer) case integer-const' (, in Verbindung damit, daß
auf Assembler-Ebene oft eine Sprungtabelle verwendet wird, die
direkt den Steuer-Integer verwendet).
"Das Prinzip" jedes Sprachkonstruktes, das den Kontrollfluss aendert,
ist "irgendwas + goto irgendwo", lediglich mit gewissen Einschraenkungen
fuer "irgendwas" und "irgendwo", denen der auf tatsaechlichen gotos
aufbauende Code nicht unterworfen waere. Mit einem berechneten goto kann
man zB sowas machen (Perl)

-----
goto PRINT;

ODD:
print(',');
goto PRINT;

EVEN:
print('\'');

PRINT:
print(shift);

goto ('DONE', 'EVEN', 'ODD')[@ARGV && ($ARGV[0] & 1) + 1];

DONE:
print("\n");
------

Beispielausgabe:

[***@doppelsaurus]/tmp#perl a.pl `seq 1 20`
1'2,3'4,5'6,7'8,9'10,11'12,13'14,15'16,17'18,19'20

waehrend man mit einer switch-Anweisung weder rueckwaerts noch beliebig
weit vorwaerts springen kann.
Helmut Schellong
2015-11-17 18:35:28 UTC
Permalink
Raw Message
[...]
Post by Rainer Weikusat
Post by Helmut Schellong
Er wird wohl nicht den Sprungraum meinen, sondern das Prinzip
eines 'switch (integer) case integer-const' (, in Verbindung damit, daß
auf Assembler-Ebene oft eine Sprungtabelle verwendet wird, die
direkt den Steuer-Integer verwendet).
"Das Prinzip" jedes Sprachkonstruktes, das den Kontrollfluss aendert,
ist "irgendwas + goto irgendwo", lediglich mit gewissen Einschraenkungen
fuer "irgendwas" und "irgendwo", denen der auf tatsaechlichen gotos
aufbauende Code nicht unterworfen waere. Mit einem berechneten goto kann
man zB sowas machen (Perl)
waehrend man mit einer switch-Anweisung weder rueckwaerts noch beliebig
weit vorwaerts springen kann.
Die oben stehende Zeile mit 'goto' zeigt tatsächlich ein berechnetes goto.
Es ist ein goto mit einem array-Argument.
Diese perl-Syntax finde ich allerdings einigermaßen schrecklich.

Es fehlt eine vollständige Definition für 'berechnetes goto'.
In C von einer Funktion in eine andere springen - das ist wegen der
gänzlich anderen Natur der Sprache ausgeschlossen.
In einem Shell-Skript hingegen wird in jeder Zeile nach Kommandos
gesucht, und Funktionskörper werden übersprungen.

C verwendet Sprungzielkonstanten bei goto als auch bei switch-case.
goto in C kann ebenfalls vor und zurück springen, nur nicht berechnet.
--
Mit freundlichen Grüßen
Helmut Schellong ***@schellong.biz
www.schellong.de www.schellong.com www.schellong.biz
http://www.schellong.de/c.htm
Rainer Weikusat
2015-11-19 16:24:55 UTC
Permalink
Raw Message
Post by Helmut Schellong
[...]
Post by Rainer Weikusat
Post by Helmut Schellong
Er wird wohl nicht den Sprungraum meinen, sondern das Prinzip
eines 'switch (integer) case integer-const' (, in Verbindung damit, daß
auf Assembler-Ebene oft eine Sprungtabelle verwendet wird, die
direkt den Steuer-Integer verwendet).
"Das Prinzip" jedes Sprachkonstruktes, das den Kontrollfluss aendert,
ist "irgendwas + goto irgendwo", lediglich mit gewissen Einschraenkungen
fuer "irgendwas" und "irgendwo", denen der auf tatsaechlichen gotos
aufbauende Code nicht unterworfen waere. Mit einem berechneten goto kann
man zB sowas machen (Perl)
waehrend man mit einer switch-Anweisung weder rueckwaerts noch beliebig
weit vorwaerts springen kann.
[...]
Post by Helmut Schellong
Es fehlt eine vollständige Definition für 'berechnetes goto'.
In C von einer Funktion in eine andere springen - das ist wegen der
gänzlich anderen Natur der Sprache ausgeschlossen.
[...]
Post by Helmut Schellong
C verwendet Sprungzielkonstanten bei goto als auch bei switch-case.
goto in C kann ebenfalls vor und zurück springen, nur nicht berechnet.
Es ist "mehr oder minder ausgeschlossen", weil ein solches Feature beim
Entwurf der Sprache nicht vorgesehen war. Darauf wollte ich aber nicht
hinaus: "So 'ne Art goto" ist die "instinktive 08/15 Reaktion" von
Leuten, die sich mit irgendetwas, dass den Kontrollfluss veraendert,
konfrontiert sehen, das Ihnen unbekannt und/oder komisch erscheint. In
freier Wildbahhn habe ich das bis jetzt ebenfalls angetroffen fuer

- zwei Funktionen, die sich gegenseitig aufrufen

- lokale Funktionen (innerhalb eines lexikalischen Scopes
definiert und benutzt)

Konkret heisst das nichts als "[es aendert den Kontrollfluss UND] ich
finde es komisch und abstossend" (wenn man die uebliche, negative
Konotation von goto beruecksichtigt). Der Wikipedia-Artikel ueber
'switch statement',

https://en.wikipedia.org/wiki/Switch_statement

demonstriert das beispielhaft ("an unstructured switch, as in
C"). Soweit sich das dem Text entnehmen laesst bedeutet 'strukturiert'
"Das war Wirths Etage!" und 'unstrukturiert' "das nicht".

Jetzt ist switch (...) aber keine "defekte Mehrwegverzweigung" sondern
etwas vollkommen anderes, naemlich ein Kontrollkonstrukt, mit dessen
Hilfe man die Ausfuehrung an einer von mehreren benannten Stellen eine
beliebigen, anderen Anweisung fortsetzen kann. Ein "Durchfall" findet
dabei nur insofern statt, als der Kontrollfluss der beeinflussten
Anweisung andernfalls linear ist: Was passiert nachdem ein switch (...)
ausgefuehrt wurde, wird von diesem nicht weiter beeinflusst. Etwas
unsinniges Beispiel:

-------
#include <stdio.h>
#include <stdlib.h>

#define kaese(x) if (0) case x:
#define oderkaese(x) else if (0) case x:
#define oder else if (0) default:

int main(int argc, char **argv)
{
switch (atoi(argv[1]))
kaese(0)
printf("Null\n");
oderkaese(1)
printf("Eins\n");
oderkaese(2)
printf("Zwei\n");
oder
printf("Weder noch\n");

return 0;
}
-------

Kombiniert mit if ist das natuerlich nicht besonders sinnvoll/
nuetzlich, aber fuer Schleifen gibt es Nutzanwendungen weil man naemlich
damit in Abhaengigkeit von einem Parameter den Code, der waehrend der
ersten Iteration ausgefuehrt wird, beeinflussen kann, was praktisch
bedeutet, das man darauf verzichten kann, goto einzusetzen, und den
Code, den erste und alle folgenden Iterationen gemeinsam haben, trotzdem
nicht duplizieren muss.

Wenn die "unstrukturierten, defekten Konstrukte" auch noch nuetzliche,
strukturierte Anwendungen haben, wird es natuerlich am allerschlimmsten
...
Helmut Schellong
2015-11-19 19:06:00 UTC
Permalink
Raw Message
[...]
Post by Rainer Weikusat
-------
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
switch (atoi(argv[1]))
kaese(0)
printf("Null\n");
oderkaese(1)
printf("Eins\n");
oderkaese(2)
printf("Zwei\n");
oder
printf("Weder noch\n");
return 0;
}
-------
Kombiniert mit if ist das natuerlich nicht besonders sinnvoll/
nuetzlich, aber fuer Schleifen gibt es Nutzanwendungen weil man naemlich
damit in Abhaengigkeit von einem Parameter den Code, der waehrend der
ersten Iteration ausgefuehrt wird, beeinflussen kann, was praktisch
bedeutet, das man darauf verzichten kann, goto einzusetzen, und den
Code, den erste und alle folgenden Iterationen gemeinsam haben, trotzdem
nicht duplizieren muss.
Eine 'alternative' Verwendung eines 'switch' - besonders unter Verwendung
von case-Makros - ist IMO unnötig hinterhältig.
Es gibt nämlich simple Alternativen dazu:

Es kann ein switch _innerhalb_ einer Schleife angeordnet werden, um sogar
bei mehreren Iterationen einen jeweils unterschiedlichen Code auszuführen.
Auch if (!f) { f=1; /*...*/ } und ähnlich wird von mir
variantenreich benutzt.

Es fällt auf, daß meines Wissens nach /nur hinsichtlich C/ die durch
diverse Schlüsselwörter und Konstrukte offerierten Möglichkeiten
kritisiert werden!
goto break continue return case ...

Beispielsweise Ada bietet hier wesentlich 'aggressivere' Möglichkeiten!
Jedoch Ada wird nicht kritisiert, sondern als (DIE) sichere Sprache
proklamiert.
Anders formuliert:
C wird wegen milderer Möglichkeiten der gleichen Art als
unsicher hingestellt, während Ada trotz aggressiverer Varianten
dieser Möglichkeiten als überzeugend sichere Sprache gilt.
Irgendwas ist hier 'kaputt'.
Aber dies wird wohl an der immensen Verbreitung von C liegen.
Die Verbreitung von C hat recht.

MISRA nimmt Zug um Zug (1998 -> 2004 -> 2012) Strenge bei der
Verunstaltung von C zurück.
Diese Idioten haben 15 Jahre gebraucht, um zu erkennen, was für einen
Käse sie zu Anfang festgelegt hatten.
--
Mit freundlichen Grüßen
Helmut Schellong ***@schellong.biz
www.schellong.de www.schellong.com www.schellong.biz
http://www.schellong.de/c.htm
Rainer Weikusat
2015-11-19 22:37:02 UTC
Permalink
Raw Message
Helmut Schellong <***@schellong.biz> writes:

[...]
Post by Helmut Schellong
Beispielsweise Ada bietet hier wesentlich 'aggressivere' Möglichkeiten!
Jedoch Ada wird nicht kritisiert, sondern als (DIE) sichere Sprache
proklamiert.
Hmm ... naja ... wenn die Programmiersprache so abartig kompliziert ist,
dass "99%" der Programmierer da nicht mehr durchsteigen, hat man die
Code-Qualitaet indirekt dadurch erhoeht, die meisten Volltrottel
aussortiert zu haben (andererseits zieht man dann "Kompliziert! Voll
geil, ey!" Zauberlehrlinge an, was diesen Effekt etwas konterkarieren
duerfte ...), aber das kann meiner Ansicht nach nicht wirklich eine
sinnvolle Loesung sein. (SCNr).
Georg Bauhaus
2015-11-22 20:13:41 UTC
Permalink
Raw Message
Post by Helmut Schellong
MISRA nimmt Zug um Zug (1998 -> 2004 -> 2012) Strenge bei der
Verunstaltung von C zurück.
Diese Idioten haben 15 Jahre gebraucht, um zu erkennen, was für einen
Käse sie zu Anfang festgelegt hatten.
Sie müssen sich ja auch der Realität stellen, dass hinreichend gute
C-Handwerker häufig bornierte Borderliner sind, die vor Kränkung zusammen
brechen, wenn die Regelgeber ihnen etwas von ihrem Lieblinsausdrucksmittel
aus der Hand zu nehmen drohen. Beschnitt am professionellen, künstlerischen
Basteln der Meister! Analog: es ist schon beeindruckend, wenn ein Schreiner
einen Sekretär mit Beitel, Ahle und Laubsäge baut; nur taugt das Verfahren eben
solange nicht für eine Möbelfabrik, bis sich heraus stellt, dass dort nur
seinesgleichen anzutreffen sind und keine effiziente Konkurrenz weit und
breit den Zustand obsolet machen könnte.

Das nur in der Reihe gesagt, weil jetzt schon genug wertender Kuhschiss
ohne Nachweis als Sachberichterstattung vorgespiegelt wurde.
Helmut Schellong
2015-11-22 20:42:09 UTC
Permalink
Raw Message
Post by Georg Bauhaus
Post by Helmut Schellong
MISRA nimmt Zug um Zug (1998 -> 2004 -> 2012) Strenge bei der
Verunstaltung von C zurück.
Diese Idioten haben 15 Jahre gebraucht, um zu erkennen, was für einen
Käse sie zu Anfang festgelegt hatten.
Sie müssen sich ja auch der Realität stellen, dass hinreichend gute
C-Handwerker häufig bornierte Borderliner sind, die vor Kränkung zusammen
brechen, wenn die Regelgeber ihnen etwas von ihrem Lieblinsausdrucksmittel
aus der Hand zu nehmen drohen. Beschnitt am professionellen, künstlerischen
Basteln der Meister! Analog: es ist schon beeindruckend, wenn ein Schreiner
einen Sekretär mit Beitel, Ahle und Laubsäge baut; nur taugt das Verfahren eben
solange nicht für eine Möbelfabrik, bis sich heraus stellt, dass dort nur
seinesgleichen anzutreffen sind und keine effiziente Konkurrenz weit und
breit den Zustand obsolet machen könnte.
Das nur in der Reihe gesagt, weil jetzt schon genug wertender Kuhschiss
ohne Nachweis als Sachberichterstattung vorgespiegelt wurde.
Der letzte Satz ist besonders interessant für mich:
Wer sind die Vorspiegelnden?


Dummytext
.......................................................................
.......................................................................
.......................................................................
.......................................................................
.......................................................................
.......................................................................
.......................................................................
.......................................................................
.......................................................................
--
Mit freundlichen Grüßen
Helmut Schellong ***@schellong.biz
www.schellong.de www.schellong.com www.schellong.biz
http://www.schellong.de/c.htm
Rainer Weikusat
2015-11-19 19:47:22 UTC
Permalink
Raw Message
Rainer Weikusat <***@talktalk.net> writes:

[...]
Post by Rainer Weikusat
-------
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
switch (atoi(argv[1]))
kaese(0)
printf("Null\n");
oderkaese(1)
printf("Eins\n");
oderkaese(2)
printf("Zwei\n");
oder
printf("Weder noch\n");
return 0;
}
-------
In diesem Zusammenhang sei auch noch erwaehnt, dass das natuerlich auch
mit Bloecken funktioniert, weil ein 'label' allgemein vor einem
'statement' angebracht werden kann und das 'statement' einer
if-Anweisung natuerlich auch ein 'compound statement' sein kann, dh,

---------
#include <stdio.h>
#include <stdlib.h>

#define kaese(x) if (0) case x:
#define oderkaese(x) else if (0) case x:
#define oder else if (0) default:

int main(int argc, char **argv)
{
switch (atoi(argv[1]))
kaese(0) {
puts("Null");
}

oderkaese(1) {
puts("Eins");
}

oderkaese(2) {
puts("Zwei");
}

oder {
puts("Nicht erkannt.");
puts("Wie doof!");
}

return 0;
}
---------

Ich moechte hier niemandem verwaehren sich gaehnend, "Alles alter
Kaese!", abzuwenden, aber zumindestens mir war das bislang in dieser
Form nicht bekannt, nicht zuletzt deswegen, weil ich es noch nirgendwo
gelesen habe.
Stefan Reuther
2015-11-17 12:02:01 UTC
Permalink
Raw Message
Post by Rainer Weikusat
Post by Juergen Ilse
Post by Rainer Weikusat
In nicht allzu ferner Vergangenheit ist mir beim Betrachten von
switch (expression) statement
und gleichzeitigem Nachdenken uber Duffs Geraet der Gedanke gekommen,
dass switch eigentlich keine grosse Aehnlichkeit mit einer
Mehrwegeverzweigung a la "Pascal case" hat
Stimmt. "switch" ist in C eigentlich eher etwas wie ein "berechnetes goto".
Das ist es nun allerdings wirklich nicht denn ein 'berechnetetes goto'
koennte zu einer beliebigen Sprungmarke irgendwo im Programm verzweigen
waehrend switch lediglich die Ausfuehrung der von ihm kontrollierten
Anweisung beeinflusst.
Der Witz ist ja, dass die "von ihm kontrollierte Anweisung" beliebig
groß, d.h. im Wesentlichen "das komplette Programm" umfassen kann.

Gestandene BASIC-Programmierer können z.B. ihre C-Programme so beginnen:

#include <stdio.h>
#include <stdlib.h>

#define goto(x) do{linenr=x; goto again;}while(0)

int main()
{
int i;
int value = rand() % 10000;
int linenr = 10;
again: switch (linenr++) {

Danach folgt dann das BASIC-Programm, hier ein Klassiker:

case 10: printf("Zahl eingeben: ");
case 20: fflush(stdout);
case 30: scanf("%i", &i);
case 40: if (i == value) goto(100);
case 50: if (i < value) goto(80);
case 60: printf("Zu gross!\n");
case 70: goto(10);
case 80: printf("Zu klein!\n");
case 90: goto(10);
case 100: printf("Gewonnen!\n");
case 110: exit(0);

Noch ein Abschluss dran:

}
return 0;
}

Fertig! Kaum umdenken nötig!

:-)


Stefan
David Seppi
2015-11-17 16:19:25 UTC
Permalink
Raw Message
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
--
David Seppi
1220 Wien
Claus Reibenstein
2015-11-17 19:03:51 UTC
Permalink
Raw Message
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
Schau mal in Deinem C-Buch unter Post Increment nach.

Gruß
Claus
David Seppi
2015-11-18 01:30:03 UTC
Permalink
Raw Message
Post by Claus Reibenstein
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
Schau mal in Deinem C-Buch unter Post Increment nach.
Ich weiß was ein Post Increment ist. Ich sehe nur keinen Einfluß
auf den Programmablauf, d.h. ein Optimierer könnte den Operator
einfach ignorieren.
--
David Seppi
1220 Wien
Claus Reibenstein
2015-11-18 09:03:30 UTC
Permalink
Raw Message
Post by David Seppi
Post by Claus Reibenstein
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
Schau mal in Deinem C-Buch unter Post Increment nach.
Ich weiß was ein Post Increment ist.
Dann ist ja gut ;-)
Post by David Seppi
Ich sehe nur keinen Einfluß auf den Programmablauf, d.h. ein
Optimierer könnte den Operator einfach ignorieren.
So genau hatte ich mir das Programm nicht angesehen. Aber Du dürftest
Recht haben: Ich sehe auch nichts Produktives.

Gruß
Claus
Juergen Ilse
2015-11-18 10:19:32 UTC
Permalink
Raw Message
Hallo,
Post by David Seppi
Post by Claus Reibenstein
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
Schau mal in Deinem C-Buch unter Post Increment nach.
Ich weiß was ein Post Increment ist. Ich sehe nur keinen Einfluß
auf den Programmablauf, d.h. ein Optimierer könnte den Operator
einfach ignorieren.
Nein, da linenr anschliessend noch verwendet wird (spaetestens beim "goto",
das zu Code expandiert wird, der die Variable verwendet).

Tschuess,
Juergen Ilse (***@usenet-verwaltung.de)
--
Ein Domainname ist nur ein Name, nicht mehr und nicht weniger.
Wer mehr hineininterpretiert, hat das Domain-Name-System nicht
verstanden.
David Seppi
2015-11-18 15:21:22 UTC
Permalink
Raw Message
[...]
Post by Juergen Ilse
Post by David Seppi
Ich weiß was ein Post Increment ist. Ich sehe nur keinen Einfluß
auf den Programmablauf, d.h. ein Optimierer könnte den Operator
einfach ignorieren.
Nein, da linenr anschliessend noch verwendet wird (spaetestens beim "goto",
das zu Code expandiert wird, der die Variable verwendet).
Ja, aber der Wert wird dort überschrieben, bevor erneut auf ihn
zugegriffen wird. Das Inkrement wirkt sich also nirgends aus.
Wieso soll das also nicht rausoptimiert werden dürfen?
--
David Seppi
1220 Wien
Stefan Reuther
2015-11-17 20:57:31 UTC
Permalink
Raw Message
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
verhindern, dass das Programm hängt, falls in 'linenr' eine nicht
existierende Zeilennummer steht, z.B. weil es nicht mit 'case 10:',
sondern 'case 20:' beginnt.


Stefan
David Seppi
2015-11-18 01:28:23 UTC
Permalink
Raw Message
Post by Stefan Reuther
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
verhindern, dass das Programm hängt, falls in 'linenr' eine nicht
existierende Zeilennummer steht, z.B. weil es nicht mit 'case 10:',
sondern 'case 20:' beginnt.
Dein Programm terminiert in diesem Fall ohne etwas zu tun. ;-)
--
David Seppi
1220 Wien
Juergen Ilse
2015-11-18 10:23:04 UTC
Permalink
Raw Message
Hallo,
Post by David Seppi
Post by Stefan Reuther
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
verhindern, dass das Programm hängt, falls in 'linenr' eine nicht
existierende Zeilennummer steht, z.B. weil es nicht mit 'case 10:',
sondern 'case 20:' beginnt.
Dein Programm terminiert in diesem Fall ohne etwas zu tun. ;-)
Stimmt, statt again muesste da default stehen ...
Meine Aussage bzgl. der Verwendung von linenr nehme ich zurueck, da ja
beim "goto" nur *schreibend* auf linenr zugegriffen wird und damit der
vorherige Wert belanglos ist, das hatte ich uebersehen ...

Tschuess,
Juergen Ilse (***@usenet-verwaltung.de)
--
Ein Domainname ist nur ein Name, nicht mehr und nicht weniger.
Wer mehr hineininterpretiert, hat das Domain-Name-System nicht
verstanden.
David Seppi
2015-11-18 15:22:57 UTC
Permalink
Raw Message
Post by Juergen Ilse
Meine Aussage bzgl. der Verwendung von linenr nehme ich zurueck
Ah, dann nehme ich meine Antwort darauf auch zurück. :-)
--
David Seppi
1220 Wien
Achim Peters
2015-11-18 22:38:44 UTC
Permalink
Raw Message
Post by David Seppi
Post by Juergen Ilse
Meine Aussage bzgl. der Verwendung von linenr nehme ich zurueck
Ah, dann nehme ich meine Antwort darauf auch zurück. :-)
Herr Müller-Lüdenscheidt!

Herr Doktor Klöbner!

(F'up2 poster)

Bye
Achim
Stefan Reuther
2015-11-18 10:21:58 UTC
Permalink
Raw Message
Post by David Seppi
Post by Stefan Reuther
Post by David Seppi
Post by Stefan Reuther
again: switch (linenr++) {
^^ tut das irgendwas produktives?
verhindern, dass das Programm hängt, falls in 'linenr' eine nicht
existierende Zeilennummer steht, z.B. weil es nicht mit 'case 10:',
sondern 'case 20:' beginnt.
Dein Programm terminiert in diesem Fall ohne etwas zu tun. ;-)
Stümpt.

(Statt dem 'goto again' stand da zuerst ein 'while (1)', dann ist aber
das 'goto'-Makro etwas kniffliger.)

Lektion gelernt: goto is evil :)


Stefan
Thomas Koenig
2015-11-20 07:03:41 UTC
Permalink
Raw Message
Post by David Seppi
Dein Programm terminiert in diesem Fall ohne etwas zu tun. ;-)
Endlich ist das Halteproblem gelöst.
Loading...