Zusatzinfo: Statische und Dynamische Arrays

Statische und dynamische Arrays
Als Array werden durchnummerierte Gruppierungen von Daten gleichen Typs bezeichnet.
Man kann sich ein Array als einen Schubladenschrank mit Schubladen gleicher Größe und
gleichen Aufbaus vorstellen, die durch eine Nummer, den INDEX, bezeichnet werden. Das
Array zahlen: array[1..10] of integer wäre somit als Schubladenschrank denkbar, dessen
Schubladen alle genau genug Platz für einen Integerwert (4 byte) haben und von 1 bis 10
durchnummeriert sind. Will ich nun auf den Inhalt des dritten Feldes lesend oder schreibend
zugreifen, geschieht das durch Aufruf des Arraynamens und des Indexes (der Nummer der
Schublade):
Lesen: x:=zahlen[3]; Schreiben: zahlen[3]:=x;
Somit kann ich mittels Schleifen auf alle Felder eines Array lesend oder schreibend zugreifen:
Lesen: for i:=1 to 10 do
Schreiben: for i:= 1 to 10 do
x:=zahlen[i];
zahlen[i]:=x;
Die Anzahl der Stellen eines Arrays gibt die Funktion length(Arrayname) zurück.
length(zahlen) wäre also 10,
Den höchsten Index eines Arrays gibt die Funktion high(Arrayname) zurück. In unserem
Beispiel wäre high(zahlen) ebenfalls 10.
Den niedrigsten Index gibt die Funktion low(Arrayname) zurück. Also wäre low(zahlen) im
Beispiel 1.
Kurz-Exkurs Speichertypen
Der Stack (englisch für Stapel) ist ein geordneter Teil des Speicherbereichs einer
Prozedur, in dem z.B. vordefinierte Variablen abgelegt werden. Das Betriebssystem nutzt
diesen Bereich um Prozesse innerhalb einer Prozedur (sogenannte THREADS)
zwischenzuspeichern (z.B. bei rekursiven Abläufen). Er ist in seiner Größe stark begrenzt,
aber durch die Strukturierung ist der Zugriff auf darin liegende Elemente einfach und
schnell.
Der Heap (englisch für Haufen) ist ein unsortierter aber riesiger (so groß wie der gesamte
verbleibende Arbeitspeicher) Teil des Speicherbereichs einer Prozedur, der nicht als
Zwischenspeicher für Programmabläufe (Threads) oder als Variablenspeicher benutzt
wird. Durch seine offene Struktur ist der Zugriff auf Elemente darin schwieriger und
theoretisch etwas langsamer als auf Elemente im Stack.
Statische Arrays
Sie werden über die Angabe des ersten und letzten Index definiert, entweder als globale
Variable oder innerhalb einer Prozedur, z.B.
namen:array[1..30] of string; oder namen:array [20..49] of string;
Dabei können die Indizes beliebig definiert werden, so ist im zweiten Beispiel der Index des
ersten Feldes im Array die 20: namen[20]:=‘Horst‘; low(namen) wäre 20, high(namen) 49.
length(namen) ergibt in beiden Fällen 30.
Ihre Anwendung ist nur dort sinnvoll, wo im Vorfeld bekannt ist, wie viele Elemente im
Array gespeichert werden müssen und genügend Speicherpatz hierfür zur Verfügung steht.
Denn es ist zu bedenken, dass statische Arrays im Stack des Arbeitsspeichers abgelegt
werden, d.h. in einem zwar geordneten aber relativ kleinen und vom Betriebssystem viel
genutzten Teil des Speichers. Hier können große Arrays schnell zu einer Belastung des
gesamten Programmes werden, da sie den Stack erheblich belasten können (Stack-Überlauf).
Dynamische Arrays
Sie werden ohne Indexangaben definiert, denn ihre Länge wird während der Laufzeit des
Programmes festgelegt oder verändert.
namen: array of string;
Somit ist ihre Anwendung überall da sinnvoll, wo noch nicht im Vorfeld bekannt ist, wie viele
Daten aufgenommen werden müssen. Ihr größter Vorteil liegt aber in der
Speicherverwendung: Bei dynamischen Array wird nur die Adresse der eigentlichen Daten
(bzw. des ersten Elementes der Daten-Liste) im Stack abgelegt und belastet diesen mit 4 byte
kaum. Unabhängig von enthaltenem Datentyp und der Größe des Arrays bleibt es stets nur bei
diesen 4 byte Stackspeicher. Man sagt: Es wird nur ein ZEIGER auf die eigentlichen Daten
im Stack abgelegt (gemeint ist dabei ein Verweis auf die eigentlichen Daten, die im Heap
liegen, also deren Adresse). Dadurch belasten sie den Programmablauf kaum.
Allerdings muss vor dem ersten Lese-oder Schreibzugriff die Länge des Arrays definiert
werden. Dies geschieht durch die Prozedur setlength(Arrayname,Länge). Um 30 Namen zu
speichern, müssen also zunächst die nötigen Speicherstellen geschaffen werden, also:
setlength(namen,30);
Nun kann lesend oder schreibend zugegriffen werden, z.B:
namen[10]:=‘Heinz‘; s:=namen[10];
Allerdings sind die Indizes eines dynamischen Arrays NICHT frei wählbar. Der erste Index
ist IMMER die 0, der letzte ist length(array)-1 oder schlicht high(array). In unserem Array
wäre also low(zahlen) 0 und high(zahlen) 29. length(namen) liefert den Wert 30.
Um allgemein auf alle Felder eines dynamischen Arrays zugreifen zu können empfiehlt sich
die Variante for i:=0 to high(zahlen) do
zahlen[i]:=0;
Denn der erste Index ist immer 0, der letzte entspricht –bei beliebiger Länge- immer
high(Array).
Soll ein dynamisches Array eine unbekannte Anzahl von Werten (hier:Namen) aufnehmen,
kann die Länge auch bei Bedarf um gerade das eine benötigte zusätzliche Feld erhöht werden:
while namen<>‘‘ do // solange noch Namen dazu kommen (z.B. aus einer File)
begin
setlength(namen, length(namen)+1); // Erhöhen der Länge um 1
namen[high(namen)]:=namen; // Speichern des neuen Namens in der neuen Stelle,
end;
// die logischerweise den höchsten Index hat