Aufrechnen von Integer-Werten in ein neues Ergebnis

[EdAdvokat]

ich möchte die Ergebnisse einer einfachen Additionen (FErgebnis:int32) in einem neuen Ergenis(FAufrechnung:int32) speichern
und ausgeben. Also Ergebnis von 11 + 9 soll zunächst mit 20 in FErgebnis angezeigt werden und dann will ich nochmals 6+6 addieren und das
Ergebnis von 12 soll zu den 20 dazuadditert werden und im Ergebnisoutput mit 32 erscheinen. Dies soll sooft addiert werden, wie
ich eine neue Summe bilde.
Irgenwie komme ich da nicht weiter. Sicher mache ich da nur einen einfachen Fehler.
anbei meine Versuche:
Logic:

Delphi-Quellcode:

type
  TAddition = class
  private
    FZahl1 : integer;
    FZahl2 : integer;
    FErgebnis: Integer;
    FAufrechnung: int32;
  public
    procedure Addition;
    procedure aufrechnen(fErgebnis:int32);
    property Zahl1: Integer read FZahl1 write FZahl1;
    property Zahl2: Integer read FZahl2 write FZahl2;
    property Ergebnis: Integer read FErgebnis;
    property Ergebnisaufrechnen : int32 read FAufrechnung ;
  end;

implementation

{ TAddition }

procedure TAddition.Addition;
begin
  FErgebnis:=FZahl1+FZahl2;
end;

procedure TAddition.aufrechnen(Fergebnis:int32);
begin
  FAufrechnung:= Faufrechnung + FErgebnis ;
end;

end.

nun die Form:

Delphi-Quellcode:

procedure TForm1.btn1Click(Sender: TObject);
var Add : TAddition;
begin
  Add:=TAddition.Create;
  try
    Add.Zahl1 := StrToIntDef(edtZahl1.text,0);
    Add.Zahl2 := StrToIntDef(EdtZahl2.Text, 0);
    Add.Addition;
    LblErgebnis.Caption := IntToStr(Add.Ergebnis);
    Add.aufrechnen(add.Ergebnis);
    lblAufrechnung.caption:=inttostr(add.Ergebnisaufrechnen);
  finally
    FreeAndNil(Add);
  end;

end;

[Zacherl]

Das Klassendesign und das aufwändige Zwischenspeichern in

Delphi-Quellcode:

FErgebnis

ist so per Aufgabenstellung vorgegeben?

Ansonsten sollte der Code ja schon funktionieren und für weitere Werte müsstest du den kompletten Block ja lediglich kopieren bzw. in einer Schleife aufrufen, oder wo genau liegt dein Problem?

[EdAdvokat]

nichts ist vorgegeben. Das habe ich mir selbst so geschrieben. Es ist nur für mich allein eine Übung. Wohl doch zu kompliziert? Doch meine verschiedenen Versuche führten einfach nicht zum Ziel.
In beiden Ergebnissen erscheinet nur die gleiche Grundsumme. Ein Aufaddieren findet nicht statt.

[LTE5]

Zitat:

nichts ist vorgegeben. Das habe ich mir selbst so geschrieben. Es ist nur für mich allein eine Übung.

Dann ändere direkt mal int32 zu Integer :P Denn int32 ist nichts anderes als ein normaler Integer.

[Delphi.Narium]

Delphi-Quellcode:

procedure TForm1.btn1Click(Sender: TObject);
var Add : TAddition;
begin
  // Du erstellst eine Instanz von TAddition,
  Add:=TAddition.Create;
  try
    // übernimmst die erste Zahl aus der Eingabe,
    Add.Zahl1 := StrToIntDef(edtZahl1.text,0);
    // übernimmst die zweite Zahl aus der Eingabe,
    Add.Zahl2 := StrToIntDef(EdtZahl2.Text, 0);
    // addierst die beiden Zahlen,
    Add.Addition;
    // gibst das Ergebnis aus,
    LblErgebnis.Caption := IntToStr(Add.Ergebnis);
    // rechnest zu einer nicht initialisierten Summe dazu
    Add.aufrechnen(add.Ergebnis);
    // gibst diese aus
    lblAufrechnung.caption:=inttostr(add.Ergebnisaufrechnen);
  finally
    // und wirfts alles wieder weg.
    FreeAndNil(Add);
  end;
end;

Beim nächsten btn1Click geht es von vorne los.

Die dann erstellte Instanz von TAddition kennt natürlich das Ergebnis der vorherigen Aufrechnung in FAufrechnung nicht, da die vorherige Instanz ja verworfen wurde.

Du müsstest dann zumindest das Ergebnis der Aufrechnung wieder aus der Anzeige in die beim Klick erstellte Instanz übernehmen.

Oder Dir überlegen, ob es wirklich sinnvoll ist, TAddition vor jeder Addition neu zu erstellen und nach der Addition zu verwerfen, wenn Du das Ergebnis nachher noch weiterverarbeiten willst.

[Zacherl]

Zitat:

Zitat von EdAdvokat (Beitrag 1392921)

Es ist nur für mich allein eine Übung

Wenn du willst, kann ich dir gerne beschreiben oder zeigen, wie ich so etwas umsetzen würde. Dazu müsste ich allerdings wissen, was genau deine Zielstellung ist?

Ein paar Punkte schonmal, die eigentlich allgemeingültig sind:

• So etwas Simples wie Addition in einer Funktion bzw. sogar einer Methode zu kapseln, macht keinen Sinn. Das ist umständlicher, als einfach
  Delphi-Quellcode:

  C := A + B

  direkt zu verwenden
• Temporäre Zwischenergebnisse (RValues; in diesem Falle das Ergebnis der Addition
  Delphi-Quellcode:

  A + B

  ) in einem Feld einer Klasse abzulegen ist eher unsinnig. Da du das Ergebnis vor dem Aufsummieren ja aber noch anzeigen willst (und somit um eine Zwischenspeicherung nicht umherkommst), würde ich hier schlicht und einfach eine lokale Variable verwenden.
  Gleiches gillt auch für das Vorherige Ablegen von
  Delphi-Quellcode:

  Zahl1/2

  in einem Feld der Klasse. Selbst wenn du
  Delphi-Quellcode:

  Addition

  wirklich als extra Funktion modellieren willst, solltest du dafür den Prototyp
  Delphi-Quellcode:

  (class) function Add(Value1, Value2: Integer): Integer; (static;)

  verwenden. Hier benötigst du weder Felder für die Parameter, noch für das Ergebnis (die Teile in Klammern sind Optimierungen; falls du damit nichts anfangen kannst, der Einfachheit halber erstmal ignorieren).
• Eigentlich ist - ausschließlich basierend auf Dem, was ich hier sehe - die komplette Klasse nicht erforderlich und verkompliziert nur deinen Code. Sinnvoll wäre sie nur, wenn die Instanz über die Button Clicks hinaus beibehalten würdest (wie Delphi.Narium bereits vorschlägt) und dazu ggfls. noch die Logging Funktionalität kapselt (denn ansonsten kannst du statt der Klasse auch lediglich deine
  Delphi-Quellcode:

  Aufsummierung

  als globale Variable deklarieren).

[Fritzew]

Das Problem liegt im Parameter Name:

Delphi-Quellcode:

procedure TAddition.aufrechnen(Fergebnis:int32);
begin
  FAufrechnung:= Faufrechnung + FErgebnis ;
end;

Ändere diesen bitte z.B zu:

Delphi-Quellcode:

procedure TAddition.aufrechnen(Value:int32);
begin
  FAufrechnung:= Faufrechnung + Value ;

end;

Grund: Was soll denn addiert werden? Der Parameter oder die Variable der Instance?

War rot trotzdem abgeschickt

[Fritzew]

Zitat:

Zitat von LTE5 (Beitrag 1392923)

Zitat:

nichts ist vorgegeben. Das habe ich mir selbst so geschrieben. Es ist nur für mich allein eine Übung.

Dann ändere direkt mal int32 zu Integer :P Denn int32 ist nichts anderes als ein normaler Integer.

An LTE5: Was ändert das? Und wie hilft es dem TE?

[EdAdvokat]

Danke Delphi.Narium für Deine Hinweise. Im Stillen hatte ich selbst diese Vermutung, dass mit FreeAndNil tatsächlich die erste
Summe wieder ins Nirwana geht und ein "Aufaddieren" somit nicht klappt.
Mit dem btn1Click ist also alles futsch. Mit dieser Konstruktion ist es also nicht möglich, das Ergebnis der Summenbildung in die neue
Instanz zu überführen.

Zitat:

Du müsstest dann zumindest das Ergebnis der Aufrechnung wieder aus der Anzeige in die beim Klick erstellte Instanz übernehmen.

Wie sollte dies geschehen?
Es ist doch wohl so, dass ich das ganze völlig neu umschreiben sollte oder?
Fritzew, vielen Dank für den Hinweis, doch auch so geht es nicht, denn es ist wohl tatsächlich so wie es Delphi.Narium geschrieben hat, dass das Ergebnis er ersten Addition mit dem btnClick in den Datenhimmel geschickt wurde und für ein neuerliches Aufrechnen somit nicht mehr zur Verfügung steht. Habe ich das so richtig verstanden?
Die Hinweise von Zacherl muss ich mir nochmals gründlich durchdenken, denn mit (class) Function habe ich mich lediglich theoretisch beschäftigt mit der mühseeligen Übersetzung von Marco Cantù, Object Pascal Handbook.
Die ganze Aktion dient wirklich nur meinem eigenen Verständnis für die Problematik. (ich wollte die Anzahl von Stücken die gedachter Maßen verkauft wurden addieren und dann die Gesamtzahl der Stücke und die Gesamtsumme des Erlöses ausgeben)
Erst einmal glaube ich, nicht auf dem richtigen Weg zu sein mit meinem Versuch.

[Delphi.Narium]

Wenn Du Zahl1 und Zahl2 aus 'nem Edit übernehmen kannst, kannst Du doch wohl auch Aufrechnung aus der Caption des Labels übernehmen.

Delphi-Quellcode:

Add.Zahl1 := StrToIntDef(edtZahl1.text,0);

angepasst für die Aufrechnung

Delphi-Quellcode:

Add.Ergebnisaufrechnen := StrToIntDef(lblAufrechnung.caption,0);

Und nein, die Lösung ist weder optimal noch irgendwie objektorientiert.

In dem Fall ist eine eigene Klasse für die Addition und die Aufrechnung überflüssig.

Überleg Dir bitte nochmal, was Du genau erreichen willst und ob es nicht eventuell sinnvoller ist, die Instanz von TAddition im Create des Formulares zu erstellen und beim Schließen des Formulares wieder freizugeben.
Dann bleiben die Zwischenergebnisse erhalten und die Klasse ließe sich auch um weitere Berechnungsmodalitäten erweitern. Die Anzeigemöglichkeiten im Formular müssen dann nicht als Zwischenspeicher für die Datenhaltung dienen.

[LTE5]

Zitat:

An LTE5: Was ändert das? Und wie hilft es dem TE?

Das ändert, dass das hier verständlicher ist

Delphi-Quellcode:

FZahl1 : integer;
    FZahl2 : integer;
    FErgebnis: Integer;
    FAufrechnung: int32;

Er sagt er ist am üben. Dann kann man doch wohl auch in den Raum werfen, dass int32 exakt dasselbe wie Integer ist und man es umschreiben sollte.
Sollte nur ein nett gemeinter Hinweis sein bevor er sich irgendwann fragt was zur hölle ist int32 ?

[EdAdvokat]

Danke Zacherl

Zitat:

Wenn du willst, kann ich dir gerne beschreiben oder zeigen, wie ich so etwas umsetzen würde. Dazu müsste ich allerdings wissen, was genau deine Zielstellung ist?

Ich will ganz für mich als Beispiel die Anzahl von Stücken und deren Preis ausgeben und dann als Ergebnis die Gesamtzahl der Stücke und deren Erlös
ausgeben zu können. Dazu habe ich mir zum Test das Additionsprogramm geschrieben, doch kam ich ersichtlich zwar zur Addition von Zahl1 und Zahl2, doch
eine Addition von weiteren Werten zum bisherigen Ergebnis scheiterte.
Sicher muss ich das mit Geter und Seter nochmals versuchen, ohne die Klasse sofort wieder zu vernichten. Das mit der class function habe ich noch nicht
verstanden.

Danke Delphi.Narium, ich glaube es ist wirklich zweckmäßig die Instanz von TAddition im create des Formulars zu erstellen, wie Du es vorgeschlagen hast.
Wenn ich das so hinbekommen habe melde ich mich erneut

LTE5 die Variablen integer und int32 sind gleich. Das ist mir durchaus klar und ich habe mich nach dem Studium von Marco Cantu entschlossen im konkreten Beispiel int32 zu verwenden.

[LTE5]

Zitat:

die Variablen integer und int32 sind gleich. Das ist mir durchaus klar und ich habe mich nach dem Studium von Marco Cantu entschlossen im konkreten Beispiel int32 zu verwenden.

Hat das einen bestimmten Grund? Ich würde nur gerne verstehen, welcher Gedankengang dahinter steckt.

[EdAdvokat]

Zitat:

Hat das einen bestimmten Grund? Ich würde nur gerne verstehen, welcher Gedankengang dahinter steckt.

Ich will da keine Grundsatzdiskussion beginnen. Ich denke man kann beide Bezeichnungen wählen.

http://docwiki.embarcadero.com/RADSt...ormate_(Delphi)

[LTE5]

Das soll doch keine Grundsatzdiskussion werden. Ich interessiere mich nur dafür, was du dir für Gedanken machst int32 zu wählen? Bessere Lesbarkeit etc?

[EdAdvokat]

nochmals zum Thema Integer oder int32: Marco Cantù, Object Pascal Handbook:

Zitat:

If you have a hard time remembering the difference between a ShortInt and a
SmallInt (including which one is effectively smaller), rather than the actual type
you can use one of the predefined aliases declared in the System unit:
type
Int8 = ShortInt;
Int16 = SmallInt;
Int32 = Integer;
UInt8 = Byte;
UInt16 = Word;
UInt32 = Cardinal;
Again, these types don't add anything new, but are probably easier to use, as it is
simple to remember the actual implementation of an Int16 rather than that of a
SmallInt. These type aliases are also easier to use for developers coming from C and
other languages that use similar type names.

Man kann es halten wie ein Gartenschlauch, nur nass werden darf man dabei nicht.

[Zacherl]

Zitat:

Zitat von LTE5 (Beitrag 1392944)

Das soll doch keine Grundsatzdiskussion werden. Ich interessiere mich nur dafür, was du dir für Gedanken machst int32 zu wählen? Bessere Lesbarkeit etc?

Kann nicht für den TE sprechen, aber ich benutze auch gerne diese Typen, da man auf den ersten Blick direkt sieht, was hier signed/unsigned ist und wie viele Bits verwendet werden können.

[EdAdvokat]

eine kleine Änderung und schon geht's. Habe Formcreate für die Instanzierung der class genutzt wie von Delphi.Narium angeregt und leise von mir vermutet wurde.
Warum kam ich nicht gleich darauf?
anbei das Ergebnis:
Die Form:

Delphi-Quellcode:

procedure TForm1.btn1Click(Sender: TObject);
var ergSummierung: int32;
begin
    Add.Zahl1 := StrToIntDef(edtZahl1.text,0);
    Add.Zahl2 := StrToIntDef(EdtZahl2.Text, 0);
    Add.Addition;
    LblErgebnis.Caption := IntToStr(Add.Ergebnis);
    ergSummierung:=add.Ergebnis;
    Add.aufrechnen(ergSummierung);
    lblAufrechnung.caption:=inttostr(add.Ergebnisaufrechnen);

  end;

procedure TForm1.btn2Click(Sender: TObject);
begin
  close;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  add:= TAddition.create;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  add.Free;
end;

hier die logic:

Delphi-Quellcode:

type
  TAddition = class
  private
    FZahl1 : int32;
    FZahl2 : int32;
    FErgebnis: Int32;
    FAufrechnung: int32;
  public
    constructor create;
    destructor override;
    procedure Addition;
    procedure aufrechnen(value:int32);
    property Zahl1: Integer read FZahl1 write FZahl1;
    property Zahl2: Integer read FZahl2 write FZahl2;
    property Ergebnis: Integer read FErgebnis;
    property Ergebnisaufrechnen : int32 read FAufrechnung ;
  end;

implementation

{ TAddition }

procedure TAddition.Addition;
begin
  FErgebnis:=FZahl1+FZahl2;
end;

procedure TAddition.aufrechnen(Value:int32);
begin
  FAufrechnung:= Faufrechnung + Value ;
end;

constructor TAddition.create;
begin
  inherited create;
end;

destructor TAddition.override;
begin
  inherited Destroy;
end;

So ist sicher auch eine Rückrechnung von einer bestimmten Anzahl von Stücken bis auf 0 möglich. Diese Musterlösung hilft mir nun bescheiden weiter in meinen Übungen.
Doch ich bin auch neugierig geworden auf den Hinweis von Zacherl zur Nutzung von class function.

Zitat:

Gleiches gillt auch für das Vorherige Ablegen von Zahl1/2 in einem Feld der Klasse. Selbst wenn du Addition wirklich als extra Funktion modellieren willst, solltest du dafür den Prototyp (class) function Add(Value1, Value2: Integer): Integer; (static;) verwenden. Hier benötigst du weder Felder für die Parameter, noch für das Ergebnis (die Teile in Klammern sind Optimierungen; falls du damit nichts anfangen kannst, der Einfachheit halber erstmal ignorieren).

Wäre dies im konkreten Fall eine Möglichkeit? Wofür benutzt man diese grundsätzlich überhaupt? Ich habe bislang relativ wenig darüber gelesen und mir fehlt noch eine
konkrete Vorstellung zum möglichen Einsatz.
Man könne eine class procedure auch dann ausführen, wenn die Klasse noch garnicht instanziert wurde habe ich gelesen. Heißt das beispielsweise, ich könnte
mit dieser Möglichkeit die "Aufaddierung" mittels class function realisieren und dann nach Instanzierung der class ausführen? Wie geht das? Oder habe ich das
völlig falsch verstanden?
Wäre das Additionsbeispiel mit der von mir gewollten "Aufaddition" für ein Beispiel mit class function geeignet und könntest Du mir da etwas aufzeigen?
Es dient lediglich meiner Fortbildung auch in den "höheren Bereich" der OOP, in den ich mich mühseelig mit der Übersetzung von Marco Cantù's Object Pascal Handbook vorwage.
Noch eine Verfahrensfrage: Wie füge ich ein Zitat mit dem Hinweis von wem es kommt hier ein. Bislang schreibe ich nur Zitat und wollte jedoch kennzeichnen, dass das Zitat von Zacherl stammt.
Vielen Dank

[Zacherl]

Zitat:

Zitat von EdAdvokat (Beitrag 1392980)

Wäre dies im konkreten Fall eine Möglichkeit?

Zitat:

Zitat von EdAdvokat (Beitrag 1392980)

Heißt das beispielsweise, ich könnte mit dieser Möglichkeit die "Aufaddierung" mittels class function realisieren und dann nach Instanzierung der class ausführen?

Nein, wenn du deine

Delphi-Quellcode:

Addition

Funktion ohne Änderungen beibehalten willst, darfst/kannst du sie nicht zu einer

Delphi-Quellcode:

class procedure

machen, da dann nicht mehr auf die (Instanz-)Felder

Delphi-Quellcode:

FErgebnis, FZahl1 und FZahl2

zugegriffen werden kann. Die Begründung hast du dir schon selbst gegeben mit

Zitat:

Zitat von EdAdvokat (Beitrag 1392980)

Man könne eine class procedure auch dann ausführen, wenn die Klasse noch garnicht instanziert wurde habe ich gelesen

Die ist nämlich vollkommen korrekt. Der Aufruf würde dann über

Delphi-Quellcode:

TMyClass.Test()

erfolgen anstelle von

Delphi-Quellcode:

TMyClass.Create.Test() bzw. MyClassInstanze.Test()

.

Es gibt im Grunde 3 verschiedene Varianten, die man betrachten muss:

1. Delphi-Quellcode:

   procedure Test;

   
   Dies ist eine Instanz-Methode, welche im versteckten
   Delphi-Quellcode:

   Self

   Parameter einen Zeiger auf die aktuelle Instanz beinhaltet
2. Delphi-Quellcode:

   class procedure Test;

   
   Im Grunde noch nicht sehr verschieden zur "normalen" Methode, nur mit dem Unterschied, dass
   Delphi-Quellcode:

   Self

   hier nicht auf die Instanz verweist, sondern auf die Klasse. Zugriff auf "normale" Instanz-Felder bzw. -Methoden ist hier schon nicht mehr möglich.
3. Delphi-Quellcode:

   class procedure Test; static;

   
   Bei dieser Variante fehlt der
   Delphi-Quellcode:

   Self

   Parameter komplett. Hierdurch bedingt gellten die gleichen Einschränkungen wie bei einer
   Delphi-Quellcode:

   class procedure

   ohne
   Delphi-Quellcode:

   static

   . Diese Art von "Methode" kann (und wird oft) auch in Records verwendet werden. Hierbei ist diese Deklaration unter der Haube komplett identisch mit einer normalen
   Delphi-Quellcode:

   procedure

   , die du außerhalb einer Klasse (z.b. "freischwebend" im
   Delphi-Quellcode:

   implementation

   Abschnitt deiner Unit) deklarierst.

Zitat:

Zitat von EdAdvokat (Beitrag 1392980)

Wofür benutzt man diese grundsätzlich überhaupt?

Es ist im Grunde einfach die modernere Schreibweise für ansonsten besagte "freischwebende" Funktionen. Vorteil ist, dass die "Methode" dann thematisch einer Klasse/einem Record zugeordnet werden kann und somit dann an einer Stelle deklariert wird, an der es vom Kontext her Sinn macht. Außerdem kann es als kleine Performanceoptimierung angesehen werden und sollte meiner Meinung nach auch immer eingesetz werden, wenn man eine Methode schreibt, die tatsächlich die konkrete Instanz nicht kennen muss.

Zitat:

Zitat von EdAdvokat (Beitrag 1392980)

Wäre das Additionsbeispiel mit der von mir gewollten "Aufaddition" für ein Beispiel mit class function geeignet und könntest Du mir da etwas aufzeigen?

Ohne Änderung und mit den Feldern so nicht machbar. Möglich wäre allerdings der schonmal genannte Prototyp

Delphi-Quellcode:

class function TAddition.Add(Value1, Value2: Integer): Integer; static;

.
Statt

Delphi-Quellcode:

Add.Zahl1 := StrToIntDef(edtZahl1.text,0);
Add.Zahl2 := StrToIntDef(EdtZahl2.Text, 0);
Add.Addition;
LblErgebnis.Caption := IntToStr(Add.Ergebnis);

würde sich dein Aufruf dann in

Delphi-Quellcode:

LblErgebnis.Caption := 
  IntToStr(TAddition.Add(StrToIntDef(edtZahl1.text,0), StrToIntDef(edtZahl2.text,0));

ändern.

Wie du siehst wäre dann hierfür auch keine Instanz notwendig. Die

Delphi-Quellcode:

Aufsummierung

kann man allerdings nicht in dieser Form umschreiben, da du dir hier den Wert ja zwischen zwei Aufrufen merken willst, demnach also zwingend eine Instanz mit Feld benötigst.

Edit:

Zitat:

Zitat von EdAdvokat (Beitrag 1392980)

Noch eine Verfahrensfrage: Wie füge ich ein Zitat mit dem Hinweis von wem es kommt hier ein

Dazu kannst du einfach auf den "Zitat" Button rechts unterhalb eines beliebigen Beitrags klicken.

[EdAdvokat]

Danke Zacherl für Deine Hinweise. Ich werde das gleich mal durchexerzieren. Auch Danke für den Hinweis mit dem Zitat. Ich habe überall gesucht und bin einfach nicht darauf gekommen, dass es auf der gleichen Seite den entspr. Button gibt.
Nochmals vielen Dank auch an die anderen user für die Hinweise.