Array: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		An array is a linear data structure concept that groups elements of the same type, stores them in contiguous and adjacent memory locations and provides random access to all of said elements (also known as components) by way of a linear index.
2	2
3	3		The word `array` is a [[Reserved word\|reserved word]]. It always occurs in conjunction with the word [[Of\|`of`]].
4	4
5	5		## Notion
6	6
7	7		An `array` is a limited and arranged aggregation of elements, all having the same [[Data type\|data type]] which is called the “base type.” It has at least one discrete, bounded dimension and continuously enumerates all of its elements. Each element can be uniquely identified by one or more scalar values, called _indices_ , along those dimensions.
8	8
9	9		A one-dimensional `array` resembles an n-tuple , as it is known in mathematics, but has the constraint of being homogenous (all elements must be of the same type). The range of all possible values such an `array` can acquire is the homogenous n-ary Cartesian product of the base type.
10	10
11	11		A two-dimensional `array` resembles the mathematical concept of a matrix , except for the homogeneity restriction.
12	12
13	13		## Usage
14	14
15	15		### Length
16	16
17	17		Originally, Pascal only provided arrays of fixed length ([[Standard Pascal]]), meaning the number of elements an array consisted of had to be known at compile-time. Since this turned out to be a major constraint, and changes in computer hardware since then justified a step forward, variable-length arrays were introduced.
18	18
19	19		[[Extended Pascal]] defined the notion of “schemata” for this. [[Delphi]] introduced “dynamic arrays”. As of 2020, [[FPC]] only supports the latter regarding variable-length arrays, while support for “schemata” is planned.
20	20
21	21		Depending on whether an array is intended of being capable of changing its size, its definition varies, but just marginally. For a one-dimensional static array, the type definition looks like this:
22	22		```
23	23		array[indexType] of baseType
24	24		```
25	25
26	26		A dynamic array type definition is simply relieved of its dimension specification:
27	27		```
28	28		array of baseType
29	29		```
30	30
31	31		### Static arrays
32	32
33	33		In static arrays, the ranges of all dimensions are known in advance. All dimension specifications have to be ordinal types. The following code shows some valid array definitions, all of them static.
34	34		```
35	35		program staticArrayDemo(input, output, stderr);
36	36
37	37		type
38	38		// specifying ordinal types as index directly
39	39
40	40		/// allows selection of a character
41	41		/// based on a Boolean value
42	42		characterChoice = array[boolean] of UCS4char;
43	43
44	44		// enumerations
45	45
46	46		/// enumerates Cartesian axes
47	47		spaceAxis = (xAxis, yAxis, zAxis);
48	48		/// a point in three-dimensional Euclidean space
49	49		locus = array[spaceAxis] of valReal;
50	50		/// a point in a two-dimensional Euclidean plane
51	51		point = array[xAxis..yAxis] of valReal;
52	52
53	53		// integer subranges
54	54
55	55		level = array[-24..24] of longint;
56	56		box = array[-1..1, -1..1, -1..1] of boolean;
57	57		transformationMatrix = array[0..1, 0..1] of valReal;
58	58		begin
59	59		end.
60	60		```
61	61
62	62		As all of an array’s elements have to be addressable, there exists a maximum limit of elements an array can hold. The [[SizeOf\|`sizeOf`]] every array type has to be less than [`ptrInt`](<https://www.freepascal.org/docs-html/rtl/system/ptrint.html>)’s maximum value.
63	63
64	64		### Initialization
65	65
66	66		It's possible to set the initial values of a static (and dynamic) array's elements when it is declared –
67	67		```
68	68		var
69	69		SArray : array[0..2] of integer = (1,2,3); // A static Array
70	70		CArray : array[0..1] of TColor = (clRed, clBlue); // A static Array
71	71		```
72	72
73	73		See more: [Topic: How to initialize the array (Free Pascal Lazarus Forum)](<https://forum.lazarus.freepascal.org/index.php/topic,52656.0.html>)
74	74
75	75		### Addressing elements
76	76
77	77		An array’s element is addressed by naming the array variable’s identifier, followed by a valid index value enclosed by square brackets.
78	78		```
79	79		program arrayAddressDemo(input, output, stderr);
80	80		var
81	81		msg: array[0..2] of char;
82	82		begin
83	83		msg[0] := 'H';
84	84		msg[1] := 'i';
85	85		msg[2] := '!';
86	86		writeLn(msg);
87	87		end.
88	88		```
89	89
90	90		Multidimensional arrays’ elements can be addressed in two ways: either by [[Comma\|comma]]-separated indices…
91	91		```
92	92		arrayVariable[firstDimensionIndex, secondDimensionIndex, thirdDimensionIndex]
93	93		```
94	94
95	95		…or by putting indices in dedicated square brackets.
96	96		```
97	97		arrayVariable[firstDimensionIndex][secondDimensionIndex][thirdDimensionIndex]
98	98		```
99	99
100	100		A third syntactically-valid option would be mixing both styles, however that is considered poor style, unless perhaps there is indication to group indices (e.g. `x`, `y` and `z` coordinates versus other indices) it is okay. Nonetheless, only the first mentioned notation is valid while defining array types.
101	101
102	102		Note, it is very important to specify indices in the defined order, within each dimensions’ range. Consider the following program; it will compile, but fail during [[runtime\|run-time]] due to `{$rangeChecks on}`:
103	103		```
104	104		program arrayAddressOrderDemo(input, output, stderr);
105	105		{$rangeChecks on}
106	106		var
107	107		i: integer;
108	108		f: array[0..1, 0..3] of boolean;
109	109		begin
110	110		for i := 0 to 7 do
111	111		begin
112	112		f[0, i] := true;
113	113		end;
114	114		end.
115	115		```
116	116
117	117		While the program would indeed iterate over every array’s elements, it doesn’t do so in the intended way, but rather exploits the fact that the array’s internal memory structure is just a continuous block of memory. This is bad style. A programmer working with a high-level language is not supposed to care about specific memory layouts. Cave: It is possible to tamper with other variables in this way. At any rate, a [[runtime error\|run-time error]], namely “RTE 216 general protection fault,” will occur if an attempt is made to access memory which is not within the purview of the process owner.
118	118
119	119		When values contained in arrays are merely read (and thus the indices do not matter), a [[for-in loop\|`for … in` loop]] can be used.
120	120
121	121		## Dynamic arrays
122	122
123	123		A [[Dynamic array\|dynamic array]] is an approach for overcoming the limitation of knowing the sizes of all dimensions in advance. See its dedicated page for more details.
124	124
125	125		## Application
126	126
127	127		See, for instance:
128	128
129	129		* [[Array sort]]
130	130		* [[15-puzzle]]’s and [[Peg Solitaire tutorial\|Peg]]’s game board states are stored as an array.
131	131
132	132		In the default [[RTL]]’s system unit, the function [`system.slice`](<https://www.freepascal.org/docs-html/rtl/system/slice.html>) returns the initial part of an array, similar to the Ruby notation `arrayVariable[0, n]`. Furthermore, there is [`system.arrayStringToPPchar`](<https://www.freepascal.org/docs-html/rtl/system/arraystringtoppchar.html>). Most [[Functions for descriptive statistics\|statistical routines of the RTL’s math unit]] accept arrays as parameters, as well as some other routines.
133	133
134	134		## See also
135	135
136	136		* [[Type information]]
137	137		* [[Defensive programming techniques]]
138	138		* [[Vectorization]]
139	139		* [[Flexible Array Member]]
140	140		* Tutorial: [[Basic Pascal Tutorial/Chapter 5/1-dimensional arrays\|1-dimensional arrays]]
141	141		* Tutorial: [[Basic Pascal Tutorial/Chapter 5/Multidimensional arrays\|Multidimensional arrays]]
142	142		* Example: [[Example: Multidimensional dynamic array\|Multidimensional dynamic array]]
143	143		* Article: [[Why Pascal is Not My Favorite Programming Language\|Why Pascal is not my favorite programming language § “The size of an array is part of its type”]]
144	144		* [`matrix` unit](<https://www.freepascal.org/docs-html/rtl/matrix/index.html>)
145	145
146	146
147	147
148		-	navigation bar: data types [[simple type\|simple data types]] \| [[Boolean\|`boolean`]] [[Byte\|`byte`]] [[Cardinal\|`cardinal`]] [[Char\|`char`]] [[Currency\|`currency`]] [[Double\|`double`]] [`dword`](</index.php?title=DWord&action=edit&redlink=1> "DWord $page does not exist$") [[Extended\|`extended`]] [[Int8\|`int8`]] [[Int16\|`int16`]] [[Int32\|`int32`]] [[Int64\|`int64`]] [[Integer\|`integer`]] [[Longint\|`longint`]] [[Real\|`real`]] [[Shortint\|`shortint`]] [[Single\|`single`]] [[Smallint\|`smallint`]] [[Pointer\|`pointer`]] [[QWord\|`qword`]] [[Word\|`word`]]
149		-	~~---\|---~~
150		-	~~complex data types \| `array` [[Class\|`class`]] [[Object\|`object`]] [[Record\|`record`]] [[Set\|`set`]] [[String\|`string`]] [[Shortstring\|`shortstring`]]~~
151		-
152		-
153		-
154		-	~~****~~
	148	+	navigation bar: data types
	149	+
	150	+	_[[simple type\|simple data types]]:_ [[Boolean\|`boolean`]] [[Byte\|`byte`]] [[Cardinal\|`cardinal`]] [[Char\|`char`]] [[Currency\|`currency`]] [[Double\|`double`]] [[DWord\|`dword`]] [[Extended\|`extended`]] [[Int8\|`int8`]] [[Int16\|`int16`]] [[Int32\|`int32`]] [[Int64\|`int64`]] [[Integer\|`integer`]] [[Longint\|`longint`]] [[Real\|`real`]] [[Shortint\|`shortint`]] [[Single\|`single`]] [[Smallint\|`smallint`]] [[Pointer\|`pointer`]] [[QWord\|`qword`]] [[Word\|`word`]]
	151	+
	152	+	_complex data types:_ `array` [[Class\|`class`]] [[Object\|`object`]] [[Record\|`record`]] [[Set\|`set`]] [[String\|`string`]] [[Shortstring\|`shortstring`]]
155	153
156	154		---
157	155		From the Free Pascal wiki, page "Array", as the Internet Archive kept it on 2026-01-21, last changed on 2024-11-03. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history