Dynamic array/fi

From Free Pascal wiki

English (en) suomi (fi) français (fr) 日本語 (ja) русский (ru)

Dynaaminen taulukko

Dynaaminen taulukko on taulukko, jonka mittoja ei tunneta käännösaikana. Dynaaminen taulukko-tyyppi ei ole ainoa sellainen tyyppi, joka tarjoaa vaihtelevan pituisen taulukon, mutta (vuonna 2018) se on ainoa mitä Free Pascal-tukee.

Käyttö

Käsite

Dynaaminen taulukon määritys varaa tilaa vain osoittimelle. Ajon aikana eri rutiinit varmistavat sen kätevän käytön, mutta tärkeintä on, että kääntäjä tukee matriisin elementtien pääsyä sijoittamalla indeksit hakasulkeisiin (toteutetaan osoittimen automaattisena viittauksena).

Dynaamisen taulukon indeksit ovat aina ei-negatiivisia kokonaislukuja, jotka alkavat nollasta joka vastaa ensimmäistä elementtiä. Lueteltua tyyppiä, muuta ordinaalityyppiä ei voida käyttää indeksinä tai muuttaa ensimmäistä elementtiä, joka on määritetty indeksillä 1.

määritelmä

Yksiulotteinen dynaaminen taulukko on määritellään seuraavasti:

array of char

Huomaa, miten taulukon kokoa ei ole määritetty.

Moniulotteisen taulukon määrittelemiseksi, perustyypiksi määritetään itse taulukko.

array of array of longInt

Mitoitus

Kääntäjän aliohjelma setLength muuttaa dynaamisen taulukon pituutta edellyttäen, että muistia on riittävästi.

1 program setLengthDemo(input, output, stdErr);
2 var
3 	sieve: array of longWord;
4 begin
5 	setLength(sieve, 1337);
6 end.

Aliohjelma varaa muistia annetun määrän mukaisesti kyseisen tyypin tietueelle ja myös joillekin hallintatiedoille. Sitten se kopioi kaikki vanhan inkarnaation elementit uuteen.

Myös moniulotteiset taulukot voidaan muuttaa setLength aliohjelmalla.

1 program multidimensionalSetLengthDemo(input, output, stdErr);
2 var
3 	samples: array of array of smallInt;
4 begin
5 	setLength(samples, 12, 64);
6 end.

Taulukon samples ensimmäisen ulottuvuuden todelliset indeksit ovat 0..11 kun taas toisen ulottuvuuden kelvolliset indeksit ovat alueella 0..63.

Yksi varsin hyödyllinen tosiasia on, että rajoituksen, jonka mukaan kaikkien ulottuvuuksien on oltava samankokoisia, ei sovelleta dynaamisiin taulukoihin.

 1 program binomialPotence(input, output, stdErr);
 2 var
 3 	pascalsTriangle: array of array of longWord;
 4 	exponent: longInt;
 5 	factor: longInt;
 6 begin
 7 	setLength(pascalsTriangle, 20);
 8 	
 9 	setLength(pascalsTriangle[0], 1);
10 	pascalsTriangle[0][0] := 1;
11 	
12 	setLength(pascalsTriangle[1], 2);
13 	pascalsTriangle[1][0] := 1;
14 	pascalsTriangle[1][1] := 1;
15 	
16 	// construct values by simple addition
17 	for exponent := 2 to high(pascalsTriangle) do
18 	begin
19 		setLength(pascalsTriangle[exponent], exponent + 1);
20 		pascalsTriangle[exponent][0] := 1;
21 		pascalsTriangle[exponent][exponent] := 1;
22 		for factor := 1 to exponent - 1 do
23 		begin
24 			pascalsTriangle[exponent][factor] :=
25 				pascalsTriangle[exponent - 1][factor - 1] +
26 				pascalsTriangle[exponent - 1][factor];
27 		end;
28 	end;
29 	
30 	// ...

Alustus

FPC:n versiosta 3.0.0 lähtien dynaaminen taulukko, jotka eivät ole anonymous, varustetaan automaattisesti “constructor” (rakentajalla), koska se on tuttua olio-ohjelmoinnista. Tämän avulla voit yhdistää setLength-kutsu ja joukon toimeksiantoja yhteen lausekkeeseen:

1 program dynamicArrayCreateDemo(input, output, stdErr);
2 type
3 	truths = array of boolean;
4 var
5 	l: truths;
6 begin
7 	l := truths.create(false, true, true, false, true, false, false);
8 end.

Voidaan tietysti käyttä myös sisäkkäisiä taulukoita:

 1 program nestedDynamicArrayCreateDemo(input, output, stdErr);
 2 type
 3 	truths = array of boolean;
 4 	pattern = array of truths;
 5 var
 6 	p: pattern;
 7 begin
 8 	p := pattern.create(
 9 			truths.create(false, false),
10 			truths.create(true, false),
11 			truths.create(true, false, false),
12 			truths.create(true, true, false)
13 		);
14 end.

Käsittely

Pitää pitää mielessä että dynaamiset taulukot ovat viitteitä. Dynaamisten taulukkomuuttujien "suora kopiointi" toisilleen ei kopioi mitään hyötykuormaa, vaan vain osoiteen. Tämä eroaa staattisten taulukkojen käyttäytymisestä.

Jos halutaan kopioida tietoja, niin on käytettävä system.copy.-tiedostoa.

 1 program dynamicArrayCopyDemo(input, output, stdErr);
 2 
 3 var
 4 	foo, bar: array of char;
 5 
 6 procedure printArrays;
 7 begin
 8 	writeLn('foo[0] = ', foo[0], '; bar[0] = ', bar[0]);
 9 end;
10 
11 begin
12 	setLength(foo, 1);
13 	foo[0] := 'X';
14 	// copies _reference_
15 	bar := foo;
16 	write('     initial values: ');
17 	printArrays;
18 	
19 	// change content _via_ _second_ reference
20 	bar[0] := 'O';
21 	write('changed via 2nd ref: ');
22 	printArrays;
23 	
24 	// copy content
25 	bar := copy(foo, 0, length(foo));
26 	bar[0] := 'X';
27 	write(' copied and changed: ');
28 	printArrays;
29 end.

Vain käyttämällä copy kopiointia molempia taulukoita voidaan muokata itsenäisesti.

Kuten edellä todettiin niin tässä setLength kopioi tiedot. Yllä olevan esimerkin korostettu rivi vastaa (semanttisesti) setLength(bar, length(bar)).

Dynaamisella taulukolla on "viitelaskuri". Kutsuminen setLength(myDynamicArrayVariable, 0) on käytännössä myDynamicArrayVariable := nil ja pienentää viitemäärää. Ainoastaan kun viitteiden määrä laskee nollaan, muistilohko vapautetaan.

 1 program dynamicArrayNilDemo(input, output, stdErr);
 2 var
 3 	foo, bar: array of char;
 4 begin
 5 	setLength(foo, 1);
 6 	foo[0] := 'X';
 7 	// copy _reference_, increase reference count
 8 	bar := foo;
 9 	// foo becomes nil, reference count is decreased
10 	setLength(foo, 0);
11 	writeLn('length(foo) = ', length(foo),
12 		'; length(bar) = ', length(bar));
13 	
14 	// decrease reference count another time
15 	bar := nil;
16 	writeLn('length(foo) = ', length(foo),
17 		'; length(bar) = ', length(bar));
18 end.

Dynaamiset taulukot kuitenkin loppukäsitellään automaattisesti. Ei tarvitse asettaa manuaalisesti kaikkiin viitteisiin setLength(, 0), kun ohjelma päättyy tai kun siirrytään osiosta pois.

Ilman {$rangeChecks on} on mahdollista saavuttaa taulukon rajat. Tämä tarkoittaa, että kun iteroidaan dynaamisia taulukkoja, on mahdotonta työskennellä ilman low ja high määrittämään kelvollisia indeksejä (ensimmäinen on valinnainen, koska dynaamiset taulukot alkavat aina nollasta). Vaihtoehtoisesti voidaan käyttää for in looppia silmukoissa, jos indeksiä ei tarvita.

Muista, että sizeOf arvioi dynaamisen taulukon osoittimen koon.

Sovellukset

Katso myös