Aufrechnen von Integer-Werten in ein neues Ergebnis

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