Funktion für nur Zahlen und nur Buchstaben

Power Off

--linuxuser-- schrieb:

kann das mit deinem (...) code zusammenhaengen?

Nein. Ich hatte bloss bei meinem letzten Arbeitgeber zuviel Stress, und hab selber gekuendigt, weil ich nicht mehr arbeiten konnte. Jetzt nach 2-3 Monaten kann ich wieder ein bisschen programmieren.

Ich wuensch Dir das auch mal.

MFK

Power Off schrieb:

Meinst Du nicht, dass Du ein wenig uebertreibst?

Nein. Du solltst doch bemerkt haben, dass eine große Anzahl qualifizierter Boardbenutzer deinen Stil furchtbar bis entsetzlich findet.

Mit "solcher Code" bezieht Du Dich auf folgende gueltige C Konstruktion:

Es geht hier nicht um gültig, es geht um Stil. Mag sein, dass das für dich persönlich nicht relevant ist. Gegenüber denen, die sich an so etwas stören, verhältst du dich aber äußerst rücksichtslos.

Jeder Anfaenger wird frueher oder spaeter sowas lesen muessen, da wird er nicht drum rum kommen.

Anfängern geht es hier aber selten darum, Code zu lesen. Die wollen schreiben, und du lieferst stilistisch schlechte Beispiele. Das muss nicht sein.

Als ich C Anfaenger war, vor 19 Jahren, hab ich ja schon sowas lesen koennen (aber da konnte ich schon BASIC und Assembler).

Wie gesagt, schön, das du so begabt bist, aber viele, die hier Fragen stellen, sind es nun mal nicht. Und darauf nimmst du keine Rücksicht.

Irgendwie hab ich das Gefuehl, ihr wollt mich bloss verscheissern.

Mir zumindest ist es durchaus Ernst mit meinem Appell: Halt dich von den Anfängern fern, du versaust ihnen durch deinen Code den Stil. Ich fände es gut, wenn du Anfängern deine Fähigkeiten im Lesen von schlechtem Code beibringen könntest. Aber du bringst ihnen nur bei, wie man schlechten Code schreibt.

--linuxuser--

Power Off schrieb:

--linuxuser-- schrieb:

kann das mit deinem (...) code zusammenhaengen?

Nein. Ich hatte bloss bei meinem letzten Arbeitgeber zuviel Stress

warum nur??

Power Off

MFK schrieb:

Mir zumindest ist es durchaus Ernst mit meinem Appell: Halt dich von den Anfängern fern, du versaust ihnen durch deinen Code den Stil. Ich fände es gut, wenn du Anfängern deine Fähigkeiten im Lesen von schlechtem Code beibringen könntest. Aber du bringst ihnen nur bei, wie man schlechten Code schreibt.

Anstatt immer nur dasselbe zu wiederholen, nenn doch mal konkret die Stellen, die Dich stoeren, und schreib zu, warum. Damit dieser Thread fuer einen Anfaenger auch noch einen Wert bekommt. Und fuer mich auch.

Ich halte meinen Stil fuer sehr gut, und jeder, fuer den ich gearbeitet habe, auch. Also, begruende mal Deine Aussagen.

Das ein "while" in dem Fall gereicht haette ist klar, aber warum soll die "for"-Konstruktion "schlechter Code" sein?

Warum rechtfertig das eine Serie persoenlicher Beleidigungen?

Power Off

--linuxuser-- schrieb:

warum nur??

Das hatte mehrere Gruende, aber es lag hauptsaechlich daran, dass ich ein Riesenprojekt allein machen musste.

MFK

Power Off schrieb:

Anstatt immer nur dasselbe zu wiederholen, nenn doch mal konkret die Stellen, die Dich stoeren, und schreib zu, warum. Damit dieser Thread fuer einen Anfaenger auch noch einen Wert bekommt. Und fuer mich auch.

Mehrere Leute haben dir an mehreren Stellen gesagt, was sie an deinem Code stört. In diesem und auch in anderen Threads. Du verstehst die Argumente nicht.

Ich halte meinen Stil fuer sehr gut, und jeder, fuer den ich gearbeitet habe, auch. Also, begruende mal Deine Aussagen.

Warum soll ich nochmals wiederholen, was dir viele Benutzer hier schon mehrfach gesagt haben, und was du bisher nicht verstanden hast? Du hältst deinen Code für stilistisch in Ordnung, sehr viele kompetente Leute hier finden, dass er grottenschlecht ist.

Ich glaube, wir können dich nicht davon überzeugen, dass dein Code schlecht ist. Genausowenig wirst du uns überzeugen können, dass er gut ist. Könnstest du nicht einfach akzeptieren, dass dein Code von vielen in dieser Community für schlecht gehalten wird und dich um des Friedens willen gegenüber Anfängern zurückhalten?

Warum rechtfertig das eine Serie persoenlicher Beleidigungen?

Das tut es nicht. Aber wenn jemand sich derart uneinsichtig zeigt wie du, dann verlagert man schon mal die Argumente auf eine unsachliche Ebene. Ich nehme mich da nicht aus. Du hast wieder und wieder gezeigt, dass du sachliche Argumente gar nicht wahrnimmst. Das einzige, was du anscheinend als stilistisches Merkmal gelten lässt, ist, ob der Code läuft oder nicht. Die Bewertungskriterien Anderer akzeptierst du nicht. Damit bist du unbelehrbar.

In Anlehnung an den alten Geisterfahrerwitz:
"Im Forum gibt es einen, der echt seltsame Ansichten über guten Code-Stil hat."
"Einen? Hunderte!"

Power Off schrieb:

Die Methode, den Code solange zu durchzulesen, bis man davon ueberzeugt ist, ist gut. Meist werfe ich den Compiler nicht eher an, bis ein Modul testbereit ist.

ich compiliere da aber viel, viel mehr.

Ich schreibe die Programme meist von vornherein so, dass man sie erweitern kann, und dass durch eine Aenderung nirgendwo "bugs aufreissen" koennen.

hört, hört.
manchmal hat man "by design" bestimmte sonderwünsche ausgeschlossen. natürlich in absprache mit dem kunden. und genau die will er dann doch haben.

das geht dann beim vogelsimulator so:
P: "ok, normale vögel wie adler stellen konzeptionell kein problem dar. und vögel, die auf dem biden bleiben, weil sie nicht fliegen können, da behaupten wir einfach, daß sie nicht fligen wollen. wie isses mit pinguinen?"
K: "das programm wird ganz sicher nur die mitteleuropäische vogelwelt abbilden sollen. laßt pinguine weg".
und 2 jahre später hätte er gerne eine pinguin-"erweiterung". daß dabei ganz zentrale klassen angetatscht werden und das eher einem kompletten redesign gleichkommt, ist ein problem.

oder bei deinen parsern, wir haben eine zeilenorientierte sprache und es ist in der DIN dazu definiert, daß jede zeile mit \n angeschlossen ist. insbesondere ist das letzte zeichen jeder gültigen quellcodedatei ein \n. ich benutze die info von anfang an und schreibe sogar so code wie du. also keine getline() und dann die zeilen verarbeiten, sondern mitten im parser drin immer getch() und tests.
den code, gegen die explizite spezifikation vorher schon so zu schreiben, daß EOF gültiges zeilenende wäre, ist falsch, denn der user hat sich damals gewünscht, daß alle falschen programme auch mit fehlermeldung bestraft werden.
nach 2 jahren kommt der kunde und will auch EOF als das letzte zeilenende erlauben, weil er inzwischen vermehrt einen editor einsetzt, der das letzte \n auch mal wegschmeißt. ich müßte im ganzen programm jede einleseschleife anpassen. oh, graus!

Jede Funktion hat eine klare Aufgabe und eine klare Schnittstelle. Klassen z.B. duerfen keine nicht-hierarchischen Abhaengigkeiten haben.

du meinst kene zyklischen abhängigkeiten? äh, das kommt aber schon mal vor. warum die forderung?

aber ich hab ne andere: jede funktion erfüllt nur einen zweck. dein monster liest whitespaces davor weg und danach, kümmert sich ums vorzeichen und liest die ziffernfolge selbst ein. das wäre für mich mindestens 4 funktionen, für jeden einfachen zweck eine und eine, die alles zusammenpappt.

Code muss geordnet sein wie eine Julia-Menge, z.B.: man kann rein- und rauszoomen, aber die Zusammenhaenge sind stets klar.

julia-mengen sind nicht in jedem zoom-faktor klar, sondern sie sind in jedem zummfaktor jedem anderen zoomfaktor ähnlich.
wäre code wie julia-mengen, wäre er sich stets ähnlich, egal wohin man zoomt. also im detail schlecht und im großen schlecht, zum beispiel.

sagen wir mal, code soll in jedem zoo-faktor klar sein. ist das nicht genaial einfach zu erreichen, daß in jedem zoom-faktor nur winzige funktionen gebaut werden?
hab jetzt keinen lese-code für ints da. nur schreib-code, aber es sollte klar werden, was ich meine.

template<typename T>
void printSignedImpl(T x,Writer& out){
	if(x<0){
		x=-x;
		out<<'-';
	}
	printUnsignedImpl(toUnsigned(x),out);
}

den leser stelle ich mir ähnlich vor. daß ich dann kein MUL mehr brauche, sondern nur ein unäres minus, ist netter nebeneffekt.

Power Off

MFK schrieb:

Mehrere Leute haben dir an mehreren Stellen gesagt, was sie an deinem Code stört. In diesem und auch in anderen Threads. Du verstehst die Argumente nicht.

Du kannst Dich nach Deinen Aussagen nicht einfach auf die auf die Aussagen anderer berufen.

Gib mir konkrete Beispiele und Begruendungen, dann reden wir weiter.

Power Off

volkardus schrieb:

manchmal hat man "by design" bestimmte sonderwünsche ausgeschlossen. natürlich in absprache mit dem kunden. und genau die will er dann doch haben.

Das ist Unsinn. Man kann Programme so schreiben, dass sie von vornherein in jede Richtung erweiterbar sind.

Nur uebelster Spaghetti-Code laesst sich nicht erweitern. Du willst doch nicht behaupten, dass Du das machst?

Deine Beispiele sind etwas aus der Luft gegriffen, uebrigens.

volkardus schrieb:

du meinst kene zyklischen abhängigkeiten? äh, das kommt aber schon mal vor. warum die forderung?

Nein, in gutem Code kommt das nicht vor. Das ist Spaghetti-Code (also verworrener Code).

Wenn es aus Design-Gruenden so erscheint, als ob es nicht anders geht, sollte man sobald moeglich, das Design entsprechend anpassen.

volkardus schrieb:

aber ich hab ne andere: jede funktion erfüllt nur einen zweck. dein monster liest whitespaces davor weg und danach, kümmert sich ums vorzeichen und liest die ziffernfolge selbst ein. das wäre für mich mindestens 4 funktionen, für jeden einfachen zweck eine und eine, die alles zusammenpappt.

Die Funktion erfuellt den Zweck, dass sie eine Zahl aus einer Zeile liest.

Man kann's mit dem Aufbrechen von Funktionalitaet auch uebertreiben.

MFK

Gib mir konkrete Beispiele und Begruendungen, dann reden wir weiter.

Das bringt bei dir nichts. Du bist in deinen Ansichten anscheinend so festgefahren, dass davon bei dir nichts ankommt.

Lass dir eine Merkbefreiung ausstellen.

volkard

Power Off schrieb:

Das ist Unsinn. Man kann Programme so schreiben, dass sie von vornherein in jede Richtung erweiterbar sind.

man kann nicht alle programme so schreiben. schon die sprachauswahl setzt einem sehr enge grenzen.

Nur uebelster Spaghetti-Code laesst sich nicht erweitern. Du willst doch nicht behaupten, dass Du das machst?

"spaghetti-code" ist ein schlagwort aus alter zeit. das wort benutze ich gar nicht, weil man keinen spaghetti-code baut. seit jahrzehnten nicht mehr. bisher ist dein code am dichtesten dran, aber er ist noch "strukturiert", das muß man zugeben.

volkardus schrieb:

du meinst keine zyklischen abhängigkeiten? äh, das kommt aber schon mal vor. warum die forderung?

Nein, in gutem Code kommt das nicht vor. Das ist Spaghetti-Code (also verworrener Code).

es ging um klassen. haste schonmal forward-deklaraionen machen müssen?

Wenn es aus Design-Gruenden so erscheint, als ob es nicht anders geht, sollte man sobald moeglich, das Design entsprechend anpassen.

das paradebeispiel für zyklische abhängigkeiten von funktionen geschieht doch regelmäßig beim rekursiven abstiegscompiler. und du bist doch compilerbauprofi? wie kann dir das nicht sofort einfallen?

Die Funktion erfuellt den Zweck, dass sie eine Zahl aus einer Zeile liest.

sie macht viele verschiedenen dinge NACHEINANDER. gut mit namen benennbare dinge, die sogar unabhängig voneinander funktionieren. also wer die nicht trennt, hat echt die letzten 20 jahre nix dazugelernt. früher war es in der tat üblich, so zu programmieren. da war es ja auch schneller, denn es gar beim inline. aber das hat sich total geändert, daß muß ich dir mal sagen. schau doch am besten mal auch in die enschlägigen newsgroups und die anderen foren (villeicht nicht gerade nicht zfx oder heise) und schau, was die so machen.

Man kann's mit dem Aufbrechen von Funktionalitaet auch uebertreiben.

eigentlich nicht.
aber sagmal, isdigit und RANGE kannste doch einsehen?
warum nicht wenigstens noch eatwhite?

Power Off

volkard schrieb:

man kann nicht alle programme so schreiben. schon die sprachauswahl setzt einem sehr enge grenzen.

Wovon sprichst Du?

Man kann so gut wie in jeder Sprache so gut wie alles programmieren.

Dass man in Java z.B. keine hochperformanten, hardwarenahen Programme schreiben kann ist klar, aber dafuer gibt's ja JNI.

In C oder C++ bin ich noch auf kein unmoegliches Problem gestossen. Ausser es war zur der Zeit tatsaechlich technisch voellig unmoeglich (z.B. sowas wie "Bagger, der in der Luft schwebt und das Raum-Zeit-Kontinuum verzerrt" ).

volkard schrieb:

"spaghetti-code" ist ein schlagwort aus alter zeit. das wort benutze ich gar nicht, weil man keinen spaghetti-code baut. seit jahrzehnten nicht mehr. bisher ist dein code am dichtesten dran, aber er ist noch "strukturiert", das muß man zugeben.

Nach dem bisschen Code, was Du von mir gesehen hast, kannst Du das wohl kaum behaupten. Und rein objektiv gesehen, ist er sauber, strukturiert, und hat keine zyklischen Abhaengigkeiten.

Das Schlagwort "Spaghetti-Code" ist immer aktuell, wenn's ums programmieren geht.

Auch bei objektorientierten Sprachen (gerade dort, wo viel Quark fabriziert wird).

volkard schrieb:

haste schonmal forward-deklaraionen machen müssen?

Klar, z.B. fuer Rekursionen und Listen.

Aber bei Klassen z.B. koennen zyklische Abhaengigkeiten "toedlich" sein.

volkard schrieb:

das paradebeispiel für zyklische abhängigkeiten von funktionen geschieht doch regelmäßig beim rekursiven abstiegscompiler. und du bist doch compilerbauprofi? wie kann dir das nicht sofort einfallen?

Weil bei Rekursionen die Abhaengigkeiten vorgegeben sind. Bei einem Compiler mit rekursivem Abstieg geht das ja gar nicht anders. Bei einem Compiler sind auch alle Abhaengigkeiten z.B. eines Syntax-Analyzers in der EBNF dokumentiert. D.h. der Syntax-Analyzer implementiert die EBNF 1:1.

Ich spreche eigentlich von zyklischen Abhaengigkeiten auf hoeherer Ebene, also z.B. "Komponente X erstellt Komponente Y. Komponente Y modifiziert Komponente X. Komponenten X und Y modifizieren sich gegenseitig. Thread T modifiziert Komponente X. Thread U modifiziert Komponente Y und X. Thread V ruft Code aus Thread T und U auf. Thread V modifiziert manchmal Komponente Y und manchmal X. Thread U beendet Thread V. Thread V beendet manchmal Thread T. Thread T erstellt manchmal Thread W, der auf Thread V wartet."

So was in der Art.

volkard schrieb:

warum nicht wenigstens noch eatwhite?

Weil readnum() nicht nur white-space ueberliest. Vielleicht solltest Du vor ausfuehrlicher Kritik den Code nochmal genau ansehen.

volkard

Power Off schrieb:

volkard schrieb:

man kann nicht alle programme so schreiben. schon die sprachauswahl setzt einem sehr enge grenzen.

Wovon sprichst Du?

symbolisch differenzieren geht mit lisp in ein paar zeilen. in c wirste alt dabei.
haste nen interpreter drunter kannste dir unter umständen einen mathematischen parser schenken.
haste keine lokalen variablen, wirds mit komplexeren programmen nicht gerade leicht.

Man kann so gut wie in jeder Sprache so gut wie alles programmieren.

halt mit mehr oder weniger aufwand.

anläßlich eines programmierwettbewerbs, bei dem alle sprachen erlaubt waren, leistete ich mir den spaß, die aufgabe, nach dem gregorianischen kalnender aus tag, monat, jahr, die der user zuerst einzugeben hatte, den wochenzag zu berechnen, in brainfuck zu erstellen. zum testen nimm http://koti.mbnet.fi/villes/php/bf.php
und natürlich muß ich betonen, daß der code klar und einfach ist. und wer den nicht kapiert oder nicht lesen mag, hat natürlich keine ahnung von brainfuck. ich such dir gerne einen link mit der sprachbeschreibung raus. oder ich zeig die ne kommentierte version.

>++++[->++++<]>[-<++++>]<+++++.>++[->++++<]>[-<++++>]<[-<+>]<++++.+++++.-------.
------.+.+++.>++[->++++<]>[-<++++>]<.[-]<++++.++++.>++[->++++<]>[-<++++>]<.[-]++
[->++++<]>[-<++++>]<[-<->]<-------.>++[->++++<]>[-<++++>]<[-<+>]<+++++++++.+++.-
----.------------.+++++++++++++++++++.>++[->++++<]>[-<++++>]<.[-]<[-]+++[->++++<
]>[-<++++>]<.+++++.-----.++++++++.-------.++++++++.--.-.++++.>++[->++++<]>[-<+++
+>]<.[-]>>,>+++[->++++<]>[-<++++>]<[-<->]<[->++<]>[-<+++++>],>+++[->++++<]>[-<++
++>]<[-<->]<[-<+>],>+++[->++++<]>[-<++++>]<[-<->]<[->++<]>[-<+++++>],>+++[->++++
<]>[-<++++>]<[-<->]<[-<+>],>+++[->++++<]>[-<++++>]<[-<->]<[->++<]>[-<+++++>],>++
+[->++++<]>[-<++++>]<[-<->]<[-<+>],>+++[->++++<]>[-<++++>]<[-<->]<[->++<]>[-<+++
++>],>+++[->++++<]>[-<++++>]<[-<->]<[-<+>]<[->>+>+<<<]>>>[-<<<+>>>]++++[->>+>+<<
<]>>>[-<<<+>>>]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>+>+<<<]
>>>[-<<<+>>>]]<-<<<-]>>>[-<<->>]<[-]<-[-<+>]+<[[-]>-<]>[-<+>]<[-<+>]<<[->>+>+<<<
]>>>[-<<<+>>>]+<[[-]>-<]>[-<+>]<[-<->]<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]++++[->>+>
+<<<]>>>[-<<<+>>>]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>+>+<
<<]>>>[-<<<+>>>]]<-<<<-]>>>[-<<->>]<[-]<-[-<+>]<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<
[-<+>]+<[[-]>-<]>[-<+>]<[-<+>]<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<<<[->>>+>+<<<<]>>
>>[-<<<<+>>>>]<[-<+>]+<[[-]>-<]>[-<+>]<[-<<<<<<<+>>>>>>>]<<<<[->>>>>+>+<<<<<<]>>
>>>>[-<<<<<<+>>>>>>]<[->+>+<<]>>[-<<+>>]<[[-]<->++++[-<<++++++++>>]<<->>]<[->+>+
<<]>>[-<<+>>]<[[-]<-><<--->><<<[->>>>+>+<<<<<]>>>>>[-<<<<<+>>>>>]<[-<<<+>>>]<]<[
->+>+<<]>>[-<<+>>]<[[-]<-><<+++>><<<[->>>>+>+<<<<<]>>>>>[-<<<<<+>>>>>]<[-<<<->>>
]<]<[->+>+<<]>>[-<<+>>]<[[-]<-><<->>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<+>>]<[->+>+<<
]>>[-<<+>>]<[[-]<-><<->>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<+>>]<[->+>+<<]>>[-<<+>>]<
[[-]<->]<[->+>+<<]>>[-<<+>>]<[[-]<-><<->>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<+>>]<[->
+>+<<]>>[-<<+>>]<[[-]<-><<->>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<+>>]<[->+>+<<]>>[-<<
+>>]<[[-]<-><<[-]>>]<[-]<[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<<<<<<<+>>>>>
>>>]<<<<<<[->>>>>>+>+<<<<<<<]>>>>>>>[-<<<<<<<+>>>>>>>]<[<[->>+>+<<<]>>>[-<<<+>>>
]+<[[-]>-<]>[-<+>]<[[-]<<+>><<<<<<<<<+>>>>>>>>>]<<->-]<[-]<[-]+<<<[->>>>+>+<<<<<
]>>>>>[-<<<<<+>>>>>]<[-[-[-<->[-]]]]<[[-]<[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[
[-]<++++++++++[->++<]>[-<+++++>]<<->>]<->]<[->+>+<<]>>[-<<+>>]+++++++[->>+>+<<<]
>>>[-<<<+>>>]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>+>+<<<]>>
>[-<<<+>>>]]<-<<<-]>>>[-<<->>]<[-]<-[-<+>]<[-<<<<<+>>>>>]<[->+>+<<]>>[-<<+>>]+++
+[->>+>+<<<]>>>[-<<<+>>>]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[
->>+>+<<<]>>>[-<<<+>>>]]<-<<<-]>>>[-]<[-<<+>>]<[-]+++++++[->>+>+<<<]>>>[-<<<+>>>
]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>+>+<<<]>>>[-<<<+>>>]]
<-<<<-]>>>[-<<->>]<[-]<-[-<+>]<[-<<<<<+>>>>>]<<[->>+>+<<<]>>>[-<<<+>>>]+++++++[-
>>+>+<<<]>>>[-<<<+>>>]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>
+>+<<<]>>>[-<<<+>>>]]<-<<<-]>>>[-<<->>]<[-]<-[-<+>]<[-<<<<<+++++>>>>>]+++++++[-<
<<<<+>>>>>]<<[->>+>+<<<]>>>[-<<<+>>>]++++[->>+>+<<<]>>>[-<<<+>>>]<-<<<[>>>[->+>+
<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>+>+<<<]>>>[-<<<+>>>]]<-<<<-]>>>[-]<[-
<<+>>]<[-]+++++++[->>+>+<<<]>>>[-<<<+>>>]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>
[-<+>]<[[-]<<+<[->>+>+<<<]>>>[-<<<+>>>]]<-<<<-]>>>[-<<->>]<[-]<-[-<+>]<[-<<<<<+>
>>>>]<<<[->>>>+>+<<<<<]>>>>>[-<<<<<+>>>>>]<[->+>+<<]>>[-<<+>>]<[[-]<->]<[->+>+<<
]>>[-<<+>>]<[[-]<-><<+++>>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<->>]<[->+>+<<]>>[-<<+>>
]<[[-]<-><<+++>>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<++>>]<[->+>+<<]>>[-<<+>>]<[[-]<->
<<+++>>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<++>>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<+++>>]<
[->+>+<<]>>[-<<+>>]<[[-]<-><<+++>>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<++>>]<[->+>+<<]
>>[-<<+>>]<[[-]<-><<+++>>]<[->+>+<<]>>[-<<+>>]<[[-]<-><<++>>]<[-]+++++++[->>+>+<
<<]>>>[-<<<+>>>]<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>+>+<<<
]>>>[-<<<+>>>]]<-<<<-]>>>[-<<->>]<[-]<-[-<+>]<[-<<<<<+>>>>>]<<<<[->>>>+>+<<<<<]>
>>>>[-<<<<<+>>>>>]<[-<<<<<+>>>>>]<[-]<[-]<[-]<[-]+++++++[->>+>+<<<]>>>[-<<<+>>>]
<-<<<[>>>[->+>+<<]>>[-<<+>>]+<[[-]>-<]>[-<+>]<[[-]<<+<[->>+>+<<<]>>>[-<<<+>>>]]<
-<<<-]>>>[-<<->>]<[-]<-[-<+>]<[->+<]<[->+<]>>[-<<+>>]<[[-]<[-]+++++++>]+[->+>+<<
]>>[-<<+>>]<[[-]<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]+<[[-]>-<]>[-<+>]<[[-]>++++[->+++
+<]>[-<++++>]<+++++++++++++++++++.>++[->++++<]>[-<++++>]<[-<+>]<----.-..++++++.-
------------------.++++++.[-]<<<->>]<]<[->+>+<<]>>[-<<+>>]<[[-]<<->><<[->>>+>+<<
<<]>>>>[-<<<<+>>>>]<>+<[[-]>-<]>[-<+>]<[[-]>++++[->++++<]>[-<++++>]<++++++++++++
+.>++[->++++<]>[-<++++>]<[-<+>]<++.-.++++++.-------------------.++++++.[-]<<<->>
]<]<[->+>+<<]>>[-<<+>>]<[[-]<<->><<[->>>+>+<<<<]>>>>[-<<<<+>>>>]+<[[-]>-<]>[-<+>
]<[[-]>++++[->++++<]>[-<++++>]<++++.>++[->++++<]>[-<++++>]<[-<+>]<+++++.----.+++
++++++.+++++.+.-------------------.++++++.[-]<<<->>]<]<[->+>+<<]>>[-<<+>>]<[[-]<
<->><<[->>>+>+<<<<]>>>>[-<<<<+>>>>]+<[[-]>-<]>[-<+>]<[[-]>++++[->++++<]>[-<++++>
]<+++++++++++++.>++[->++++<]>[-<++++>]<[-<+>]<----.+++++++++++..+++.--------.---
---------.+++++.[-]<<<->>]<]<[->+>+<<]>>[-<<+>>]<[[-]<<->><<[->>>+>+<<<<]>>>>[-<
<<<+>>>>]+<[[-]>-<]>[-<+>]<[[-]>++++[->++++<]>[-<++++>]<++++.>++[->++++<]>[-<+++
+>]<[-<+>]<+++++++++++.-..---------.+++++++++++++.+.+.-------------------.++++++
.[-]<<<->>]<]<[->+>+<<]>>[-<<+>>]<[[-]<<->><<[->>>+>+<<<<]>>>>[-<<<<+>>>>]+<[[-]
>-<]>[-<+>]<[[-]>++++[->++++<]>[-<++++>]<++++++.>++[->++++<]>[-<++++>]<[-<+>]<++
++++++++++.-------------.++++.+++++++++++.-------------------.++++++.[-]<<<->>]<
]<[->+>+<<]>>[-<<+>>]<[[-]<<->><<[->>>+>+<<<<]>>>>[-<<<<+>>>>]+<[[-]>-<]>[-<+>]<
[[-]>++++[->++++<]>[-<++++>]<+++++++++++++++++++.>++[->++++<]>[-<++++>]<[-<+>]<-
-----------------.++++++++++++.++++++.+.-------------------.++++++.[-]<<<->>]<]<
[->+>+<<]>>[-<<+>>]<[[-]<<->><<[->>>+>+<<<<]>>>>[-<<<<+>>>>]+<[[-]>-<]>[-<+>]<[[
-]>++++[->++++<]>[-<++++>]<++++++.>++[->++++<]>[-<++++>]<[-<+>]<-.+++.++++.-----
--.+++++++++++++.[-]<<<->>]<]<[-]<[-]++++++++++.[-]<

ok, das programm ist gut. es ist sogar vorbildlich, würde ich sagen. es ist auch noch wartbar. für brainfuck-verhältnisse optimal. es gibt aber andere sprachen, in denen kalenderprogramme besser wartbar sind.

edit: der oben genannte interpreter schafft's nicht, weil er nur 30 sek laufzeit erlaubt.
http://justice.loyola.edu/~mcoffey/pr/5k/i.html ist besser.

Power Off

volkard schrieb:

anläßlich eines programmierwettbewerbs, bei dem alle sprachen erlaubt waren, leistete ich mir den spaß, die aufgabe, nach dem gregorianischen kalnender aus tag, monat, jahr, die der user zuerst einzugeben hatte, den wochenzag zu berechnen, in brainfuck zu erstellen. zum testen nimm http://koti.mbnet.fi/villes/php/bf.php
und natürlich muß ich betonen, daß der code klar und einfach ist. und wer den nicht kapiert, hat natürlich keine ahnung von brainfuck. ich such dir gerne einen link mit der sprachbeschreibung raus. oder ich zeig die ne kommentierte version.

edit: der oben genannte interpreter schafft's nicht, weil er nur 30 sek laufzeit erlaubt.
http://justice.loyola.edu/~mcoffey/pr/5k/i.html ist besser.

Cool!

Aber fuer jemanden, der Brainfuck kann, ist das doch kein Problem zu lesen, oder?

Hier ist z.B. der Output eines Lexical Analyzers, den ich neulich geschrieben habe:

#2:$2:c$8:I5:Alpha$E:{
#4:$5:f$E:I7:beeswax$L:($N:I5:omega$S:,$U:I5:delta$a:)$b:;
#6:$2:}$3:;
#8:$2:M$C:I5:Alpha$H:.$I:I7:beeswax$Q:{
#9:$5:I4:redo$9:4
#A:$5:F$8:I5:omega$E:=$G:I5:delta$M:{
#B:$8:I5:omega$E:A$H:I5:omega$N:/$P:N2:$Q:;
#C:$8:I5:delta$E:A$H:I5:delta$N:+$P:N1:$Q:;
#D:$8:J$D:I4:redo$H:;
#E:$5:}
#F:z
#G:$8:y$D:{
#H:$B:w$G:I1:i$H:;
#I:$B:I1:i$D:A$G:N1:$H:;
#J:$8:}
#K:Y$I:I1:i$K:<$M:N5:
#L:$8:d$B:{
#M:k$G:I8:printnum$P:I1:i$Q:;
#N:$8:}
#O:$2:}
#Q:c$8:I5:Alpha$E:I1:a$F:;
#R:$2:k$7:I1:a$8:.$9:I7:beeswax$G:($I:N5:$J:,$L:N7:$N:)$O:;

Fuer mich ist das kein Problem, zu lesen.

Also Lesbarkeit ist immer relativ.

volkard

Power Off schrieb:

volkard schrieb:

warum nicht wenigstens noch eatwhite?

Weil readnum() nicht nur white-space ueberliest. Vielleicht solltest Du vor ausfuehrlicher Kritik den Code nochmal genau ansehen.

ok, eatLine.
warum das nicht?

volkard

mich beschleicht die befürchtung, daß mein code nur spaß war (weil ich damit garantiert den ersten (und einzigen) platz bei den brainfuckern kriege) und du deinen ernst meinst.

otze

Weil readnum() nicht nur white-space ueberliest. Vielleicht solltest Du vor ausfuehrlicher Kritik den Code nochmal genau ansehen.

ahh, danke dir. hab völlig vergessen das zu kritisieren.

wenn der user ne false eingabe macht, soll er bitteschön ne fehlermeldung bekommen, und eine neue Eingabe tätigen, anstatt dass die funktion einfach alle zeichen bis zum ende der zeile killt(sofern nicht auf dem weg doch noch ne zahl oder ein '-' auftaucht ). Im endeffekt sollte die funktion sofort abbrechen, sofern ein anderes zeichen ausser leerzeichen/zeilenumbrüchen/zahlen/'-' kommt.

Power Off

Was haltet ihr hiervon?

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

int            chr = EOF;
int            dig = EOF;
int            val = 0;
int            sgn = 0;

void readchr( void ) {
   do {
      chr = getchar();
   } while ( chr == '\r' );
}

bool readdigit( void ) {
   if ( chr < '0' || chr > '9' ) return false;
   dig = chr;
   readchr();
   return true;
}

bool readdec( void ) {
   if ( !readdigit() ) return false;
   val = 0;
   do {
      val = val * 10 + ( dig - '0' );
   } while ( readdigit() );
   return true;
}

bool readint( void ) {
   if ( chr == '-' ) {
      readchr();
      sgn = -1;
   }
   else {
      sgn = 1;
   }
   if ( !readdec() ) return false;
   val *= sgn;
   return true;
}

void skipspc( void ) {
   while ( chr == ' ' || chr == '\t' ) readchr();
}

bool readnum( int* result ) {
   readchr();
   skipspc();
   if ( !readint() ) return false;
   skipspc();
   if ( chr != '\n' ) return false;
   *result = val;
   return true;
}

void skiptoeol( void ) {
   while ( chr != '\n' && chr != EOF ) readchr();
}

void promptnum( const char* name, int* result ) {
RETRY:
   printf( "%s eingeben (ganze Zahl): ", name );
   fflush( stdout );
   if ( !readnum( result ) ) {
      skiptoeol();
      if ( chr == EOF ) {
         printf( "Eingabe abgebrochen (EOF)\n" );
         exit( EXIT_FAILURE );
      }
      printf( "Eingabefehler: %s muss ganze Zahl sein\n", name );
      goto RETRY;
   }
   printf( "%s = %d\n", name, *result ); 
}

int main( int argc, char** argv ) {
   int w;
   promptnum( "Watt", &w );
   return EXIT_SUCCESS;
}

volkard

Power Off schrieb:

Was haltet ihr hiervon?

viel besser
jetzt kriegste auch nicht mehr allgemeines gemäkel, sondern konkrete mecker. naja das augenfällige goto und die globalen variablen wohl. wobei ich aber eher meine, daß die gar nicht so unhübsch in diesem fall sind.
jetzt ruft das program eigentlich am lautestes danach, ein paar kleinigkeiten einzubauen, die mit c++ besser gehen.

ich nehme mal ein kleines stück raus und gucke nach, ob die globalen vars vermeidbar sind, ohne daß man sich weh tut.

bool readint( void ) {
   if ( chr == '-' ) {
      readchr();
      sgn = -1;
   }
   else {
      sgn = 1;
   }
   if ( !readdec() ) return false;
   val *= sgn;
   return true;
}

mache ich zu

bool readint(int* val) {
   if ( chr == '-' ) {
      readchr();
      sgn = -1;
   }
   else {
      sgn = 1;
   }
   if ( !readdec(val) ) return false;
   *val *= sgn;
   return true;
}

und das zu

bool readint(int* val) {
   if ( chr == '-' ) {
      readchr();
      if ( !readdec(val) ) return false;
      *val = -*val;
   }
   else {
      if ( !readdec(val) ) return false;
   }
   return true;
}

naja, man hat jetzt massig möglichkeiten, was zu ändern und es macht wieder spaß. auch wenn meine änderung wohl nicht so sinnvoll war. ich denke, es würde sich gut anfühlen, die globalen vars alle zu übergabeparametern zu machen. oder nach c++ wechseln und die werte zurückgeben und bei fehler exceptions werfen.

edit:
aber was mir voll gefällt, ist

bool readnum( int* result ) { 
   readchr(); 
   skipspc(); 
   if ( !readint() ) return false; 
   skipspc(); 
   if ( chr != '\n' ) return false; 
   *result = val; 
   return true; 
}

bis auf den seltsamen readchr() am anfang, kann das ein halbidiot flüssig lesen und ich auch.

Power Off

volkard schrieb:

jetzt ruft das program eigentlich am lautestes danach, ein paar kleinigkeiten einzubauen, die mit c++ besser gehen.

vergiss aber nicht, das wir im C Forum sind!