Hallo zusammen. Meine Frage ist eher theoretischer Natur. Ich habe von einer Basisklasse zwei Klassen abgeleitet. In den abgeleiteten Klassen wird eine einfache Preisberechnung(Anzahl*Preis) durchgeführt.
Nun möchte ich die Ergebnisse der Preisberechnungen der Klasse1 mit denen der Klasse 2 addieren. Dies geht natürlich in der Form ohne Schwierigkeiten, doch ist das der richtige Weg?
Gibt es eine Möglichkeit die Berechnung in der logic, also nicht in der Form durchzuführen.
Der Versuch in der Basisklasse(Elternklasse) diese Aufrechnung (Gesamtpreis:=Preis1+Preis2) durchzuführen klappt nicht. Eigentlich auch klar.
Ist mein Denkansatz überhaupt richtig und gibt es da einen Weg, der gangbar wäre?

Die Berechnungsfunktion in der Basisklasse als Virtual und eventuell auch noch als Abstract definieren und dann in den Ableitungen überschreiben ... dann kannst du bei allen Ableitungen ohne Cast über den Basistyp das auslesen.

Wenn deine Klassen Objektinstanzen irgendwo registriert sind, dann kannst du der Liste/Registrierungsstelle eine Zusammenrechnen-Funktion verpassen.
Oder eine Funktion oder Klassen-Funktion in der Basisklasse, die als Parameter (eventuell als OpenArray) deine Instanzen bekommt und das Gesamtergebnis liefert.

Wenn ich ehrlich bin, verstehe ich Dein Problem nicht. Du hast zwei (drei,vier...) Berechnungsergebnisse. diese willst Du addieren. Dann pack Deine Ergebnisse in ein Array oder eine Liste und addiere die Array/Listeninhalte.
Fertig.

Gruß
K-H

möglicherweise habe ich mich nicht klar ausgedrückt. Ich habe jeweils ein Ergebnis der Objektinstanz1 und das der Objectinstanz2. Diese sollen dann addiert werden.
1. wo kann diese Addition der Preisergebnisse durchgeführt werden? (in einer neuen Objectinstanz oder in der Form)
2. wie kann ich von außen auf die Berechnungsergebnisse der Objectinstanzen für diese Aufrechnung(Addition) in der logic zugreifen?

hier ein Auszug aus der unit logic:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TKarten = class
   private
    FAnzahl: int32;
    FAufrechnen: int32;
   public
    constructor create;
    destructor Destroy;override;
    procedure setAnzahl(a:Int32);virtual; abstract;
    procedure Aufrechnen(Value:Int32);virtual;abstract;
    function BerechnePreis: Currency;virtual; abstract;
    property Preis: Currency read BerechnePreis;
    property Anzahl: int32 read FAnzahl;
    property Aufre: int32 read FAufrechnen write FAufrechnen;
    end;

type
  TKartenErste = class(TKarten)
   private
    FAnzahl1: int32;
   public
    constructor create;
    destructor Destroy;override;
    procedure SetAnzahl(a:Int32);override;
    procedure aufrechnen(value: int32);override;
    function BerechnePreis: Currency;override;
    property Preis1: Currency read BerechnePreis ;
    property Anzahl1: int32 read FAnzahl;
  end;

type
  TKartenZweite = class(TKarten)
   private
    FAnzahl2: int32;
   public
    constructor create;
    destructor Destroy;override;
    procedure SetAnzahl(a:Int32);override;
    function BerechnePreis: Currency;override;
    property Preis2: Currency read BerechnePreis ;
    property Anzahl2: int32 read FAnzahl;
  end;


implementation

{ TKartenErste }

procedure TKartenErste.aufrechnen(value: Int32);
begin

  //hier weiss ich nicht weiter
end;

function TKartenErste.BerechnePreis: Currency;
begin
  Result := 10 * FAnzahl1;
end;

constructor TKartenErste.create;
begin
  inherited;
end;

destructor TKartenErste.Destroy;
begin
  inherited;
end;

procedure TKartenErste.SetAnzahl(a: Int32);
begin
  FAnzahl1:=a;
end;

{ TKartenZweite }

function TKartenZweite.BerechnePreis: Currency;
begin
  Result := 15 * FAnzahl2;
end;

constructor TKartenZweite.create;
begin
  inherited;
end;

destructor TKartenZweite.Destroy;
begin
  inherited;
end;

procedure TKartenZweite.SetAnzahl(a: Int32);
begin
  FAnzahl2:=a;
end;

{ TKarten }

constructor TKarten.create;
begin
  inherited;
end;

destructor TKarten.Destroy;
begin
  inherited;
end;

end.

und hier den Teil der Form, in der die Zusammenrechnung der Preise vorgenommen wird:

markieren

Delphi-Quellcode:

procedure TForm1.btnPreisaufgerechnetClick(Sender: TObject); //aufrechnen
begin
  lblPreisaufgerechnet.caption:=floattostr(Karten1.Preis1+Karten2.Preis2)
end;

dies funktioniert auch. Doch sollte man das so machen? Das ist meine Frage

.. wenn Du es nur zur Anzeige benötigst - ist das aus meiner Sicht ok.
Wenn Du den Gesamtpreis noch weiter verwenden willst solltest Du noch eine Variable oder Containerklasse für den Gesamtpreis spendieren.

Die Klassen unterscheiden sich nur durch den Faktor (10;15) in der Berechnungsmethode.
Würde hier nicht eine Klasse ausreichen (mit dem Faktor als Parameter)?

Grüße
Klaus

Zitat von Klaus01:

.. wenn Du es nur zur Anzeige benötigst - ist das aus meiner Sicht ok.
Wenn Du den Gesamtpreis noch weiter verwenden willst solltest Du noch eine Variable oder Containerklasse für den Gesamtpreis spendieren.

Die Klassen unterscheiden sich nur durch den Faktor (10;15) in der Berechnungsmethode.
Würde hier nicht eine Klasse ausreichen (mit dem Faktor als Parameter)?

Grüße
Klaus

Danke für die klare Feststellung. Das Ganze ist nur eine theoretische Übung, um festzustellen was geht und was nicht. Also muss die Ergebniszusammenführung in der Form (in welcher auch immer Array... einfache Addition...)erfolgen.
Weiter schreibst Du dass ich möglicherweise eine Containerklasse bilden sollte. Wie und wo könnte dies geschehen? Es ist das leidige Problem des Zugriffs auf gekapselte Werte der class1 und class2 von außen.
Geht Dein Vorschlag in Richtung Objectlist?
Das ist mir also noch nicht ganz klar.

.. ja, das könnte z.B eine generische ObjectList<TKarte> sein.
Der "AlleKartenListe" könntest Du Deine Kartenklassen (eins, zwei) übergeben.

Oder Du baust Dir eine Warenkorbklasse die intern eine generische ObjectList verwendet.
Der Warenkorb kann dann den Gesamtpreis bereitstellen.

Grüße
Klaus

Ich hatte einen ähnlichen Gedanken:

zusammenfalten · markieren

Delphi-Quellcode:

uses ..., System.Generics.Collections;

type
  TBase = class
  strict private
    FAnzahl: integer;
    class var FInstances: TObjectList<TBase>;
    class constructor Create;
    class destructor Destroy;
    class function GetTotal: integer; static;
  public
    constructor Create; virtual;
    destructor Destroy; override;
    property Anzahl: integer read FAnzahl write FAnzahl;
    class property Total: integer read GetTotal;
  end;

  TEins = class(TBase)

  end;

  TZwei = class(TBase)

  end;

...


class constructor TBase.Create;
begin
  FInstances := TObjectList<TBase>.Create(false);
end;

constructor TBase.Create;
begin
  inherited Create;
  FInstances.Add(self);
end;

destructor TBase.Destroy;
var
  idx: integer;
begin
  idx := FInstances.IndexOf(self);
  if idx > -1 then
     FInstances.Delete(idx);
  inherited;
end;

class destructor TBase.Destroy;
begin
  FInstances.Free;
end;

class function TBase.GetTotal: integer;
var
  lBase: TBase;
begin
  Result := 0;
  for lBase in FInstances do
    inc(Result, lBase.Anzahl);
end;

Danke DaddyH, zwar habe ich noch nicht alles verstanden, doch ich experimentiere damit bereits herum und versuche so hinter den tiefen Sinn Deines Quelltextes zu gelangen. Die Generics und auch die Anwendung von class-Methoden sind für mich noch Neuland. Jedenfalls rechnet er die in zwei edit-Felder eingegeben Anzahl-Werte zusammen.Na das ist ja schon mal was!
Ich versuche mich mit solchen theoretischen Tests an die Problematik heranzutasten, um dann damit eine praktische Anwendung zu erstellen. Doch da muss ich nochmals ein gutes Tutorial finden.