Aufbau Dynamisches Array?

[iphi]

Hallo,

kann mir jemand beim Verständnis des Aufbaus von dynamischen Arrays auf die Sprünge helfen?

Soweit verstehe ich die Sache:

var x: array of BYTE; ...legt einen Zeiger x an, der auf den später allokierten Speicherblock zeigen soll.

SetLength(x,4); ...allokiert 4 Byte zusammenhängenden Speicher. Auf diesen zeigt dann x.

Nun meine Frage: Wo wird denn die Länge des dynamischen Arrays im Speicher abgelegt? Ist x wirklich nur ein Zeiger oder ein Record, der die Länge enthält?

[Deep-Sea]

Auszug aus der System.pas:

Delphi-Quellcode:

procedure _DynArrayLength;
asm
{       FUNCTION _DynArrayLength(const a: array of ...): Longint; }
{     ->EAX     Pointer to array or nil                           }
{     <-EAX     High bound of array + 1 or 0                      }
        TEST    EAX,EAX
        JZ      @@skip
        MOV     EAX,[EAX-4]
@@skip:
end;

Interessant ist hier nur die Zeile mit dem MOV-Befehl. Er packt in das Ausgaberegister den Wert, auf den der Array-Pointer - 4 zeigt.
Sprich: Die Länge wird direkt vor den Daten, auf die der Pointer zeigt, gespeichert.
Es handelt sich also nur um einen Pointer und keinen Record.

[mleyen]

Delphi-Quellcode:

function GetArrayLen(var bytes: TBytes): Longint;
begin
  if Cardinal(bytes) = 0 then
    Result := 0
  else
    Result := PInteger(Cardinal(@bytes[0])-sizeof(Result))^;
end;

In der kommenden 64bit-Version wird da auch Int64 verwendet.

[Deep-Sea]

Richtig. Mein Auszug stammt aus einer 32-bit-Version
(Aber darum ging's hier ja auch nicht wirklich.)

[iphi]

Alles klar, danke!
Dann sieht der Datenblock eines dynamischen Arrays also genauso aus wie der eines statischen Arrays mit der Arraylänge ganz am Anfang, richtig?

[Blup]

Nein, in einem statischen Array sind kein Informationen über die Größe enthalten.

Bei aktiver Bereichsprüfung erzeugt der Compiler lediglich Code der die Zugriffe auf den gültigen Bereich des Arrays prüft. Die Größe des Array ist dabei Teil dieses Codes.

[Deep-Sea]

@Blup:
Ich glaube er wollte nur auf die Gleichheit der eigentlichen Datenbereiche hinaus. Glaube ich

[himitsu]

Delphi-Quellcode:

// für 32 Bit-Delphi (mal sehn, ob die den StringCheckingScheiß jetzt endlich wieder ausbauen)

const
  cDynArrayInfoA   = 2 * SizeOf(LongInt);
  {$IF CompilerVersion >= 20.0}
    cDynArrayInfoS = 3 * SizeOf(LongInt);
  {$ELSE}
    cDynArrayInfoS = cDynArrayInfoA;
  {$IFEND}

type
  TDynArrayInfo = packed Record
    RefCount:     LongInt;
    ElementCount: LongInt;
    Data:         packed Array[0..High(Integer) - cDynArrayInfoA - 1] of Byte;
  End;
  PDynArrayInfo = ^TDynArrayInfo;
  // PInfo := @Var - cDynArrayInfoA;

  TAnsiStringInfo = packed Record
    {$IF CompilerVersion >= 20.0}
      CharSize:   Word;  // könnte auch sein, daß CharSize und Codepage andersrum liegen
      Codepage:   Word;  // (dieser Schrott stammt von dem blöden StringChecking)
    {$IFEND}
    RefCount:     LongInt;
    ElementCount: LongInt;
    Data:         packed Array[1..High(Integer) - cDynArrayInfoS] of AnsiChar;
  End;
  PAnsiStringInfo = ^TAnsiStringInfo;
  // PInfo := @Var - cDynArrayInfoS;

  TUnicodeStringInfo = packed Record
    {$IF CompilerVersion >= 20.0}
      CharSize:   Word;
      Codepage:   Word;
    {$IFEND}
    RefCount:     LongInt;
    ElementCount: LongInt;
    Data:         packed Array[1..(High(Integer) - cDynArrayInfoS) div 2] of WideChar;
  End;
  PUnicodeStringInfo = ^TUnicodeStringInfo;
  // PInfo := @Var - cDynArrayInfoS;

  TDynArrayInfo<TheField> = packed Record
    RefCount:     LongInt;
    ElementCount: LongInt;
    Data:         packed Array[0..(High(Integer) - cDynArrayInfoA) div SizeOf(TheField) - 1] of TheField;
  End;
  TStringInfo<TheChar> = packed Record
    {$IF CompilerVersion >= 20.0}
      CharSize:   Word;
      Codepage:   Word;
    {$IFEND}
    RefCount:     LongInt;
    ElementCount: LongInt;
    Data:         packed Array[1..(High(Integer) - cDynArrayInfoS) div SizeOf(TheChar)] of TheChar;
  End;

Der interne Zeiger zeigt jeweils auf .Data

Delphi-Quellcode:

var
  MyArray = array of irgendwas;

if MyArray <> nil then
  TheLength := PDynArrayInfo(Integer(MyArray) - SDynArrayInfoA).ElementCount
else
  TheLength := 0;

PS: Bei den Strings ist jeweils noch ein abschließendes #0 nach den Stringdaten, für die Kompatibilität und eine direkte Konvertierungsmöglichkeit in einen PChar/PAnsiChar/PWideChar.
Es ist also ein DynArray, mit einem zusätzlichen Feld.


Und wenn man sich nun den "alten" ShortString ansieht,
dann erkennt man, warum Delphi-Strings mit 1 beginnen.

Delphi-Quellcode:

type 
  TShortStringInfo = packed Record
    Len: Byte;
    Chars: packed Array[1..255{1..Len}] of Char;
  End;
  PShortStringInfo = ^TShortStringInfo;
  // PInfo := @Var;