Met arrays kunnen we verwijzen naar een reeks variabelen met dezelfde naam en een nummer (een index) gebruiken om individuele elementen in die reeks op te roepen. Arrays hebben zowel boven- als ondergrenzen en de elementen van de array zijn aaneengesloten binnen die grenzen.
Elementen van de array zijn waarden die allemaal van hetzelfde type zijn (string, geheel getal, record, aangepast object).
In Delphi zijn er twee soorten arrays: een array met vaste grootte die altijd dezelfde grootte behoudt - een statische array - en een dynamische array waarvan de grootte tijdens runtime kan veranderen.
Statische arrays
Stel dat we een programma schrijven waarmee een gebruiker aan het begin van elke dag een aantal waarden kan invoeren (bijvoorbeeld het aantal afspraken). We zouden ervoor kiezen om de informatie in een lijst op te slaan. We zouden deze lijst kunnen noemen Afspraken, en elk nummer kan worden opgeslagen als Afspraken [1], Afspraken [2], enzovoort.
Om de lijst te gebruiken, moeten we deze eerst verklaren. Bijvoorbeeld:
var Afspraken: array [0..6] van Integer;
declareert een variabele met de naam Afspraken die een eendimensionale matrix (vector) van 7 gehele getallen bevat. Gezien deze verklaring duidt Afspraken [3] de vierde gehele waarde aan in Afspraken. Het nummer tussen de haakjes wordt de index genoemd.
Als we een statische array maar wijs geen waarden toe aan al zijn elementen, de ongebruikte elementen bevatten willekeurige gegevens; ze zijn als niet-geïnitialiseerde variabelen. De volgende code kan worden gebruikt om alle elementen in de Afspraken-array in te stellen op 0.
voor k: = 0 tot 6 doen afspraken [k]: = 0;
Soms moeten we gerelateerde informatie in een array bijhouden. Als u bijvoorbeeld elke pixel op uw computerscherm wilt bijhouden, moet u de X- en Y-coördinaten ervan raadplegen met a multidimensionaal array om de waarden op te slaan.
Met Delphi kunnen we arrays van meerdere dimensies declareren. Met de volgende instructie wordt bijvoorbeeld een tweedimensionale matrix van 7 bij 24 verklaard:
var DayHour: array [1..7, 1..24] van Real;
Om het aantal elementen in een multidimensionale array te berekenen, vermenigvuldigt u het aantal elementen in elke index. De DayHour-variabele, hierboven aangegeven, zet 168 (7 * 24) elementen opzij, in 7 rijen en 24 kolommen. Om de waarde uit de cel in de derde rij en zevende kolom op te halen, gebruiken we: DayHour [3,7] of DayHour [3] [7]. De volgende code kan worden gebruikt om alle elementen in de DayHour-array in te stellen op 0.
voor i: = 1 tot 7 doen
voor j: = 1 tot 24 doen
Daguur [i, j]: = 0;
Dynamische arrays
Mogelijk weet u niet precies hoe groot u een array moet maken. Misschien wilt u de mogelijkheid hebben het wijzigen van de grootte van de array tijdens runtime. Een dynamische array verklaart het type, maar niet de grootte. De werkelijke grootte van een dynamische array kan tijdens runtime worden gewijzigd met behulp van de Lengte instellen procedure.
var Students: array van tekenreeksen;
creëert een eendimensionale dynamische reeks strings. De verklaring wijst geen geheugen toe voor studenten. Om de array in het geheugen te maken, noemen we de SetLength-procedure. Gezien de bovenstaande verklaring,
SetLength (studenten, 14);
wijst een reeks van 14 strings toe, geïndexeerd van 0 tot 13. Dynamische arrays zijn altijd geheel geïndexeerd, altijd beginnend bij 0 tot één kleiner dan hun grootte in elementen.
Gebruik de volgende code om een tweedimensionale dynamische array te maken:
var Matrix: array van array van Double;
beginnen
Lengte instellen (Matrix, 10, 20)
einde;
die ruimte toewijst voor een tweedimensionale reeks van 10 bij 20 dubbele drijvende-kommawaarden.
Om de geheugenruimte van een dynamische array te verwijderen, wijst u nul toe aan de arrayvariabele, zoals:
Matrix: = nihil;
Heel vaak weet uw programma tijdens het compileren niet hoeveel elementen er nodig zijn; dat aantal is pas bekend tijdens runtime. Met dynamische arrays kunt u slechts zoveel opslagruimte toewijzen als op een bepaald moment nodig is. Met andere woorden, de grootte van dynamische arrays kan tijdens runtime worden gewijzigd, wat een van de belangrijkste voordelen van dynamische arrays is.
In het volgende voorbeeld wordt een array met gehele waarden gemaakt en wordt vervolgens de functie Kopiëren aangeroepen om de grootte van de array te wijzigen.
var
Vector: array van Integer;
k: geheel getal;
beginnen
SetLength (Vector, 10);
voor k: = Laag (Vector) tot Hoog (Vector) doen
Vector [k]: = i * 10;
...
// nu hebben we meer ruimte nodig
SetLength (Vector, 20);
// hier kan de Vector array maximaal 20 elementen bevatten // (het heeft er al 10) end;
De SetLength-functie maakt een grotere (of kleinere) array en kopieert de bestaande waarden naar de nieuwe array. De functies Laag en Hoog zorgen ervoor dat u toegang heeft tot elk arrayelement zonder in uw code terug te kijken naar de juiste lagere en bovenste indexwaarden.