Taschenrechner nur pder keys

Huhu...

sagt mal ist das eine gute Idee, einen Taschenrechner zu programmieren?

Also Idee: nur 1 Edit zur Eingabe, und berechnung aufgrund von Keydown:

Hier mal beispiel für addition:

void __fastcall TForm1::Edit1KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{
if (Key == VK_ADD)
 {
  a = Edit1->Text;
  Edit1->Clear();
 }
if (Key == VK_RETURN)
 {
 b = Edit1->Text;
 b= StringReplace(b,"+","",TReplaceFlags()<<rfReplaceAll);
 a1 = StrToInt(a);
 b1 = StrToInt(b);
 b2 = a1+b1;
 Label1->Caption=b2;

 }
}

für Verbesserungsvorschläge bin ich immer zu gebrauchen!

akari

Hallo

bedient sich dann wohl so ähnlich wie ein konventieller Taschenrechner, schätze ich. Als Übung in Ordnung, aber immerhin sitzen wir ja vor einem großen Bildschirm, und denn kannst du doch auch nutzen. Also ruhig die Tasten mit Buttons anzeigen, die Hotkeys kannste ja drinelassen. Ideen wäre eine Anzeige der Zwischenwerte in einer seperaten ListBox.

bis bald
akari

2 probleme noch:

1: wie kann ich mehrere Operationen einbinden, also nicht nur ADD..sondern auch DIV etc....da das RETURN ja nur auf ADD funktioniert

2: wie kann ich die berechnung "weiterlaufen" lassen, also hier kann ich ja nur einmal "+" drücken, beim 2 mal wird ja nicht auf das ergebniss von der ersten addition aufgerechnet, sondern nur auf den ersten eingebenen wert!

akari

Hallo

du must dir einfach Operationstyp (z.b. durch ein eigenes enum) und Wert in Membervariablen des Forms zwischenspeichern und beim Enter wieder vorholen und auswerten.

bis bald
akair

BigNeal

versuche deine berechnung etwas dynamischer zu gestallten
zB im Stil von

if (Key == VK_ADD)
 {
    switch(Operator)
    {
        case '+':
            a = a + StrToInt(Edit1->Text);
        break;
        case '-':
            a = a - StrToInt(Edit1->Text);
        break;
        case '/':
            a = a / StrToInt(Edit1->Text);
        break;
        case '*':
            a = a * StrToInt(Edit1->Text);
        break;
        default:
            a = StrToInt(Edit1->Text);
    }
    operator = '+';

  Edit1->Clear();
 }

das ganze natürlich mit allen entsprechenden tasten "+-*/"

also code wurde nicht getestet und ist nur so ne idee.. kann auch voller fehler sein..

mfg BigNeal

Ja, indem man beim drueken der plustaste (VK_ADD), alle berechnungen machen kann ;)!

@ akari, kannst mir mal ein beispiel geben....bitte

BigNeal

Kopffrau_oder_mann schrieb:

Ja, indem man beim drueken der plustaste (VK_ADD), alle berechnungen machen kann ;)!

?? was meinst du jetzt damit?

ser1al

Ich glaube mal, das Sie/Er meint, das bei deinem Code ja erst nach dem drueken der PLUSTASTE der switsch ausgeführt wird!

BigNeal

ich habe jetzt mal kurz einen taschenrechner getestet mit meinem codebeispiel..
es funktioniert tipptopp soweit.
ich berechne einfach bei jedem operator der eingetippt wird die rechnung vorher..
also bei 1+5-6=
beim - wird 1+5 berechnet und zwischengespeichert und beim = den zwischenspeicher-6

@ Big, bei deinem Beispiel bekomme ich einen fehler, "Überladbarer Operator erwartet"

ser1al

ich glaube so dürfte es funktionieren:

public:		// Anwender-Deklarationen
        char Operator;
        int a;

void __fastcall TForm1::Edit1KeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{

if (Key == RETURN)
 {
    switch(Operator)
    {
        case '+':
            a = a + StrToInt(Edit1->Text);
        break;
        case '-':
            a = a - StrToInt(Edit1->Text);
        break;
        case '/':
            a = a / StrToInt(Edit1->Text);
        break;
        case '*':
            a = a * StrToInt(Edit1->Text);
        break;
        default:
            a = StrToInt(Edit1->Text);
    }
    Operator = '+';

  Edit1->Clear();
  Label1->Caption=a;
 };

}

berichtigt mich wenn ich falsch liege!

akari

Hallo

wenn es funktioniert, ist es richtig, also einfach mal ausprobieren!
Ich würde aber einen besseres Namen für eine so wichtige Variable wie a nehmen, z.B. Value.

bis bald
akari

ser1al

Na funktioniert net...da bei VK_RETURN das "+" mit im String bleibt und er dann meckert, das +324324 kein Integerwert ist!

akari

Hallo

ich hab mal ein wenig rumgespielt. Um das so hinzukriegen, wir ihr es wollt, mußt ihr :
- statt Edit1->OnKeyDown den Event Form1->OnShortCut nehmen
- Form1->KeyPreview auf true stellen
- in Form1ShortCut dies kopieren

int NewValue;

  switch(Msg.CharCode)
  {
    case VK_ADD :
    case VK_SUBTRACT :
    case VK_DIVIDE :
    case VK_MULTIPLY :
    case VK_RETURN :
      NewValue = StrToIntDef(Edit1->Text, 0);
      Handled = true;
      if (NewValue == 0) return;
      switch(Operator)
      {
        case VK_ADD:
          a = a + NewValue;
          break;
        case VK_SUBTRACT:
          a = a - NewValue;
          break;
        case VK_DIVIDE:
          a = a / NewValue;
          break;
        case VK_MULTIPLY :
          a = a * NewValue;
          break;
        default:
          a = NewValue;
        };
      if (Msg.CharCode != VK_RETURN)
      {
        Operator = Msg.CharCode;
        Edit1->Clear();
        }
      Label1->Caption=a;
      break;
    };

dann habt ihr einen Rechner, wie ihr es wollt. Sind noch ein paar Schwächen, aber ansonsten...

bis bald
akari

BigNeal

also hier mal mein beispiel von gestern abend

void __fastcall TForm1::Berechnen()
{

    switch(cRechnungsOperator)
    {
        case '+':
            dTemp = dTemp + StrToInt(Edit1->Text);
        break;
        case '-':
            dTemp = dTemp - StrToInt(Edit1->Text);
        break;
        case '/':
            dTemp = dTemp / StrToInt(Edit1->Text);
        break;
        case '*':
            dTemp = dTemp * StrToInt(Edit1->Text);
        break;
        default:
            dTemp = StrToInt(Edit1->Text);
    }
}                  

void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)
{
   if (Key == '+')
   {
      Berechnen();
      cRechnungsOperator = '+';
      Edit1->Clear();
      Key = NULL;
   }
   if (Key == '-')
   {
      Berechnen();
      cRechnungsOperator = '-';
      Edit1->Clear();
      Key = NULL;
   }
   if (Key == '/')
   {
      Berechnen();
      cRechnungsOperator = '/';
      Edit1->Clear();
      Key = NULL;
   }
   if (Key == '*')
   {
      Berechnen();
      cRechnungsOperator = '*';
      Edit1->Clear();
      Key = NULL;
   }
   if (Key == 13)
   {
      Berechnen();
      Label1->Caption = AnsiString(dTemp);
      Edit1->Clear();
      Key = NULL;
      cRechnungsOperator = 0;
   }
}

falls jemand eine beschreibung braucht werde ich das noch nachholen

[Edit] wobei natürlich

char cRechnungsOperator;
double dTemp;

in der .h steht [/Edit]

ja also ich hätte schon gern eine beschreibung...=)

BigNeal

damit es auch einen möglichst hohen lehrnefekt hat, sagst du am besten was du verstehst und was nicht..

ok, du legst funktion an, wo dTemp der Wert in Edit1 ist, und dann ein schalter, wo je nach operator der alte mit dem neuen berechnet wird!

Im programm wertest du Keypress aus, und übergibst den keys die jeweiligen operatoren! ODER?

Mit Key 13 verstehe ich nicht!

Wenn ich oben schon was falsch verstanden habe, sag es bitte!

BigNeal

ich mach mal ein beispiel.. wieder dass "1+5-6="

wenn eine die "1" eingegeben wird passiert nichts spezieles
kommt der erste RechnungsOperator das "+" da wird in der if schleife die funktion "berechnen()" aufgerufen.
da noch nichts im RechnungsOperator steht und erste eine zahl eingegeben wurde(zum berechnen brauchs ja für die 4 grundoperationen immer 2 zahlen) wird default aufgerufen. d.h. der wert im edit wird zwischengespeichert in dTemp
durch Edit1->Clear() wird der inhalt des edits gelöscht und der Wert in "Key"(das zeichen das ins Edit feld übergeben wird) wird auch gelöscht, so dass nichts mehr im edit steht.
bei der zweiten zahl die "5" passiert wieder nichts
beim "-" wird wieder das entsprechende if aufgerufen
berechnet wird die erste zahl mit dem operator mit der zweitern zahl momentan im edit

dTemp + StrToInt(Edit1->Text);

und das ganze wird wieder in dTemp geschrieben.
dann halt man "die erste zahl" gespeichert.. da immer das zwischenresultat berechnet wird und der letzte operator auch.. so kann man immer weiter rechnen ohne an ein ende zu kommen.
beim enterschlag

if (Key == 13)
   {
      Berechnen();
      Label1->Caption = AnsiString(dTemp);
      Edit1->Clear();
      Key = NULL;
      cRechnungsOperator = 0;
   }

wird nochmals das resultat berechnet, das in einem label ausgegeben, wieder alles löschen inkl RechnungsOperator

hoffe das war verständlich..