Förord

Denna artikel beskriver och demonstrerar användning av arraystrukturer - vektorer och matriser. 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.

Innehåll

  » Ett exempel på en vektor i formulärtypen
  » Deklaration av vektor
  » Allmän deklaration av en vektor
  » Typdeklaration av en vektor
  » Enstaka vektorelement
  » Likvärdiga vektorer
  » Flerdimensionella arraystrukturer

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.

0 Kommentarer

Skriv en kommentar på artikeln

Ditt betyg på artikeln

UtmärktLäsvärdIntressantMindre braDålig

Kommentar: