Setlength aufrufen von untergeordneter prozedur auf owner Klasse.

[gemy]

Guten Morgen !

Ich habe ein Trecord in einer Klasse :

..

Code:

Torder = record
         private
                ...
                fMissed_points: currency;
                ...
                
                procedure SetMissedPoints (Value: currency);
                ...
        public
                property Missed_points : currency Read fMissed_points Write SetMissedPoints;
end;

Tpattern = class(Tobject)
          PRIVATE
          fMedArr: array of currency;
          ...


   PUBLIC { Public-Deklarationen  }
          OrderItems    : array of Torder;

nun befinde ich mich im Aufruf :

Code:

procedure Torder.SetMissedPoints(const Value: currency);
var i : integer;
begin
 self.fMissed_points := Value;
 Setlength(

//
end;

Wie kann ich von Torder.SetMissedPoints das Setlength auf fMedArr aufrufen ? quasi so: setlength(übergeordneteklasse.fMedarr,1); ? (das muss auch sicher sein wenn ich meine Klasse mehrmals erstelle). Irgendwie so muss das ausehen SetLength(tpattern.self.fmedarr,1). Ich komm aber leider nicht drauf.


Danke für eure Hilfe !

[Der schöne Günther]

Nur dass ich die Struktur richtig verstanden habe: Du hast beliebig viele TOrder-Records die in einem TPattern stecken. Wenn man auf einem TOrder SetMissedPoints(..) aufruft soll der hingehen und auf dem TPattern in dem er steckt Dinge ändern?



Wenn ja, dann fehlt deinem TOrder eine Referenz auf das TPattern in dem es steckt. Es weiß ja momentan gar nicht, worin es steckt. Dir fehlt also ein Feld in deinem TOrder das auf das TPattern-Objekt zeigt.

[gemy]

Genau so ist es. In OrderItems habe ich z.B. 100 Einträge. Ergo 100 mal ->(fMissed_points: currency

Nun will ich die 100 Werte von dem OrderItems array in die übergeordnete Klasse Tpattern in ein array speichern um dort dann den median Wert der 100 Werte zu ermitteln.


Muss nun arbeiten gehen. Ich schreibe heute abend nochmal rein. Ich dachte mit

Code:

   PUBLIC { Public-Deklarationen  }

          OrderItems    : array of Torder;

weis Torder von wem es abstammt.

[gemy]

Hallo nochmal

habe jetzt ewig rumprobiert, aber ich bekomme es nicht gebacken. Sogar wenn ich es so mache geht es nicht :

Code:

Tpattern = class(Tobject)
        PRIVATE TYPE
                 Torder = record
                        
                        fMissed_points: currency;

                        
                        procedure SetMissedPoints (val : currency);
                        
        PUBLIC
                        property Missed_points : currency Read fMissed_points Write SetMissedPoints;
        end;


 PRIVATE


 fMedArr: array of currency;


  PUBLIC { Public-Deklarationen  }
  OrderItems    : array of Torder;
  procedure MedArr(const Value: currency);



end;

Code:

procedure Tpattern.MedArr(const Value: currency);
var temp: integer;
begin
temp := Length(self.fMedArr)-1;
SetLength(self.fMedArr, temp);
self.fMedArr[temp] := Value;
end;

Code:

procedure Tpattern.Torder.SetMissedPoints(val: currency);
var i : integer;
begin
self.fMissed_points := val;
//Zugriff auf Tpattern.MedArr(const Value: currency) geht nicht.

end;

Egal wie ich es drehe oder wende, ich komme von innen nicht nach ausen um vom Record aus auf die übergeordnete Klasse das SetLenght zu verwenden.

[Luckie]

Kleine Anmerkung zu deinen Settern und Gettern:
property Missed_points : currency Read fMissed_points Write SetMissedPoints; Das ist etwas inkonsistent, da die Benennung vom Schema unterschiedlich ist. Beim Getter fehlt das Get und einmal trennst du mit Unterstrichen und das andere Mal mit Großbuchstaben. So viel ich weiß, ist die Benutzung von Unterstrichen in der Benennung von Prozeduren und Variablen in Delphi eher unüblich. Und in C und C++ üblich. Und konsequenter wäre auch eine Prozedur für den Getter. So macht man es auch normaler Weise.
Besser wäre:
property MissedPoints : currency Read GetMissedPoints Write SetMissedPoints; Eine einheitliche Benennung macht den Code auch einfacher lesbar.

[bernau]

Zitat von Luckie:

Kleine Anmerkung zu deinen Settern und Gettern:
property Missed_points : currency Read fMissed_points Write SetMissedPoints; Das ist etwas inkonsistent, da die Benennung vom Schema unterschiedlich ist. Beim Getter fehlt das Get und einmal trennst du mit Unterstrichen und das andere Mal mit Großbuchstaben. So viel ich weiß, ist die Benutzung von Unterstrichen in der Benennung von Prozeduren und Variablen in Delphi eher unüblich. Und in C und C++ üblich. Und konsequenter wäre auch eine Prozedur für den Getter. So macht man es auch normaler Weise.
Besser wäre:
property MissedPoints : currency Read GetMissedPoints Write SetMissedPoints; Eine einheitliche Benennung macht den Code auch einfacher lesbar.

Bezüglich der einheitlichen Schreibweisen (einmal mit Unterstrich, einmal Ohne) volle Zustimmung. Die Schreibweise sollte gleich bleiben.

Aber warum sollte ein Getter zugefügt werden, wenn dort gar kein weiterer Code ausgeführt wird? Selbst die Codevervollständigung von Delphi erzeugt ein privates Feld und verwendet dies direkt statt einem Getter.

Ich gehe sogar so weit und entferne auch die Setter-Procedure, wenn dort kein Code ausgeführt wird.

property MissedPoints:currency read fMissedPoints write fMissedPoints;

Ich vermeide somit unnützen Code und sehe sofort im Interface-Abschnitt, ob der Setter zusätzlichen Code beinhaltet.

[bernau]

@gemy:

Wenn ich es richtig verstanden habe, möchtest du immer, wenn ein Wert in TOrder "geändert" wird, diesen geänderten Wert in fMedArray "zufügen". Richtig?

TOrder ist für sich gekapselt und hat keinen Zugriff nach aussen auf TPattern.

Du könntest TOrder mitteilen, wer TPattern ist. Dazu erstellst du das "Property parent".

Du darfst aber nicht vergessen Parent anzugeben, wenn du ein Element zu OrderItems zufügst.

Delphi-Quellcode:

type
  Tpattern = class(Tobject)
  private
    fMedArr: array of currency;
  private
    type
    Torder = record
      fMissed_points: currency;
      procedure SetMissedPoints(val: currency);
    private
      FParent: Tpattern;
    public
      property Missed_points: currency Read fMissed_points Write SetMissedPoints;
      Property Parent: Tpattern read FParent write FParent;
    end;
  public
    OrderItems: array of Torder;
    procedure MedArr(const Value: currency);
  end;

procedure Tpattern.MedArr(const Value: currency);
begin
  fMedArr := fMedArr + [Value];
end;

procedure Tpattern.Torder.SetMissedPoints(val: currency);
begin
  fMissed_points := val;
  if assigned(FParent) then
    FParent.MedArr(val);
end;

Wobei ich jetzt nicht sagen will, dass dies besonders Toller Code ist. Und nichts ist getestet.

Insgesamt würde ich auch deine Namensgebung anpassen.

Die Procedure MedArr für einen Wert zu deinem Array hinzu. Besser wärde der Name Procedure AddToMedArr eine Procedure sollte beschreiben, was sie macht.

[gemy]

Danke @bernau, das ist genau das was ich gesucht habe! Auf die Idee bin ich nicht gekommen.

Ich teste das gleich mal.

VIELEN DANK

[Gyrospeter]

wenn ich es so verstanden habe

Funktion erstellt um auf die Länge des Arrays zuzugreifen:

Code:

type
  TArrayClass = class
  private
    MyArray: array of Integer;
    function GetArrayLength: Integer;
  public
    property MyArray: Integer read GetArrayLength;
  end;



function TArrayClass.GetArrayLength: Integer;
var
  i: Integer;
begin
  for i := 0 to Length(FMyArray) - 1 do
    Result := Length(FMyArray);
end;

Instanz erzeugen und dann auf das Objekt zugreifen.

Code:

TForm1 = class(TForm)
    cxMemo1: TcxMemo;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    FArrayObj: TArrayClass;

    procedure ShowArrayValues;
  end;


procedure TForm1.FormCreate(Sender: TObject);
begin
  FArrayObj := TArrayClass.Create;
end;

// hier setze ich die Länge des Arrays aus der anderen Klasse und greife über die Property
// auf den Rückgabewert der Funktion

procedure TForm1.ShowArrayValues;
begin
  SetLength(FArrayObj.FMyArray, 6);

  cxMemo1.Lines.Add(IntToStr(FArrayObj.MyArray));
end;


procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowArrayValues;
end;

[gemy]

Danke, das schaue ich mir auch mal an. Probiere jetzt erst bernaus code aus.