Record erweitern

[Bomberbb]

Hallo,

mal ne Frage: Kann ich in einem Rekord mit 2 Variablen auf die gleiche Speicherstelle verweisen?

Gruß

BBB

[Dax]

Mit varianten Records (Hilfe sagt dazu mehr) geht das:

Delphi-Quellcode:

... = record
  ...
  case Integer of
    1: (felder1);
    2: (felder2);
  end;

felder1 und felder2 haben nun den gleichen Startpunkt im Speicher.

[himitsu]

mal ein praktisches Beispiel:

Delphi-Quellcode:

type
  LongRec = packed record
    case Integer of
      0: (Lo, Hi: Word);
      1: (Words: array [0..1] of Word);
      2: (Bytes: array [0..3] of Byte);
  end;

Weiteres siehe Delphihilfe
Abschnitt: Variante Teile in Record-Typen (auch zu finden über Abschnitte Record-Typen oder Record-Konstanten)

[Bomberbb]

Ich will ein vorhandenes Record

Delphi-Quellcode:

rec=record
  p1:tpoint;
  p2:tpoint;
  p3:tpoint;
  p4:tpoint;
end;

so erweitern:

Delphi-Quellcode:

rec=record
  p1:tpoint;
  p2:tpoint;
  p3:tpoint;
  p4:tpoint;
  p:Array[1..4]of tpoint;
end;

ggf. auch mit pointern. So dass ich mit rec.p1 und rec.p[1] auf den gleichen Wert zugreife.

[himitsu]

wie zu sehn ... ist es doch recht einfach

Delphi-Quellcode:

type
  Rec = record
    case Integer of
      0: (p1: TPoint;
          p2: TPoint;
          p3: TPoint;
          p4: TPoint);
      1: (p: Array[1..4] of TPoint);
  end;

oder

Delphi-Quellcode:

type
  Rec = record
    case Integer of
      0: (p1, p2, p3, p4: TPoint);
      1: (p: Array[1..4] of TPoint);
  end;

[Bomberbb]

gut funktionieren tut es, aber verstanden hab ich's trotz Durchlesen der Hilfe noch nicht.

Was sagt mir
  case integer of ?

Sollte der Selektor einer CaseAnweisung nicht eine Variable sein???

In der Hilfe steht:

Zitat:

Der variante Teil eines Records enthält mehrere Varianten, die sich denselben Speicherplatz teilen.

Kann ich davon ausgehen das bei folgender Definition:

Delphi-Quellcode:

type
  Rec = record
    case Integer of
      0: (p1, p2, p3, p4: TPoint);
      1: (p: Array[1..4] of TPoint);
  end;

immer gilt p1=p[1], p2=p[2]...?

[Cyf]

Wenn du noch ein packed rein setzt sollte das sicher so sein, ohne bin ich nicht sicher, ob dir das Alignment nicht reinpfuscht.

[himitsu]

Jupp, davon kanns du ausgehen (nja, zumindestens die Feldausrichtung im Record dieses hergibt)
drum verwende ich oftmals ganz gern packed Records und Arrays

Delphi-Quellcode:

Rec = record
  case x: Integer of
    0: (p1, p2, p3, p4: TPoint);
    1: (p: Array[1..4] of TPoint);
end;

ohne Feldnahmen im CASE wird der dort angegebene Type zur Unterteilng er einzelnen überlagerten Teile verwendet

Delphi-Quellcode:

Rec = record
  case Boolean of
    false: (p1, p2, p3, p4: TPoint);
    true:  (p: Array[1..4] of TPoint);
end;

// oder

MySet = (msPoints, msPointArray);
Rec = record
  case Boolean of
    msPoints:     (p1, p2, p3, p4: TPoint);
    msPointArray: (p: Array[1..4] of TPoint);
end;

bezüglich der "Variable"

Delphi-Quellcode:

Rec = record
  case x: Integer of
    0: (p1, p2, p3, p4: TPoint);
    1: (p: Array[1..4] of TPoint);
end;

// entspricht

Rec = record
  x: Integer;
  case Integer of
    0: (p1, p2, p3, p4: TPoint);
    1: (p: Array[1..4] of TPoint);
end;
// bzw.
Rec = record
  x: Integer;
  p1, p2, p3, p4: TPoint;
end;

in diesem Fall könnte man X z.B. dazu verwenden welche Defiinition verwendet wird.
vorallem nützlich, wenn man da unterschiedliche ypen einbaut

Delphi-Quellcode:

Rec = record
  case verwendet: Integer of
    0: (s: string);
    1: (i: integer);
    2: (b: byte);
end;

[Bomberbb]

Also. ich werde das nur für gleiche Typen nutzen. Ich will einfach ein vorhandenes Record so erweitern, dass ich über ein Array auf die Punkte zugreifen kann, was das arbeiten damit einfacher macht. Leider ist das Record 20 Jahre alt und eine generelle Umstellung wäre fatal.

Besten Dank! und schönen Feierabend!

[himitsu]

seit 'ner Weile (ich glaub Delphi 2006) geht auch Folgendes:

Delphi-Quellcode:

TRec = record
  p1, p2, p3, p4: TPoint;
private
  function ReadP(index: integer): TPoint;
  procedure WriteP(index: integer; p: TPoint);
public
  property p[index: integer]: TPoint read ReadP write WriteP;
  procedure ReadP3: TPoint;
end;

function TRec.ReadP(index: integer): TPoint;
begin
  case index of
    1: result := p1;
    2: result := p2;
    3: result := p3;
    4: result := p4;
  end;
end;

procedure TRec.WriteP(index: integer; p: TPoint);
begin
  case index of
    1: p1 := p;
    2: p2 := p;
    3: p3 := p;
    4: p4 := p;
  end;
end;

procedure TRec.ReadP3: TPoint;
begin
  result := p3;
end;

also fast so wie man es auch von den Klassen her kennt.