array of record zuweisung

[Marco Steinebach]

Hallo zusammen,
Ich seh mal wieder den Wald vor lauter Bäumen nicht.
Ich möchte einer Methode ein array of record als open-array-parameter übergeben, soweit, so einfach:

Code:

type
  TRec = record
    s: string;
    i: integer;
  end;
procedure machwas (a: array of TRec);

Aber wie, um himmelswillen, ruf ich die jetzt auf?
Ich hatte was von

Code:

machwas ([('Hallo', 1), ('Selber Hallo', 2)]);

geträumt, is aber nich.

Kann mir mal jemand auf die Sprünge helfen, bitte!

Herzliche Grüße
Marco

[KodeZwerg]

Also ich würde noch eine Variable dazwischen schubsen um besser damit umgehen zu können.

Delphi-Quellcode:

type
  TRec = record
    s: string;
    i: integer;
  end;
  TRecs = array of TRec;

noch ein
  Recs: TRecs;
um damit spielen zu können.



procedure TuWasRein(const s: string; const i: Integer);
begin
  SetLength(Recs, Length(Recs) +1);
  Recs[Length(Recs)].s := s;
  Recs[Length(Recs)].i := i;
end;

function HolWasRaus(const AIndex: Integer): TRec;
begin
  Result.s := Recs[AIndex].s;
  Result.i := Recs[AIndex].i;
end;

Nur so mal hier in Editor getippst, nicht getestet.

[Uwe Raabe]

Delphi 5 habe ich gerade nicht zur Hand, aber mit einem const solle es gehen:

Delphi-Quellcode:

procedure machwas(const a: array of TRec);
begin
  ...
end;

[KodeZwerg]

Wenn in dem TRec der Integer Wert als eine Art Index genutzt werden soll könnte man auch gleich auf eine TStringList umsatteln falls es das bei Delphi 5 schon gab.

[QuickAndDirty]

Ich überlege gerade
ist Delphi5 Lazarus vorraus?

Ich wette es liegt an Packages von Fremdherstellern?

[himitsu]

Mit CONST geht es auch im neuen delphi nicht.

Bei Record-Konstanten musste man auch die Feldnamen mit angeben, aber hier funktioniert es so nicht.

Delphi-Quellcode:

const
  CRec: array[0..1] of TRec =  // geht
    (
      (s: 'Hallo'; i: 1),
      (s: 'Selber Hallo'; i: 2)
    );

machwas([(s: 'Hallo', i: 1), (s: 'Selber Hallo', i: 2)]); // geht nicht

k.A. warum, aber scheinbar wird bei diesem [ kein "array of TRec" begonnen, sondern ein "array of string", Anhand des ersten Feldes darin, was ein String ist.

So geht es, mit etwas aktuellerem Delphi, was nur halb so alt ist.
Bei Delphi 5 dürfte die Variante mit "externe Funktion" gehen.

Delphi-Quellcode:

type
  TRec = record
    s: string;
    i: integer;
    constructor Create(s: string; i: Integer);  
    //class operator Implicit(Values: array of const): TRec;
  end;
  // der als "class function C(s: string; i: Integer): TRec; static;" anstatt dem constructor
  // oder als externe Funktion "function Rec(s: string; i: Integer): TRec;" , für noch Kürzer

constructor TRec.Create(s: string; i: Integer);
begin
  Self.s := s;  // wenn als "function" dann Result.s := s;
  Self.i := i;
end;

procedure machwas(a: array of TRec);
begin
end;

procedure TForm13.FormCreate(Sender: TObject);
begin
  machwas([TRec.Create('Hallo', 1), TRec.Create('Selber Hallo', 2)]);
  //machwas([['Hallo', 1], ['Selber Hallo', 2]]);  // IMPLICIT geht nicht
  //machwas([TRec(['Hallo', 1]), TRec(['Selber Hallo', 2])]);  // EXPLICIT geht auch nicht
end;

Oder unschön als procedure machwas(Values: array of const);
machwas(['Hallo', 1, 'Selber Hallo', 2]);
und dann das eine Array intern auf die Felder des TRec-Array aufteilen.

[KodeZwerg]

@himitsu: Hui... naja, wers mag soll zugreifen.
Ich kann es noch nicht ganz nachvollziehen da ich meine Records nicht direkt als Definition anspreche sondern als Objekt der Definition.
Kann man so echt auf das TRec und seine Elemente per Index zugreifen? (zum lesen)

Für mich schaut des gerade so aus als ob immer wieder ein neues Array in speicher geschrieben wird und niemand weiß wo es abgeblieben ist.

//edit
Meine Vermutung ist, das "a" dann die Daten hat, zumindest einen Augenblick lang und dann byebye...

[himitsu]

Zitat von KodeZwerg:

Kann man so echt ...

Zitat von himitsu:

So geht es,

Also ja.

OpenArray, aber nur wenn der Parameter wirklich als array of deklariert ist. (kein TArray<> oder sonstwelche Array-"Typen")
http://docwiki.embarcadero.com/RADSt...en/Open_Arrays
Und array of const ist nochmal härter (siehe Format), wobei das "const" eigentlich auch nur ein TVarRec ist.
http://rvelthuis.de/articles/articles-openarr.html

[KodeZwerg]

Zitat von himitsu:

Also ja.

Sorry das ich fragte, das war Neuland für mich, also ganz lieben Dank für mehr Input zum Thema!!!

Ausgehend von Deinem Beispiel (wo mich der Constructor part zu sehr an Klassen erinnert) wurde gebastelt das es auch ohne klappt.

Delphi-Quellcode:

type
  TRec = record
    s: string;
    i: integer;
  end;

function MakeRec(ss: string; ii:integer): TRec; inline;
begin
  with Result do
    begin
      s := ss;
      i := ii;
    end;
end;

procedure DoJob(a: array of TRec);
begin
end;

begin
  DoJob([MakeRec('Hi', 1), MakeRec('Bye', 2)]);
end.

und noch mehr gespielt in der schönen Delphi Welt

Delphi-Quellcode:

type
  test = ^TRec;
  TRec = record
    s: string;
    i: integer;
  end;


function create_test(const ss: string; const ii: integer): test;
var
  temp : test;
begin
// speicherleck durch new(temp) möglich/wahrscheinlich!
  new(temp);
  temp^.s := ss;
  temp^.i := ii;
  exit(temp);
end;

procedure doJob(a : array of test);
//var
//  j : test;
begin
//  for j in a do
//    begin
//      writeln(j^.s,'  ',j^.i);
//    end;
end;

begin
  doJob([create_test('hello',10), create_test('bye',20)]);
end.

Ohne Deine Erklärungen wäre das nie passiert :-]

[himitsu]

Zitat:

der schönen Delphi Welt

Nur dass du mit dem Pointer nun ein Speicherleck bekommst, awnn du in doJob die Zeiger im Array nicht freigibst.

Ein ReportMemoryLeaksOnShutdown := True; kann da nicht schaden.


Man muß einen constructor nicht Create nennen. (nur der Destrucor muß eigentlich immer Destroy heißen, was auch nicht ander geht, wegen dem override)
Und die Methode in der Klasse statt Einzeln hat den Vorzeil, dass man logisch so alles zusammen hat und wunderbar die Codevervollständigung ausnutzen kann, um alles zu finden, was zum Record gehört ... weil st ja direkt drin.

Zitat:

temp^.s

Vor dem Punkt ist das ^ ist optional.

Rein technisch hast mir dem Pointer aber den einen Vorteil vom Records vernichtet ... da könnte man auch gleich ein Objekt verwenden.


Und statt Temp kann man auch direkt Result nutzen. (keine unnötigen doppelten Variablen)