Umsetzung eines erweiterten Taschenrechners

[Jumpy]

Zitat von a.def:

Warum machen eigentlich alle Anfänger einen Taschenrechner, obwohl das eher, sagen wir mal, ein "schwieriges" Ding ist (bzgl. Parser etc) ?

Man muss das ja nicht unbedingt als Parser realisieren. Wenn man sich mal einen richtigen ganz einfachen 2,90€ Taschenrechner anschaut, wird da ja auch keine Formel erstellt o.ä.

Da braucht man drei Variablen als Speicher für Zahlen und zwei als Speicher für Operatoren und das war's dann auch schon.

[himitsu]

Wieso 3 und 2?

Einmal die letzte Zahl und dann noch den letzten Operator (hier kann man sich einfach das AusgabeEdit als "Variable" nehmen)

* Tippt man Zahlen ein, geht das ins Edit
* drückt man einen Operator
** wird zuerst die letzte Zahl und der letzte Operator mit der aktuellen Zahl Eingabe-Edit verrechnet (wenn etwas im Zwischenspeicher steht)
*** Ergebnis langet dann im AusgabeEdit
*** war nichts im Zwischenspeicher, dann landet nur die Eingabe in der Ausgabe
** nun wird noch der gedrückte Operator gespeichert
** und es geht mit der nächsten Zahl weiter ... also ab nach oben

Mit "richtiger" Operatorenreihen (z.B. 1+2*3 = 1+(2*3) statt nacheinander (1+2)*3 ) und Klammern wird es schwerer und man braucht einen Stack.

Eine Eingabe in Postfix ( https://de.wikipedia.org/wiki/Umgeke...ische_Notation ) würde in der einfachsten Variante nur eine Variable für die letzte Zahl benötigen, den den Operator braucht man nicht speichern, da er ja zuletzt eingegeben wird.

[BrightAngel]

Zitat von a.def:

Warum machen eigentlich alle Anfänger einen Taschenrechner, obwohl das eher, sagen wir mal, ein "schwieriges" Ding ist (bzgl. Parser etc) ?

Wobei so ein "Minimalinterpreter" für +*/- auch eine gute Übung sein kann, wenn man sich für sowas interessiert. Ist immernoch "einfach" im Vergleich zu einer vollen "Pipeline" für Quellcodeverarbeitung. Es gibt immerhin nur überschaubare Präzendenzregeln zu beachten.

Also wenn dich sowas wirklich interessiert, kannst du das fürs Erste auch direkt interpretieren. Man kann da auch entsprechend Datenstrukturen aufbauen, aber das dürfte vielleicht wirklich ein wenig weit führen...

Beim direkten interpretieren gehst du einfach die Zeichenkette von Vorne nach Hinten durch und nach jedem Zeichen musst du entscheiden, ob du was verrechnest, oder weiter liest. Kommt eine Ziffer (0-9) dann weißt du sicher, dass du in einer Zahl bist. Das merkst du dir in einer lokalen Variable und erweiterst das, bis ein Rechenzeichen oder das Ende auftaucht.
Je nachdem, ob eine Punkt- oder eine Strichoperation auftaucht musst du die jeweilig Entscheidung treffen und in der Funktion verzweigen. Das ist vom Aufwand überschaubar.


Versuche es dir einfach Stück für Stück vorzustellen. Im Zweifel ist Stift und Papier dabei auch ganz handlich

Wenn du das hinbekommst, kannst du auch noch Klammern einführen, in dem du bei öffnenden Klammern durch Rekursion (erneutes Aufrufen einer der beteiligten Funktionen) "in die Verschachtelung hinabsteigst" und bei schließenden Klammern das "Zwischenergebnis" (= den Wert der Klammerung) die Rekursion wieder "nach oben" zurückgibst.

Mache dir einfach mal ein, zwei, zehn Beispiele. Fange vielleicht erstmal mit dem reduzierten Problem (nur Strich- oder nur Punktrechnung) an und arbeite dich von da an weiter.

Das hier von mir Vorgestellte ist nur ein möglicher Ansatz.

Viel Spaß dir beim Ausprobieren!
Brighty

[Luckie]

Ich habe mal den Titel angepasst. In Zukunft bitte eigenständig einen Aussagekräftigen Titel wählen.

[a.def]

Zitat:

Umsetzung eines erweiteretn Taschenrechners

[Luckie]

Ach hör uff. Ist schon spät!

[a.def]

Darf man fragen wie weit der Themenersteller bezüglich seines Problemes mittlerweile ist?
Würde mich brennend interessieren.