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?

[DeddyH]

Du kannst Typen im private-Abschnitt deklarieren? Das war mir neu und funktioniert bei mir auch nicht.

[Muetze1]

Zitat:

Zitat von DeddyH

Du kannst Typen im private-Abschnitt deklarieren? Das war mir neu und funktioniert bei mir auch nicht.

Ab BDS2006 mindestens, warscheinlich schon ab D2005. Mit deinem D7 und meinem D5 geht sowas noch nicht.

[DeddyH]

Ahja, wieder was dazugelernt, Danke.

[juergen]

@ Muetze1,
wenn ich bei mir unter Delphi 2007 die Type-Deklaration von TMyRec in den "private" Abschnitt rein setze, bekomme ich aber die Fehlermeldung, dass TMyRec nicht deklariert wäre... :gruebel:
Wenn ich es "standardmäßig" wie im Beispielcode mache, funktioniert es.
Oder muss ich in meiner Delphiversion erst irgendeinen Compiler-Schalter setzen?

Grüße
Jürgen

[Muetze1]

Zitat:

Zitat von juergen

@ Muetze1,
wenn ich bei mir unter Delphi 2007 die Type-Deklaration von TMyRec in den "private" Abschnitt rein setze, bekomme ich aber die Fehlermeldung, dass TMyRec nicht deklariert wäre... :gruebel:
Wenn ich es "standardmäßig" wie im Beispielcode mache, funktioniert es.
Oder muss ich in meiner Delphiversion erst irgendeinen Compiler-Schalter setzen?

Grüße
Jürgen

Aber der Compiler meckert ja nicht im private Abschnitt rum, sondern in deiner Funktion DoCalc. Diese ist keine Methode und kann somit nicht die Typen der Klasse von Haus aus nutzen. Wenn, dann musst du die Klasse vor den Typ setzen, wenn du dich ausserhalb der Methoden der definierenden Klassen befindest. In diesem Falle wirkt die Deklaration wie ein namespace.

Und wenn du es im private Abschnitt definierst, dann soll diese Deklaration auch private sein. Du willst sie aber außerhalb der Klasse in doCalc nutzen. Somit entweder public oder du nutzt das friend-Prinzip aus, da du ja mit private und nicht strict private arbeitest.

Ich würde dir aber eigentlich eher raten die Funktion zu einer Methode zu wandeln.

Die Lösung unter Nutzung des friend-Verhaltens:

Delphi-Quellcode:

function doCalc(const Arr: array of TForm1.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;

[juergen]

@Muetze1,
Ahhhh, Danke für die ausführlichen Erklärungen!
Die Wandlung der Funktion in eine Methode ist ein guter Vorschlag!

schöne Grüße aus Dortmund nach Rostock!
Jürgen