Record Größe zur Laufzeit bestimmen

[brechi]

bisher habe ich folgenden code um die größe von Records (Alignment 1,2,4,8) zur Laufzeit zu bestimmen
der Code sollte selbsterklärend sein, aber ich bin zu dumm dafür oder einfach zu müde, also wenn sich jemand dran machen will dann gerne

Delphi-Quellcode:

function GetRecordSize(types: array of TxType; Alignment: Integer): Integer;
var
  i: integer;
  max: integer;
begin
  max := 0;
  for i := low(types) to high(types) do
  case types[i] of
    xInteger: if max < 4 then max := 4;
    xByte: if max < 1 then max := 1;
    xDouble: if max < 8 then max := 8;
    xExtended: if max < 10 then max := 10;
    xWord: if max < 2 then max := 2;
  end;
  if max < Alignment then
    Alignment := max;

  result := 0;
  for i := low(types) to high (types) do
  case types[i] of
    xInteger: if result mod 4 = 0 then inc(result,4) else inc (result,4 + alignment-(result mod alignment+1));
    xByte: if result mod 1 = 0 then inc(result,1) else inc (result,1 + alignment-(result mod alignment+1));
    xDouble: if result mod 8 = 0 then inc(result,8) else inc (result,8 + alignment-(result mod alignment+1));
    xExtended: if result mod 10 = 0 then inc(result,10) else inc (result,10 + alignment-(result mod alignment+1));
    xWord: if result mod 2 = 0 then inc(result,2) else inc (result,2 + alignment-(result mod alignment+1));
  end;
  if result mod alignment <> 0 then
    result := result + alignment-(result mod alignment);
end;

type b =  record
  b: byte;
  a: extended;
  i: integer;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  form1.caption := inttostr(GetRecordSize([xByte, xExtended, xInteger],8))+' '+inttostr(SizeOf(b))

der obice dode ist im mom schwachsinn hab den mittlerweile wieder geändert :/ vill bekommts jemand hin

[sirius]

sizeof ist dir wohl nicht gut genug?

[brechi]

Ne weil ich die Records erst zur laufzeit "selbst" erzeuge. Den Aufbau des Records kenn ich zur Designzeit nicht.

[Christian Seehase]

Moin Brechi,

mal abgesehen, dass ich die Sache etwas anders angehen würde (

Delphi-Quellcode:

function csGetRecordSize(const ATypes: array of TxType;const AiAlignment: Integer): Integer;

var
  i          : Integer;
  iIncrement : Integer;

begin
  Result := 0;
  for i := Low(ATypes) to High(ATypes)-1 do begin
    iIncrement := 0;
    case ATypes[i] of
      xInteger  : if AiAlignment > 4 then iIncrement := AiAlignment else iIncrement := 4;
      xByte     : iIncrement := AiAlignment;
      xDouble   : if AiAlignment > 8 then iIncrement := AiAlignment else iIncrement := 8;
      xExtended : begin
        case AiAlignment of
          1,2 : iIncrement := 10;
          4   : iIncrement := 12;
          8   : iIncrement := 16;
        end;
      end;
      xWord     : if AiAlignment > 2 then iIncrement := AiAlignment else iIncrement := 2;
    end;
    inc(Result,iIncrement);
  end;
  if High(ATypes) > -1 then begin
    case ATypes[High(ATypes)] of
      xInteger  : Inc(Result,4);
      xByte     : Inc(Result,1);
      xDouble   : Inc(Result,8);
      xExtended : Inc(Result,10);
      xWord     : Inc(Result,2);
    end;
  end;
end;

), frage ich mich, was SizeOf da eigentlich bei einem Alignment von 8 veranstaltet.
SizeOf errechnet 24, was ja, wie man leicht von Hand nachrechnen kann, falsch ist.
(Byte erfordert 8, Extended 16 und Integer 4 Byte, macht zusammen 28 )
Bei 1, 2 und 4 ist alles richtig.
Ausprobiert hat ich es mit D7 und D2006

[brechi]

extended ist 10 vill liegts daran danek erstmal werd morgen mal testen

[brechi]

Also der Code von dir funtkoineit so auch nicht. Als Beispiel hab ich:

Delphi-Quellcode:

type xt = record
  a: extended;
  b: integer;
  c: byte;
end;

begin
  writeln(SizeOf(xt),' ',csGetRecordSize([xExtended, xInteger, xByte], 8));

genommen und bei dir kommt da 25 raus. Das kann aber deshalb nicht sein, weil das Ergebnis immer mod alignment = 0 sein muss. (in dem Fall 24)
Ich versuch das heute nochmal selbst aber vill hat ja jemand so einen Code schonmal geschrieben Jedenfalls danke erstmal Christian.

Du erhöst z.B. in deinem COde immer umd as Alignment das ist aber falsch. Bei einem Alignment von 8 und einem Record von Byte Integer ist die richtige Lösung 8 da es so aufgebaut wird:
b---iiii

Eigentlich weiß ich genua wie alles Berechnet wird war bisher nur zu dumm das umzusetzen, ok war auch spät nachdem man shcon 8 h geproggt hatte.

[nicodex]

Ein wenig Pseudo-Code:

Delphi-Quellcode:

{$ALIGN Alignment}
type
  TFoo = record
    b : Byte;                  //  $00
  //x1: array [0..6] of Byte;  //  $01  Align(Min(Alignment, SizeOf(a)))
    a : Extended;              //  $08
  //x2: array [0..1] of Byte;  //  $12  Align(Min(Alignment, SizeOf(i)))
    i : Integer;               //  $14
  //x3: array [    ] of Byte   //  $18  Align(Min(Alignment, SizeOf(MaxMember))
  end;                         // ($18)

Noch ein Edit um Missverständnissen vorzubeugen
SizeOf(...) in den Kommentaren ist das 'Alignment, welches für das Strukturmitglied benötigt wird'. SizeOf() ist insofern 'inkorrekt', da das Alignment eines strukturierten Typs das Alignment des 'größten Mitglieds' ist.
Beispiel:Arr: array [0..1] of Word; Die benötigte Ausrichtung für Arr ist die Größe eines Elements - nicht SizeOf(Arr)!

Delphi-Quellcode:

Bar: record
  A: Word;  // 'größte erforderliche Ausrichtung' in Bar
  B: Byte;
//x: Byte;
end;

SizeOf(Bar) ist 4. Die Ausrichtung für Bar selbst ist 2 (Bar.A erfordert eine Ausrichtung der Struktur an 2 Bytes).

Lösungsansatz für o.g. Problem:

Delphi-Quellcode:

type
  PXType = ^TXType;
  TXType = (
    xByte,
    xWord,
    xInteger,
    xDouble,
    xExtended
  );

const
  XTypeSize: array [TXType] of Cardinal = (
    SizeOf(Byte),     // xByte
    SizeOf(Word),     // xWord
    SizeOf(Integer),  // xInteger
    SizeOf(Double),   // xDouble
    SizeOf(Extended)  // xExtended
  );

type
  // Dummy type to automatically detect the default alignment
  TAlignmentDetection = record
    A: Byte;
    B: Int64;
  end;

function GetRecordAlignment(const ATypes: array of TXType; AAlignment: Cardinal
  ): Cardinal;
var
  Index: Integer;
  Align: Cardinal;
begin
  if AAlignment < 1 then
    AAlignment := SizeOf(TAlignmentDetection) - SizeOf(Int64);
  Result := 0;
  for Index := Low(ATypes) to High(ATypes) do
  begin
    Align := XTypeSize[ATypes[Index]];
    if Align > AAlignment then
      Align := AAlignment;
    if Align > Result then
      Result := Align;
  end;
end;

function GetRecordSize(const ATypes: array of TXType; AAlignment: Cardinal
  ): Cardinal;
var
  ResultAlign: Cardinal;
  Index: Integer;
  XSize: Cardinal;
  Align: Cardinal;
  Spare: Cardinal;
begin
  if AAlignment < 1 then
    AAlignment := SizeOf(TAlignmentDetection) - SizeOf(Int64);
  Result := 0;
  ResultAlign := 0;
  for Index := Low(ATypes) to High(ATypes) do
  begin
    XSize := XTypeSize[ATypes[Index]];
    if XSize > 1 then
    begin
      Align := XSize;
      if Align > AAlignment then
        Align := AAlignment;
      if Align > ResultAlign then
        ResultAlign := Align;
      Spare := Align - (Result mod Align);
      if Spare < Align then
        Inc(Result, Spare);
    end;
    Inc(Result, XSize);
  end;
  if ResultAlign > 1 then
  begin
    Spare := ResultAlign - (Result mod ResultAlign);
    if Spare < ResultAlign then
      Inc(Result, Spare);
  end;
end;