Ich erkundige mich seit kurzem über Delphi XE 2 Starter Edition, weil ich bedenke, dieses mir zuzulegen.
[Edit] Schade, mich habense verloren: http://www.delphipraxis.net/1120577-post27.html [/Edit]

Auf einem Youtube-Video habe ich eben folgendes gesehen - ein Record hatte einen Constructor. Mir stellt sich nun die Frage, was der ganze Sinn dahinter ist. Muss/(besser)Kann man nun Speicher für Records direkt per Constructor reservieren oder was? Sollen damit Konstrukte wie diese hier...

markieren

Delphi-Quellcode:

var
  pPnt: PPoint;
begin
  New(pPnt);
  {...}

hiermit...

markieren

Delphi-Quellcode:

var
  Pnt: PPoint;
begin
  Pnt := TPoint.Create;
  {...}

umgangen werden?

Weiters frage ich mich, wie sehr Records nun Klassen ähneln. Wo sind die Unterschiede.

Wäre nett, wenn mich einer diesbezüglich aufklären könnte ^_^

Wie das mit den Konstruktoren ist, weiß ich auch nicht so genau. Könnte mir vorstellen, dass sie bei der Initalisierung automatisch aufgerufen werden, aber wenn ich mich recht erinnere, hatte sich himitsu mal beschwert, dass das nicht möglich ist – also wohl eher nicht. Wahrscheinlich ist es einfach nur, damit man schreiben kann Point = TPoint.Create(3,4); (sowas habe ich bisher immer mit statischen Methoden gemacht)? Keine Ahnung... würde mich auch interessieren.

Auf jeden Fall ist der wichtigste Unterschied zwischen Klassen und Records, dass Records keine Vererbung unterstützen.

Zitat:

Auf jeden Fall ist der wichtigste Unterschied zwischen Klassen und Records, dass Records keine Vererbung unterstützen.

Ist das wirklich der Fall bei den neuesten Versionen?

Zitat von Aphton:

Zitat:

Auf jeden Fall ist der wichtigste Unterschied zwischen Klassen und Records, dass Records keine Vererbung unterstützen.

Ist das wirklich der Fall bei den neuesten Versionen?

Nach meiner Information ja.

Hallo,

Der Constructor bei Records ist eher eine Init-Methode, in der man Felder initialisieren kann.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TPointEx = record
    X,Y: Integer;
    constructor Create(AX,AY: Integer);
  end;

constructor TPointEx.Create(AX,AY: Integer);
begin
  X := AX;
  Y:= AY;
end;

procedure TForm1.FormCreate(Sender: TObject);
var Pt: TPointEx;
begin
  Pt.X := 123;
  Pt.Y := 987;
  Caption := Format('X: %d, Y: %d',[Pt.X,Pt.Y]);

  Pt := TPointEx.Create(10,20);
  Caption := Caption + ' ' + Format('X: %d, Y: %d',[Pt.X,Pt.Y]);
end;

Beide Methoden funktionieren ohne Probleme.

Pt := TPointEx.Create(10,20);
ist quasi eine Alternative zu

Pt := Point(10,20);

Ein Konstructor in einem Record ist nichts anderes als eine (statische) Init-Funktion, nicht mehr und nicht weniger.

Außerdem ist ein Record nach wie vor ein Wertetyp und kein Referenztyp.

Das mit dem Create-an-Pointer geht leider nicht.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TTest = record
    constructor Create; // *1
    constructor Create(X: integer = 0); // *2
  end;
  PTest = ^TTest;

procedure TForm2.FormCreate(Sender: TObject);
var
  P: PTest;
  T: TTest;
begin
  P := TTest.Create(0); // *3

  T := TTest(0); // *4
  T := TTest.Create(0); // *5
end;

1: [DCC Fehler] Unit3.pas(30): E2394 Parameterlose Konstruktoren sind für Record-Typen nicht zulässig
Warum eigentlich nicht?
Einen plusieblen Grund konnte man mir noch nicht nennen.

2: [DCC Fehler] Unit3.pas(30): E2471 Möglicherweise parameterlose Konstruktoren sind in Record-Typen nicht zulässig
(ich dachte ja, man kann den austriksen )

3: [DCC Fehler] Unit1.pas(42): E2010 Inkompatible Typen: 'PTest' und 'TTest'

4: [DCC Fehler] Unit1.pas(35): E2089 Ungültige Typumwandlung
Schade, denn eigentlich sah es sehr schön aus

5: geht, so kann man sich den Record über einen Constructor vorbefüllen lassen


Im Prinzip ist "entsprichter" Constructor nur

markieren

Delphi-Quellcode:

type
  TTest = record
    class function Create(X: integer): TTest;
  end;

Was IMHO hier verständlicher wäre, als soeine "Constructor".
Die Klassenfunction kann man übrigens auch parameterlos nutzten und sie wird genauso verwendet die dieser Pseudoconstructor.

Ich frage mich eh, warum sie überhaupt die constructor Syntax gewählt haben, da da nix "constructed" wird, im Sinne von Speicher allokieren.
Den parameterlosen "Konstructor" kann man wie du schon geschrieben hast, durch eine static methode simulieren.

Punkt 4 geht, wenn du operator implicit oder explicit einbaust.

Zitat von Stevie:

Punkt 4 geht, wenn du operator implicit oder explicit einbaust.

Aber nur solange nur ein Parameter verwendet wird.

Und TTest([0, 2, 666]) sieht ein bissl blöd aus, bei einem Explicit mit Open-Array-Parameter.

PS:

zusammenfalten · markieren

Delphi-Quellcode:

type
  PTest = ^TTest;
  TTest = record
    x, y: Integer;
    class function Create: PTest;
    class function Create(x, y: Integer): PTest;
    procedure Free;
  end;

class function TTest.Create: PTest;
begin
  Result := Create(0, 0);
end;

class function TTest.Create(x, y: Integer): PTest;
begin
  New(Result);
  Result.x := x;
  Result.y := y;
end;

procedure TTest.Free;
begin
  if @Self <> nil then
    Dispose(@Self);
end;

Sieht doch hübsch aus?

Zitat von himitsu:

Zitat von Stevie:

Punkt 4 geht, wenn du operator implicit oder explicit einbaust.

Aber nur solange nur ein Parameter verwendet wird.

Und TTest([0, 2, 666]) sieht ein bissl blöd aus, bei einem Explicit mit Open-Array-Parameter.

Logisch, dein Beispiel hatte ja auch nur einen Wert, oder?

Kann's dir ooch uff'n Kopp stell'n um die 6 Zeichen und den Punkt von .Create zu sparen... bringt ooch nüscht.