Array

Belongs to : Keyword

Description

The Array keyword provides single and multi dimensional arrays (indexable sequences) of data.

Delphi has three basic array types :

1.Static arrays

These are defined with fixed, unchangeable sizes. They may be single or multidimensional – the latter being an array of arrays (of arrays etc). The size and range of such a multidimensional array is always given for the highest, leftmost array – the parent array.

The size of each dimension is determined in two ways, which may be freely mixed in a multidimensional array :

Index type Where Index is an integer type, normally Byte or Word. The range of this type defines the dimension range. For example, a Byte gives a 0..255 range.

Ordinal..Ordinal Alternatively, the range of each dimension may be given by direct ordinal values, such as 22..44.

2.Dynamic arrays

Dynamic arrays have no preallocated storage. When defined, only a pointer is created. Such arrays must have their length set before they can be used. For example :

SetLength(dynArray, 5);

sets the dynArray single dimension array size to 5 elements. This allocates storage.

All dynamic arrays starts at index = 0.

Individual subarrays of a multidimensional dynamic array may have different sized dimensions – they are, of course, separate arrays. After one such SetLength operation, elements of the set array may be referenced, even though the rest of the array is undefined.

3.Open arrays

Both static and dynamic arrays may be passed to subroutines as parameters. If the array parameter definition has no range (ie, a dynamic array type), then you must, paradoxically pass a static array as a parameter. Such an array is referred to as an Open array. Delphi passes the length as a hidden parameter to the subroutine.

An open array may also be defined with const value type. This is called a Variant open array – it is mostly used to allow a variable number of argument value to be passed to a subroutine.

In order to pass a Dynamic array by reference, the array and the subroutine definition of the array must be via an array type definition. See the code for an example.

Notes
Use Copy to copy one array to another. But be warned - it only copies the first, highest array dimension - the new array will still refer to elements of the subarrays.

Example code

Static Array

var
  // Define static arrays
  wordArray  : Array[Word] of Integer;     // Static, size=High(Word)
  multiArray : Array[Byte, 1..5] of char;  // Static array, 2 dimensions
  rangeArray : Array[5..20] of string;     // Static array, size = 16

  i : Integer;

begin
  // Show the sizes and ranges of these arrays
  ShowMessage('wordArray length = '+IntToStr(Length(wordArray)));
  ShowMessage('wordArray lowest element = '+IntToStr(Low(wordArray)));
  ShowMessage('wordArray highest element = '+IntToStr(High(wordArray)));
  ShowMessage('multiArray length = '+IntToStr(Length(multiArray)));
  ShowMessage('multiArray lowest element = '+IntToStr(Low(multiArray)));
  ShowMessage('multiArray highest element = '+IntToStr(High(multiArray)));
  ShowMessage('rangeArray length = '+IntToStr(Length(rangeArray)));
  ShowMessage('rangeArray lowest element = '+IntToStr(Low(rangeArray)));
  ShowMessage('rangeArray highest element = '+IntToStr(High(rangeArray)));
  ShowMessage('');

  // The full range of a static array are available before assignment,
  // but the values will be unpredictable
  ShowMessage('wordArray Element 7 = '+IntToStr(wordArray[7]));
  ShowMessage('wordArray Element 20 = '+IntToStr(wordArray[20]));

  // Use indexing to furnish an array
  for i := 5 to 20 do
    rangeArray[i] := IntToStr(i * 5);

  // Now use indexing to display 2 of the elements
  ShowMessage('rangeArray element 7 = '+rangeArray[7]);
  ShowMessage('rangeArray element 20 = '+rangeArray[20]);
end;
{
   wordArray length = 65536
   wordArray lowest element = 0
   wordArray highest element = 65535
   multiArray length = 256
   multiArray lowest element = 0
   multiArray highest element = 255
   rangeArray length = 16
   rangeArray lowest element = 5
   rangeArray highest element = 20
  
   wordArray element 7 = 0
   wordArray element 20 = 0
   rangeArray element 7 = 35
   rangeArray element 20 = 100
}

var

// Define static arrays

wordArray : Array[Word] of Integer; // Static, size=High(Word)

multiArray : Array[Byte, 1..5] of char; // Static array, 2 dimensions

rangeArray : Array[5..20] of string; // Static array, size = 16

i : Integer;

begin

// Show the sizes and ranges of these arrays

ShowMessage('wordArray length = '+IntToStr(Length(wordArray)));

ShowMessage('wordArray lowest element = '+IntToStr(Low(wordArray)));

ShowMessage('wordArray highest element = '+IntToStr(High(wordArray)));

ShowMessage('multiArray length = '+IntToStr(Length(multiArray)));

ShowMessage('multiArray lowest element = '+IntToStr(Low(multiArray)));

ShowMessage('multiArray highest element = '+IntToStr(High(multiArray)));

ShowMessage('rangeArray length = '+IntToStr(Length(rangeArray)));

ShowMessage('rangeArray lowest element = '+IntToStr(Low(rangeArray)));

ShowMessage('rangeArray highest element = '+IntToStr(High(rangeArray)));

ShowMessage('');

// The full range of a static array are available before assignment,

// but the values will be unpredictable

ShowMessage('wordArray Element 7 = '+IntToStr(wordArray[7]));

ShowMessage('wordArray Element 20 = '+IntToStr(wordArray[20]));

// Use indexing to furnish an array

for i := 5 to 20 do

rangeArray[i] := IntToStr(i * 5);

// Now use indexing to display 2 of the elements

ShowMessage('rangeArray element 7 = '+rangeArray[7]);

ShowMessage('rangeArray element 20 = '+rangeArray[20]);

end;

{

wordArray length = 65536

wordArray lowest element = 0

wordArray highest element = 65535

multiArray length = 256

multiArray lowest element = 0

multiArray highest element = 255

rangeArray length = 16

rangeArray lowest element = 5

rangeArray highest element = 20

wordArray element 7 = 0

wordArray element 20 = 0

rangeArray element 7 = 35

rangeArray element 20 = 100

}

Dynamic Arrays

var
  // Define dynamic arrays
  byteArray  : Array of Byte;           // Single dimension array
  multiArray : Array of Array of string;  // Multi-dimension array

  i,j : Integer;

begin
  // Set the length of the single dimension array
  SetLength(byteArray, 5);

  // Show the size and range of this array
  ShowMessage('byteArray length = '+IntToStr(Length(byteArray)));
  ShowMessage('byteArray lowest element = '+IntToStr(Low(byteArray)));
  ShowMessage('byteArray highest element = '+IntToStr(High(byteArray)));

  // Furnish this array - remember that dynamic arrays start at 0
  for i := 0 to 4 do
    byteArray[i] := i * 5;

  // Show selected elements from the array
  ShowMessage('byteArray element 2 = '+IntToStr(byteArray[2]));
  ShowMessage('byteArray element 4 = '+IntToStr(byteArray[4]));

  // Set the length of the 1st dimension of the multi-dim array
  SetLength(multiArray, 3);

  // Set the length of the 3 sub-arrays to different sizes
  SetLength(multiArray[0], 1);
  SetLength(multiArray[1], 2);
  SetLength(multiArray[2], 3);

  // Set and show all elements of this array
  for i := 0 to High(multiArray) do
    for j := 0 to High(multiArray[i]) do
    begin
      multiArray[i,j] := IntToStr(i+j);
      ShowMessage('multiArray['+intToStr(i)+','+intToStr(j)+'] = '+
                  multiArray[i,j]);
    end;
end;
{
   byteArray length = 5
   byteArray lowest element = 0
   byteArray highest element = 4
   byteArray element 2 = 10
   byteArray element 4 = 20
   multiArray[0,0] = 0
   multiArray[1,0] = 1
   multiArray[1,1] = 2
   multiArray[2,0] = 2
   multiArray[2,1] = 3
   multiArray[2,2] = 4
}

var

// Define dynamic arrays

byteArray : Array of Byte; // Single dimension array

multiArray : Array of Array of string; // Multi-dimension array

i,j : Integer;

begin

// Set the length of the single dimension array

SetLength(byteArray, 5);

// Show the size and range of this array

ShowMessage('byteArray length = '+IntToStr(Length(byteArray)));

ShowMessage('byteArray lowest element = '+IntToStr(Low(byteArray)));

ShowMessage('byteArray highest element = '+IntToStr(High(byteArray)));

// Furnish this array - remember that dynamic arrays start at 0

for i := 0 to 4 do

byteArray[i] := i * 5;

// Show selected elements from the array

ShowMessage('byteArray element 2 = '+IntToStr(byteArray[2]));

ShowMessage('byteArray element 4 = '+IntToStr(byteArray[4]));

// Set the length of the 1st dimension of the multi-dim array

SetLength(multiArray, 3);

// Set the length of the 3 sub-arrays to different sizes

SetLength(multiArray[0], 1);

SetLength(multiArray[1], 2);

SetLength(multiArray[2], 3);

// Set and show all elements of this array

for i := 0 to High(multiArray) do

for j := 0 to High(multiArray[i]) do

begin

multiArray[i,j] := IntToStr(i+j);

ShowMessage('multiArray['+intToStr(i)+','+intToStr(j)+'] = '+

multiArray[i,j]);

end;

{

byteArray length = 5

byteArray lowest element = 0

byteArray highest element = 4

byteArray element 2 = 10

byteArray element 4 = 20

multiArray[0,0] = 0

multiArray[1,0] = 1

multiArray[1,1] = 2

multiArray[2,0] = 2

multiArray[2,1] = 3

multiArray[2,2] = 4

}

Open Array as parameter

var
  // Define a dynamic array
  charArray : TCharArray;
  openArray : Array [0..2] of char;

  i : Integer;

begin
  // Pass the undefined array as a dynamic array to a subroutine
  FurnishDynamicArray(charArray);

  // Furnish an array for the next routine
  openArray[0] := 'N';
  openArray[1] := 'o';
  openArray[2] := 'w';

  // Pass this predefined array as an open array to a subroutine
  ShowOpenTypeArray(openArray);

  // Show all elements of the passed array
  for i := 0 to High(charArray) do
      ShowMessage('charArray['+intToStr(i)+'] = '+charArray[i]);

  // Pass a number of characters as an open constant array to a subroutine
  ShowOpenConstArray(['H','e','l','l','o']);
end;

// Procedure that updates a dynamic array size
// IMPORTANT - note that the array type must not be defined here -
//             we must use an array type to avoid the array being treated
//             as an open array.
procedure TForm1.FurnishDynamicArray(var typeArray : TCharArray);
var
  i : Integer;

begin
  // Set the length of the single dimension array
  SetLength(typeArray, 5);

  // Furnish this array - remember that dynamic arrays start at 0
  for i := 0 to 4 do
    typeArray[i] := Chr(Ord('A') + i);
end;

// Procedure that takes an open array
procedure TForm1.ShowOpenTypeArray(typeArray : Array of char);
var
  i : Integer;

begin
  // Show all elements of the passed array
  for i := 0 to High(typeArray) do
    ShowMessage('typeArray['+intToStr(i)+'] = '+typeArray[i]);
end;

// Procedure that takes an open constant array
procedure TForm1.ShowOpenConstArray(const constArray : Array of const);
var
  i : Integer;

begin
  // Show all elements of the passed array
  // IMPORTANT - we assume here that the constant types are all char
  //             See the TVarRec type for more on Variant types.
  for i := 0 to High(constArray) do
    ShowMessage('constArray['+intToStr(i)+'] = '+constArray[i].VChar);
end;

{
   typeArray[0] = N
   typeArray[1] = o
   typeArray[2] = w
   charArray[0] = A
   charArray[1] = B
   charArray[2] = C
   charArray[3] = D
   charArray[4] = E
   constArray[0] = H
   constArray[1] = e
   constArray[2] = l
   constArray[3] = l
   constArray[4] = o
}

var

// Define a dynamic array

charArray : TCharArray;

openArray : Array [0..2] of char;

i : Integer;

begin

// Pass the undefined array as a dynamic array to a subroutine

FurnishDynamicArray(charArray);

// Furnish an array for the next routine

openArray[0] := 'N';

openArray[1] := 'o';

openArray[2] := 'w';

// Pass this predefined array as an open array to a subroutine

ShowOpenTypeArray(openArray);

// Show all elements of the passed array

for i := 0 to High(charArray) do

ShowMessage('charArray['+intToStr(i)+'] = '+charArray[i]);

// Pass a number of characters as an open constant array to a subroutine

ShowOpenConstArray(['H','e','l','l','o']);

end;

// Procedure that updates a dynamic array size

// IMPORTANT - note that the array type must not be defined here -

// we must use an array type to avoid the array being treated

// as an open array.

procedure TForm1.FurnishDynamicArray(var typeArray : TCharArray);

var

i : Integer;

begin

// Set the length of the single dimension array

SetLength(typeArray, 5);

// Furnish this array - remember that dynamic arrays start at 0

for i := 0 to 4 do

typeArray[i] := Chr(Ord('A') + i);

end;

// Procedure that takes an open array

procedure TForm1.ShowOpenTypeArray(typeArray : Array of char);

var

i : Integer;

begin

// Show all elements of the passed array

for i := 0 to High(typeArray) do

ShowMessage('typeArray['+intToStr(i)+'] = '+typeArray[i]);

end;

// Procedure that takes an open constant array

procedure TForm1.ShowOpenConstArray(const constArray : Array of const);

var

i : Integer;

begin

// Show all elements of the passed array

// IMPORTANT - we assume here that the constant types are all char

// See the TVarRec type for more on Variant types.

for i := 0 to High(constArray) do

ShowMessage('constArray['+intToStr(i)+'] = '+constArray[i].VChar);

end;

{

typeArray[0] = N

typeArray[1] = o

typeArray[2] = w

charArray[0] = A

charArray[1] = B

charArray[2] = C

charArray[3] = D

charArray[4] = E

constArray[0] = H

constArray[1] = e

constArray[2] = l

constArray[3] = l

constArray[4] = o

}

Make a question and you'll have an answer…

Make a question and you'll have an answer…

Array

Description

Example code