Variablen Definition

[Aphton]

Ein Freund von mir meinte, es macht einen Unterschied, ob man Variablen nach dem Schema A oder Schema B definiert

Delphi-Quellcode:

// A
type
  TMyRecordA = record
    _1: Byte;
    _2: Byte;
    _3: Byte;
    _4: Byte;
  end;

// B
type
  TMyRecordB = record
    _1, _2, _3, _4: Byte;
  end;

Er meinte nämlich, dass bei Variante B für die Vier 1 Byte Elemente nur 1 DWord (also wirklich 4 Bytes) reserviert werden und bei A eben für jedes Feld 4 Bytes (vlt weil dadurch - also 32 Bit - es schneller läuft?)

Stimmt das so? Falls ja, ist das "packed" genau dafür da, damit dies nicht geschieht?

also ist C = B, sofern A <> B

Delphi-Quellcode:

// C
type
  TMyRecordC = packed record
    _1: Byte;
    _2: Byte;
    _3: Byte;
    _4: Byte;
  end;

Edit:
Obwohl --> sizeof(TMyRecordA) = sizeof(TMyRecordB) = sizeof(TMyRecordC).

[Namenloser]

Zitat von Aphton:

Ein Freund von mir meinte, es macht einen Unterschied, ob man Variablen nach dem Schema A oder Schema B definiert
[…]
Stimmt das so?

Nein.

Delphi-Quellcode:

program recordalign;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type

  TRec1A = record
    _1: Byte;
    _2: Byte;
    _3: Byte;
    _4: Byte;
  end;

  TRec1B = record
    _1, _2, _3, _4: Byte;
  end;

  TRec1C = packed record
    _1: Byte;
    _2: Byte;
    _3: Byte;
    _4: Byte;
  end;

  // mit integer in der mitte der das alignment beeinflusst:
  TRec2A = record
    _1: Byte;
    _2: Byte;
    _int: integer;
    _3: Byte;
    _4: Byte;
  end;

  TRec2B = record
    _1, _2: Byte;
    _int: integer;
    _3, _4: Byte;
  end;

  TRec2C = packed record
    _1: Byte;
    _2: Byte;
    _int: integer;
    _3: Byte;
    _4: Byte;
  end;

begin
  WriteLn('1 (4 bytes):');
  WriteLn('Record 1A: ', SizeOf(TRec1A));
  WriteLn('Record 1B: ', SizeOf(TRec1B));
  WriteLn('Record 1C: ', SizeOf(TRec1C));
  WriteLn('');
  WriteLn('2 (2 bytes, 1 int, 2 bytes):');
  WriteLn('Record 2A: ', SizeOf(TRec2A));
  WriteLn('Record 2B: ', SizeOf(TRec2B));
  WriteLn('Record 2C: ', SizeOf(TRec2C));
  readln;
end.

Ausgabe:

Code:

1 (4 bytes):
Record 1A: 4
Record 1B: 4
Record 1C: 4

2 (2 bytes, 1 int, 2 bytes):
Record 2A: 12
Record 2B: 12
Record 2C: 8

[Aphton]

Ahh ne habs, also es ist falsch, was er meinte aber das packed (no-Alignment) macht den unterschied bei ner Größe von 4x:

Delphi-Quellcode:

  TMyTypeA = record
    A: Integer;
    B: Byte;
  end;

  TMyTypeB = packed record
    A: Integer;
    B: Byte;
  end;

sizeof(TMyTypeA) 8
sizeof(TMyTypeB) 5

Die Frage hat sich erübrigt =)
Btw ty

[Luckie]

Zitat von Aphton:

Delphi-Quellcode:

// A
type
  TMyRecordA = record
    _1: Byte;
    _2: Byte;
    _3: Byte;
    _4: Byte;
  end;

// B
type
  TMyRecordB = record
    _1, _2, _3, _4: Byte;
  end;

Er meinte nämlich, dass bei Variante B für die Vier 1 Byte Elemente nur 1 DWord (also wirklich 4 Bytes) reserviert werden und bei A eben für jedes Feld 4 Bytes

Unsinn. Beide Records sind gleich groß. Wird das Schlüsselwort packed nicht verwendet werden die Felder des Records ausgerichtet. Wie sie ausgerichtet werden, kann man mit der Compilerdirektive Align beeinflussen. Wird das Schlüsselwort packed verwendet, liegen sie ohne "Zwischenraum" hintereinander im Speicher. Erstes ermöglicht es der CPU schneller auf die Felder des Rorcords zuzugreifen, weil unter 32 Bit immer 32 Bit aus dem Arbeitsspeicher geholt werden.

Version A und Version B sind identisch, nur unterschiedliche Schreibweisen.

[Aphton]

Alles klar, war ja auch mein Gedanke