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!

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

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!

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

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 ;)!

?? was meinst du jetzt damit?

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!

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

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

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]

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!

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..