wie kann man globale Flags in eine Rechenoperation wandeln?

[juergen]

Hallo zusammen,

ich habe z.B. 30 globale Variabeln vom Typ Integer.
Passend dazu habe ich 30 Edit und 30 Buttons. Jenachdem wie oft man den Button drückt,
wird die passende globale Variable auf einen bestimmten Wert gesetzt ( 1= Addition, 2= Subtraktion usw.)
Nun will ich je nach Stati des jeweiligen Flags die passende Rechenoperation durchführen (Addition, Subtraktion, ect.).
Ich habe leider keinerlei Ideen wie ich das bewerkstelligen könnte.
Es soll nach Möglichlkeit so sein, dass ich in einer procedur dann alle globalen Variablen berechne.

Habt ihr hierzu (verständliche) Ideen/Vorschläge?
Danke schon mal vorab!

[DGL-luke]

Ja, bau dir nen richtigen matheparser :)

ansonsten: pack alle edits und alle buttons in zwei arrays. dann kannst du von links nach rechts in einer schleiße durchgehen und immer die entsprechende rechenoperation ausfphren.

[juergen]

Hallo Lukas,

nachdem ich nun weiß das ich parsen könnte, aber das ganze für mich viel zu aufwendig/kompliziert wäre,
(ich benötige nur Addition und Subtraktion und hoffe, dass somit kein Parser notwendig ist)
bliebe für mich wohl die 2. Option: 2 Arrays...

Wie müsste ich da vorgehen? (habe leider auch noch nie mit Arrays gearbeitet :oops: )
1.)
Vermutlich die Rechenoperation vom Buttonxx in ein Array of Integer (bei Addition = 1, bei Subtraktion = 2...)
Dann die Zahlen aus dem Editxx in ein Array of Integer...(Editxx.Text wird immer typensicher umgewandelt in Integer)

Das bekomme ich (hoffentlich) nach Einarbeitung noch hin.
Wäre der angedeutete Weg überhaupt richtig?

2.)
Wie führe ich die eigentlichen Rechenoperationen über die beiden Arrays aus, so dass Delphi das auch als Rechenoperation erkennt?

[DeddyH]

Wieso definierst Du Dir keinen Record, der den Zahlenwert und den Operator enthält?

Delphi-Quellcode:

type
  TMyRec = record
    Zahl: Integer;   //Zahlenwert
    Subtr: Boolean;  //Addition(false) oder Subtraktion(true)
  end;

function Berechne(const Arr: array of TMyRec; var Ergebnis: Integer): Boolean;
var i: Integer;
begin
  Result := false;
  Ergebnis := 0;
  if Length(Arr) < 1 then Exit;
  //Operator des 1. Elements wird ignoriert
  Ergebnis := Arr[Low(Arr)].Zahl;
  //die folgenden Elemente werden je nach Wert von Subtr addiert oder subtrahiert
  for i := Succ(Low(Arr)) to High(Arr) do
    begin
      if Arr[i].Subtr then
        Dec(Ergebnis,Arr[i].Zahl)
      else
        Inc(Ergebnis,Arr[i].Zahl);
    end;
  Result := True;
end;

procedure TForm1.FormCreate(Sender: TObject);
var TestArr: array[0..2] of TMyRec;
    Erg: Integer;
begin
  FillChar(TestArr,SizeOf(TestArr),0);
  TestArr[0].Zahl := 15;
  TestArr[1].Zahl := 10;
  TestArr[2].Zahl := 24;
  TestArr[2].Subtr := True;
  Berechne(TestArr,Erg);
  ShowMessage(IntToStr(Erg));
end;

Vielleicht hab ich aber auch nur wieder alles falsch verstanden :mrgreen:

[juergen]

Hallo DeddyH,

auf den ersten Blick schaut das genau nachdem aus, was ich benötige! :thumb:
Allerdings bekomme ich das noch nicht implementiert... :oops:
Es kommt eine Fehlermeldung bei -> function Berechne(const Arr: array of TMyRec;...
[DCC Fehler] Calculator.pas(371): E2003 Undefinierter Bezeichner: 'TMyRec'

Delphi-Quellcode:

type 
  TMyRec = record 
    Zahl: Integer;   //Zahlenwert 
    Subtr: Boolean;  //Addition(false) oder Subtraktion(true) 
  end;

habe ich im private Abschnitt eingefügt.


Leider reicht mir ein boolscher Wert für -> Subtr: Boolean; nicht aus (ich benötige 3 Zustände: undefiniert, Plus oder Minus)
Das kann ich dann ja ändern in Integer-Datentyp.

Schon mal Danke für deine Mühen!

[Muetze1]

Delphi-Quellcode:

type
  TOperation = ( opUnknown, opAdd, opSub );
  TMyRec = record
    Zahl: Integer;     //Zahlenwert
    Subtr: TOperation; // undefiniert, Addition oder Subtraktion
  end;

[DeddyH]

Und die Typdeklaration gehört nicht in den private-Abschnitt.

[juergen]

Hallo zusammen,

vielen Dank euch beiden, es scheint zu funktionieren...
:thumb: :thumb: :thumb:

Hier mein Testcode für alle interessierten:

Delphi-Quellcode:

unit Test_Pseudo_Parse_Add_or_Sub;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

type
  TOperation = (opUnknown, opAdd, opSub);
  TMyRec = record
    Zahl: Integer; //Zahlenwert
    Calc_Operation: TOperation; // undefiniert, Addition oder Subtraktion
  end;

function doCalc(const Arr: array of TMyRec; var Ergebnis: Integer): Boolean;
var
  i: Integer;
begin
  Result := false;
  Ergebnis := 0;
  if Length(Arr) < 1 then
    Exit;
  //Operator des 1. Elements wird ignoriert
  Ergebnis := Arr[Low(Arr)].Zahl;
  //die folgenden Elemente werden je nach Wert von Calc_Operation addiert oder subtrahiert
  for i := Succ(Low(Arr)) to High(Arr) do
  begin
    if Arr[i].Calc_Operation = opAdd then
      Inc(Ergebnis, Arr[i].Zahl)
    else if Arr[i].Calc_Operation = opSub then
      Dec(Ergebnis, Arr[i].Zahl)
  end;
  Result := True;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  MyArray: array[0..4] of TMyRec;
  Erg: Integer;
begin
  FillChar(MyArray, SizeOf(MyArray), 0);
  MyArray[0].Zahl := 15;
  MyArray[1].Zahl := 10;
  MyArray[2].Zahl := 24;
  MyArray[3].Zahl := 51;
  MyArray[4].Zahl := 20;
  MyArray[1].Calc_Operation := opAdd;
  MyArray[2].Calc_Operation := opSub;
  MyArray[3].Calc_Operation := opAdd;
  MyArray[4].Calc_Operation := opAdd;
  doCalc(MyArray, Erg);
  ShowMessage(IntToStr(Erg));
  // Ergebnis ist in diesem Beispiel 21 (15+10-24+"nichts"+20)
end;

end.

Ich hoffe ich habe alles richtig umgesetzt.


Allen noch einen schönen Sonntag!

[DeddyH]

Eine Kleinigkeit: ich würde in doCalc statt der If-Abfrage case verwenden (sind ja jetzt mehr als 2 Möglichkeiten).

[edit] Rechtschreibung :oops: [/edit]

[Muetze1]

Zitat:

Zitat von DeddyH

Und die Typdeklaration gehört nicht in den private-Abschnitt.

Wieso nicht? Warum lässt du ihn nicht die neuen Feature nutzen?