|
Rösta på artikeln
Arraystrukturer
En väldigt användbar datatyp i Delphi är typen array. En variabel
av typen array innehåller en följd av värden. Värdena i följden är alla i sin tur
alla av en viss datatyp. Vi börjar med ett enkelt problem för att visa hur en array
ser ut och hur den används.
Ett exempel på en vektor i formulärtypen
Vi skall här göra ett program där vi kan läsa in tal till en
array. Talen skall vi sedan kunna skriva ut i rättvänd eller omvänd ordning.
-
Placera ut komponenter på formuläret i ett nytt projekt som
bilden visar.
-
Gör sedan följande typdeklaration i interface-delen.
type
TVek = array[1..10] of integer;
//TVek = typetikett för array med plats för 10 tal.
TForm1 = class(TForm);
Label1 : TLabel;
Edit1 : TEdit;
end; |
-
Gör följande deklaration i formulärtypens private-del.
private
{ private declarations }
vek : TVek;
n : byte; // n=antalet lagrade tal i arrayen. |
-
Aktivera formuläret. Dubbelklicka i värderutan för OnActivate
under Events-fliken i objektinspektorn. Skriv följande händelseprocedur.
procedure TForm1.FormActivate(Sender: TObject);
begin
n := 0; //Anger att det inte finns något tal i vektorn
end;
|
-
Dubbelklicka på knappen "Lagra tal". Skriv följande händelseprocedur.
procedure TForm1.Button1Click(Sender: TObject);
var tal : integer;
begin
//Hämta talet från editeringsrutan.
tal := StrToInt(Edit1.Text);
Inc(n); //Peka ut nästa tomma låda i vektorn.
vek[n] := tal; //Lägg in talet i denna låda.
Edit1.Text := '';
Edit1.SetFocus;
end;
|
-
Dubbelklicka på knappen "Rättvänd". Skriv följande händelseprocedur.
procedure TForm1.Button2Click(Sender: TObject);
var
i, p : integer;
s : string;
begin
ListBox1.Clear;
for i := 1 to n do begin
//Översätt värdet i låda i till en sträng
s := IntToStr(vek[i]);
p := ListBox1.Items.Add(s); //Lägg in s i listrutan.
end;
end;
|
-
Dubbelklicka på knappen "Bakvänd". Skriv följande händelseprocedur.
procedure TForm1.Button2Click(Sender: TObject);
var
i, p : integer;
s : string;
begin
ListBox1.Clear;
for i := n downto 1 do begin
//Översätt värdet i låda i till en sträng
s := IntToStr(vek[i]);
p := ListBox1.Items.Add(s); //Lägg in s i listrutan.
end;
end;
|
Arrayvariabeln deklareras i formulärtypens private-del
private
vek : TVek;
med hjälp av typetiketten TVek. Här deklareras vi också
en variabel n, med vars hjälp vi kan hålla reda på hur många tal som lagrats
i vek. Naturligtvis nollställer vi n när programmet startar.
Vi har med deklarationen av vek skaffat oss 10 st variabler,
vek[1], vek[2],...,vek[10]. Alla variablerna är samlade under ett namn, vek, och respektive
variabel har ett nummer som vi anger inom hakparenteser, precis som vi anger numret
på ett speciellt tecken i en strängvariabel.
Observera att alla variabler tillhör samma datatyp, i detta
fallet integer. Numreringen av variablerna startar på 1 och slutar på 10. Variablerna
kallas för arrayelement och ordet array är ett reserverat ord.
Inläsningen av värden till vek görs i händelseproceduuren
för knappen "Lagra tal". Först räknas värdet n upp med 1, varefter talet läggs
in i lådan med detta nummer. Om vi lagt in 5 tal i vek, är ju 6 numret på nästa
tomma låda, där vi skall lägga in det nya talet.
Utskrifter av värdena i rättvänd ordning gör vi i en for-loop,
där vi skriver ut värdet i vek[i] och räknar ner från i till 1. Att åstadkomma
effekten i programmet utan att använda en array skulle vara ganska omständligt. I
exemplet använde vi bara 10 värden, men i situationer med 100-tals (eller 1000-tals)
värden skulle det i praktiken bli omöjligt.
Det går att hitta åtskilliga situationer där en array är en
bekväm lösning till många problem och ofta den enda lösningen. Istället för att låta vek utgöra
en medlem av formulärtypen, hade vi kunnat göra deklarationen direkt i implementationsdelen
på följande sätt.
implementation
{$R *.DFM}
type
TVek = array[1..10] of integer;
var
vek : TVek;
n : byte;
En deklaration av en identifierare på denna plats innebär att
identifieraren är global för hela enheten och kan användas överallt i denna. Dock
så kan endast denna enhet använda identifieraren, dvs. den är ej synlig i andra enheter.
Variabeln vek ovan är ett exempel på en s k endimensionell array.
Man brukar kalla en sådan för vektor eller en lista.
Deklaration av vektor
Några exempel på vektordeklarationer med typen angiven direkt.
var
anna : array[1..20] of char;
{rymmer 20 element of typen char}
namn : array[1..10] of string[8];
{rymmer 10 element of typen string[8]}
htal : array[1..3] of integer;
{rymmer 3 element of typen integer}
rtal : array[-100..100] of real;
{rymmer 201 element of typen real}
frek : array['A'..'E'] of byte;
{rymmer 5 element of typen byte}
|
En variabel är alltid knuten till en eller flera minnesceller,
där det värde som variabeln innehåller lagras. Man kan likna en variabel vid en låda
som innehåller ett värde av en viss typ. En array skulle då kunna liknas vid en stapel
av lådor, en "byrå" med ett visst namn, där varje låda är försedd med ett nummer eller
en beteckning.
Allmän deklaration av en vektor
var vek : array[indexintervall] of elementtyp;
lVek är namnet på vektorn, samlingsnamnet på de variabler, element,
som tillhör vektorn. Indexintervall är ett intervall i någon uppräknelig datatyp,
dvs kan vara ett indexintervall i någon heltalstyp eller i typerna char eller boolean.
Elementtyp kan vara vilken godtycklig datatyp som helst.
Typdeklaration av en vektor
Vektorer är en sammansatt datatyp som normalt först typdeklareras
t ex
type
Tvek = array[1..100] of integer;
innan variabler av denna typ deklareras.
Typen TVek är en beteckning, en etikett, som kan "klistras"
på variabler när dessa deklareras. Den kan här representera en vektor med 100 lådor
som var för sig rymmer ett integervärde. Naturligtvis kan indexintervallet ändras
för att passa på andra etiketter.
Enstaka vektorelement
Tilldelning kan ske genom t ex
vek[7] := 133; //värdet 133 stoppas in i låda nr
7
Likvärdiga vektorer
Om variabeldeklarationen
var a,b : array[1..5] of real;
så går tilldelningen a:= b; utmärkt att genomföra. Om däremot
variabeldeklarationen
var a : array[1..5] of real;
b
: array[1..5] of real;
så kan inte samma tilldelning göras! Vektorerna har deklarerats
var för sig och kompilatorn anser dem därför vara olika.
Har däremot etiketter använts enligt följande
type
Tvek = array[1..5] of real;
var a : TVek;
b : TVek;
så går tilldelningen bra eftersom både a och b deklarerats
med samma etikett.
Flerdimensionella arraystrukturer
Det finns också s k flerdimensionella arraystrukturer som också
kallas för matriser. Ett exempel på en tvådimensionell array utgör rutorna på ett
schackbräde. Raderna på ett schackbräde betecknas med siffrorna 1 till 8, medan kolumnerna
består av en vektor med åtta rutor, element.
Schackbrädet kan alltså sägas bestå av en vektor med åtta kolumnelement,
där varje kolumnelement är en vektor med åtta rutelement. Om vi låter ett rutelement,
dvs en ruta, vara av typen char, kan vi deklarera en variabel brade, som representerar
schackbrädet på följande sätt.
var brade : array['A'..'H'] of
array[1..8] of char;
Detta är en matris (8x8-matris) som innehåller 64 element,
rutor. Varje ruta är av typen char, dvs representeras av ett tecken som vi kan föreställa
oss vara förkortningen för en schackpjäs.
Vi kan förenkla deklarationen genom att skriva
var brade : array['A'..'H',1..8] of char;
En matris behandlas på samma sätt som en vektor. Den enda skillnaden
är att vi måste ange mer än ett index när vi refererar till ett element. Här följer
några exempel för detta.
brade['E',4]
:= 'B'; {flytta vit bonde till E4}
brade['E',5]
:= 'b'; {flytta svart bonde till E5}
brade['F',3]
:= 'S'; {flytta vit springare till F3}
I exemplet med schackbrädet är varje element av datatypen char.
Varje element kan naturligtvis vara av vilken datatyp som helst, t o m en ny vektor.
Man kan deklarera en tredimensionell array på följande sätt.
var kub : array[1..6,1..6,1..6] of integer;
Denna matris innehåller 6x6x6 = 216 heltalsvariabler. Vi kan
tolka denna matris som ett antal punkter i rymden, där varje punkt har ett heltalsvärde.
Matriser av godtycklig dimension deklareras på liknande sätt.
|