Справочник функций и процедур Delphi: Array

  Навигация по первой букве:

A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z

  Навигация по категории:

Compiler directives, Directives, Keywords / Types, Variables, Constants / Functions, Procedures

  Реклама:

 

Array
Ключевое слово
Тип данных содержащий индексируемую коллекцию данных unit
  
1 type Name = array[Index type|Ordinal..Ordinal {,...}] of Base type; // Статический массив

2 type Name = array of {array of ...} Base type; // Динамический массив

3 Name : array of {array of ...} const; // Открытый различный массив
   Name : Array type; // Открытый динамический массив

Google  
 
Описание
Ключевое слово Array обеспечивает одномерные и многомерные массивы данных.

Delphi имеет три основных типа массивов :

1. Статические массивы

Они определены установленными, неизменяемыми размерами. Они могут быть одномерными или многомерными - последний является массивом массивов (массивов и т.д). Размер и диапазон такого многомерного массива всегда даются для самого высокого, крайнего левого массива - родительского массива.

Размер каждого измерения определен двумя способами, которые могут быть свободно смешаны в многомерном массиве :

Index type, где Index целое число, обычно Byte или Word. Диапазон этого типа определяет диапазон измерения. Например, Byte дает дипазон 0..255.

Ordinal..Ordinal Альтернативно, диапазон каждого измерения может быть задан предписанными порядковыми значениями, типа 22..44.

2. Динамические массивы

Динамические массивы не имеют никакой предраспределенной памяти. Определяется только когда создан указатель. Размеры таких массивов должны быть установлены прежде, чем они будут использоваться. Например :

SetLength(dynArray, 5);

устанавливает размер одномерного массива dynArray в 5 элементов. При этом будет распределена память.

Все динамические массивы начинаются с индекса = 0.

Индивидуальные подмассивы многомерного динамического массива могут иметь различные измерения - они, конечно являются отдельными массивами. После одной такой операции SetLength, на элементы набора массива уже можно ссылаться, даже при том, что остальная часть массива неопределена.

3. Открытые массивы

И статические и динамические массивы можно передать подпрограммам как параметры. Если определение параметра массива не имеет никакого диапазона (то есть, динамический тип массива), то вы должны, как это ни парадоксально передавать статический массив как параметр. Такой массив упоминается как Открытый массив. Delphi передает длину как скрытый параметр для подпрограммы.

Открытый массив также может быть определен типом значения константы. Это называют Различным (Variant) открытым массивом - это, главным образом, используется для разрешения передачи подпрограмме переменного числа значений аргументов.

Для передачи Динамического массива ссылкой, массив и подпрограммное определение массива должны быть через определение типов массива. См. код для примера.
Примечания
Используйте Copy для копирования одного массива в другой. Но будьте осторожны - это копирует только первое, самое высокое измерение - новый массив будет все еще относиться к элементам подмассивов.
Похожие команды
Copy  Создает копию части строки или части массива

High  Возвращает самое высокое значение типа или переменной

Length  Возвращает число элементов в массиве или строке

Low  Возвращает самое низкое значение типа или переменной

SetLength  Изменяет размер строки или размер динамического массива

Slice  Создает часть массива с параметром "Открытый Массив"

 
Пример кода : Объявление и использование статических массивов
var
  // Определение статического массива
  wordArray  : Array[Word] of Integer;     // Статический, размер=High (Word)
  multiArray : Array[Byte, 1..5] of char;  // Статический массив, 2 измерения
  rangeArray : Array[5..20] of string;     // Статический массив, размер = 16

  i : Integer;

begin
  // Показ размеров и диапазоны этих массивов
  ShowMessage('Длина wordArray = '+IntToStr(Length(wordArray)));
  ShowMessage('Самый маленький элемент wordArray = '+IntToStr(Low(wordArray)));
  ShowMessage('Самый большой элемент wordArray = '+IntToStr(High(wordArray)));
  ShowMessage('Длина multiArray = '+IntToStr(Length(multiArray)));
  ShowMessage('Самый маленький элемент multiArray = '+IntToStr(Low(multiArray)));
  ShowMessage('Самый большой элемент multiArray = '+IntToStr(High(multiArray)));
  ShowMessage('Длина rangeArray = '+IntToStr(Length(rangeArray)));
  ShowMessage('Самый маленький элемент rangeArray = '+IntToStr(Low(rangeArray)));
  ShowMessage('Самый большой элемент rangeArray = '+IntToStr(High(rangeArray)));
  ShowMessage('');

  // Полный диапазон статического массива доступен до назначения,
  // но значения будет непредсказуемо
  ShowMessage('wordArray элемент 7 = '+IntToStr(wordArray[7]));
  ShowMessage('wordArray элемент 20 = '+IntToStr(wordArray[20]));

  // Использование индексации для заполнения массива
  for i := 5 to 20 do
    rangeArray[i] := IntToStr(i * 5);

  // Теперь используем индексацию для отображения 2-х элементов
  ShowMessage('rangeArray элемент 7 = '+rangeArray[7]);
  ShowMessage('rangeArray элемент 20 = '+rangeArray[20]);
end;

Длина wordArray = 65536
Самый маленький элемент wordArray = 0
Самый большой элемент wordArray = 65535
Длина multiArray = 256
Самый маленький элемент multiArray = 0
Самый большой элемент multiArray = 255
Длина rangeArray = 16
Самый маленький элемент rangeArray = 5
Самый большой элемент rangeArray = 20
wordArray элемент 7 = 0
wordArray элемент 20 = 0
rangeArray элемент 7 = 35
rangeArray элемент 20 = 100
 
Пример кода : Объявление и использование динамических массивов
var
  // Определение динамического массива
  byteArray  : Array of Byte;           // Одномерный массив
  multiArray : Array of Array of string;  // Многомерный массив

  i,j : Integer;

begin
  // Установка длины одномерного массива
  SetLength(byteArray, 5);

  // Показ размера и диапазона этого массива
  ShowMessage('Длина byteArray = '+IntToStr(Length(byteArray)));
  ShowMessage('Самый маленький элемент byteArray = '+IntToStr(Low(byteArray)));
  ShowMessage('Самый большой элемент byteArray = '+IntToStr(High(byteArray)));

  // Заполнение этого массива - помните, что динамические массивы начинаются с 0
  for i := 0 to 4 do
    byteArray[i] := i * 5;

  // Показ выбранных элементов массива
  ShowMessage('byteArray элемент 2 = '+IntToStr(byteArray[2]));
  ShowMessage('byteArray элемент 4 = '+IntToStr(byteArray[4]));

  // Установка длины 1-ого измерения многомерного массива
  SetLength(multiArray, 3);

  // Установка различной длины этих 3 подмассивов
  SetLength(multiArray[0], 1);
  SetLength(multiArray[1], 2);
  SetLength(multiArray[2], 3);

  // Установка и показ всех элементов этого массива
  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 = 0
Самый маленький элемент byteArray = 4
byteArray элемент 2 = 10
byteArray элемент 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
  // Определение динамического массива
  charArray : TCharArray;
  openArray : Array [0..2] of char;

  i : Integer;

begin
  // Передача неопределенного массива как динамический массив подпрограмме
  FurnishDynamicArray(charArray);

  // Заполнение массива для следующей подпрограммы
  openArray[0] := 'N';
  openArray[1] := 'o';
  openArray[2] := 'w';

  // Передача этого предопределенного массива как открытый массив подпрограмме
  ShowOpenTypeArray(openArray);

  // Показ всех элементов переданного массива
  for i := 0 to High(charArray) do
      ShowMessage('charArray['+intToStr(i)+'] = '+charArray[i]);

  // Передача подпрограмме числа символов как открытый постоянный массив
  ShowOpenConstArray(['H','e','l','l','o']);
end;

// Процедура, которая модифицирует динамический размер массива
// ВАЖНО - обратите внимание, что тип массива здесь не должен быть определен -
//         мы должны использовать тип массива, чтобы избежать массива,
//         обрабатываемого как открытый массив.
procedure TForm1.FurnishDynamicArray(var typeArray : TCharArray);
var
  i : Integer;

begin
  // Установка длины одномерного массива
  SetLength(typeArray, 5);

  // Заполнение этого массива - помните, что динамические массивы начинаются с 0
  for i := 0 to 4 do
    typeArray[i] := Chr(Ord('A') + i);
end;

// Процедура, которая принимает открытый массив
procedure TForm1.ShowOpenTypeArray(typeArray : Array of char);
var
  i : Integer;

begin
  // Показ всех элементов переданного массива
  for i := 0 to High(typeArray) do
    ShowMessage('typeArray['+intToStr(i)+'] = '+typeArray[i]);
end;

// Процедура, которая принимает открытый постоянный массив
procedure TForm1.ShowOpenConstArray(const constArray : Array of const);
var
  i : Integer;

begin
  // Показ всех элементов переданного массива
  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
 


Copyright © 2004-2016 Delphi Sources (источник – "DelphiBasics.ru")
 


Группа ВКонтакте   Ссылка на Twitter   Группа на Facebook