c# Taschenrechner

[wahappen1]

Kann mir bitte jemand helfen ich versuche seit lange Zeit die Punkt vor Strich Rechnung in diesen Code reinzugeben aber es funktioniert nicht.

Hier ist mein Code in Library:

using System;

namespace TaschenrechnerLib
{
public class Taschenrechner
{
private string eingabespeicher = "0";
private char alteroperator = '+';
private decimal erstesZahl = 0;
private bool input = true;

public string AddZahl(char zahl)
{
input = true;
if (eingabespeicher == "0")
eingabespeicher = zahl.ToString();
else
eingabespeicher += zahl;

return eingabespeicher;
}

public string NewOperator(char op)
{
erstesZahl = Convert.ToDecimal(eingabespeicher);
eingabespeicher = "0";
alteroperator = op;
input = false;

return eingabespeicher;
}

public decimal Gleich()
{
decimal zweitesZahl = Convert.ToDecimal(eingabespeicher);
decimal result = 0;

switch (alteroperator)
{
case '+':
result = erstesZahl + zweitesZahl;
break;
case '-':
result = erstesZahl - zweitesZahl;
break;
case '*':
result = erstesZahl * zweitesZahl;
break;
case '/':
if (zweitesZahl != 0)
result = erstesZahl / zweitesZahl;
break;
}

// Reset for the next calculation
eingabespeicher = result.ToString();
erstesZahl = result;

return result;
}

public string GetInput()
{
if (input)
return eingabespeicher;
return erstesZahl.ToString();
}

public string AddKomma()
{
if (!eingabespeicher.Contains(","))
eingabespeicher += ",";

return eingabespeicher;
}

}
}

Und hier ist Console:

using TaschenrechnerLib;
namespace GruppeB;

internal class Program
{
static void Main(string[] args)
{
Taschenrechner taschenrechner = new Taschenrechner();
Console.Clear();
Console.WriteLine(taschenrechner.GetInput());
bool quit = false;
while (!quit)
{
var key = Console.ReadKey(true);
if (key.Key == ConsoleKey.Escape)
{
quit = true;
}
else if (key.KeyChar >= '0' && key.KeyChar <= '9')
{
taschenrechner.AddZahl(key.KeyChar);
}
else if (key.KeyChar == '+' || key.KeyChar == '-' ||
key.KeyChar == '*' || key.KeyChar == '/')
{
taschenrechner.NewOperator(key.KeyChar);
}
else if (key.KeyChar == '.' || key.KeyChar == ',')
{
taschenrechner.AddKomma();
}
Console.Clear();
Console.WriteLine(taschenrechner.GetInput());

}
}
}

 

[Der_Picknicker]

@Raijin … Jaja… Silbertablett.

Hat mich nur interessiert - bin kein Mathematiker. Ich denke ich werde mal versuchen einen solchen Rechner zu bauen. Ist ne gute Fingerübung

 

[mike78sbg]

@mike78sbg

Welchen Vorteil siehst du in deinem Vorgehen? Man muss doch so oder so durch den String laufen… Würde mich echt interessieren, da ich ggf. Mal so einen Rechner bauen will

Hier ist eine gute Erklärung am Beispiel von Postfix.

https://www5.in.tum.de/lehre/vorlesungen/eipro1/ws01/Mittwoch/index.html

Hat weniger mit Mathematiker, als mit Informatiker zu tun. Ist Teil von Algorithmen und Datenstrukturen, zumindest war es das an meiner UNI damals. Denke aber, dass gilt für die meisten Informatik Zweige.

 

[Raijin]

Ich würde das auch eher in der Informatik verorten. Für einen Menschen hat sich die Infix-Notation bewährt und sie ist im allgemeinen einfacher zu lesen. Bei einem Computer ist das etwas anders. Je präziser und effizienter man etwas darstellen kann, umso einfacher ist es vom Computer zu verarbeiten.

Bei der Postfix-Notation kann die CPU die Berechnung letztendlich vollkommen linear durchführen und so effizienter mit den Ressourcen umgehen, u.a. dem Speicher. Die Operanden werden der Reihe nach auf den Stack gelegt (PUSH) und wieder heruntergenommen (POP), um anschließend berechnet zu werden. Das passiert nun für jede Teilrechnung bis am Ende die Aufgabe vollständig gelöst ist, linear, schnell, gut.

Bei der Infix-Notation mit Klammern, PunktVorStrich, etc. müsste die CPU wild durch die Gegend springen und die Aufgabe möglicherweise sogar von hinten an berechnen. Das kostet CPU-Zeit, die prinzipiell nur dafür draufgeht, dass die CPU die Aufgabe überhaupt erst versteht.

Allerdings kommt man auch als Informatiker eher selten wirklich damit in Berührung. Abgesehen von hardware-naher Programmierung hat man es stets mit Hochsprachen zu tun. Zwischen diesem Code und dem Maschinencode steht der Compiler und dieser macht aus a+b*c eben abc*+ in Form von Assembler-Kommandos, fachgerecht zerschnibbelt für den Stack.

Spoiler: So funktioniert's dann in der CPU

Aufgabe: abc*+

a erkannt --> PUSH auf den Stack - Neuer Inhalt: [ a ]
b erkannt --> PUSH auf den Stack - Neuer Inhalt: [ a b ]
c erkannt --> PUSH auf den Stack - Neuer Inhalt: [ a b c ]
Operator *
--> Die beiden letzten Operanden vom Stack holen (POP) - Neuer Inhalt: [ a ]
--> MUL b c rechnen
--> Ergebnis PUSH auf den Stack - Neuer Inhalt: [ a Ergebnis ]
Operator +
--> Die beiden letzten Operanden vom Stack holen (POP) - Neuer Inhalt: [ ]
--> ADD a Ergebnis rechnen
--> Endergebnis PUSH auf den Stack - Neuer Inhalt: [ Endergebnis ]

Das kann man jetzt ewig weiterführen - ohne komplexe Sprünge.

 

[Der_Picknicker]

Ich habe mich tatsächlich mal dran gewagt - ganz so einfach ist ein solcher Rechner nicht. Besonders das parsen muss mit bedacht erfolgen, um flexibel genug bei den Eingaben zu sein.
Damit beispielsweise auch sowas geht:
((2+2)*2)+33*3-(2) …
Was ich an dieser Stelle jedoch festhalten kann, Golang ist ne geile Sprache.

 

[tollertyp]

Was ich an dieser Stelle jedoch festhalten kann, Golang ist ne geile Sprache.

Ich glaub das ist der Punkt, an dem ich mich endgültig aus dem Thread verabschiede, in dem es um einen C#-Taschenrechner ging.

 

[Markchen]

Und da der TE schon lange nicht mehr unter uns ist, mache ich hier zu.