Dim name.<type>(<expression1>, [<expression2>], ...)

Параметры

name	Имя Массива, оно должно соответствовать синтаксису принятому в Purebasic для Переменных, Массивов, Связных списков и Хеш-карт, описание синтаксиса имени, см. ниже.
<type>	Этот параметр указывает тип Массива, это может быть любой стандартный тип поддерживаемый PureBasic, или структурный тип определяемый пользователем. Каждый элемент Массива будет соответствовать обычной переменной с таким же типом.
<expression1>, <expression2>..	Выражения задающее количество элементов (длину) Массива в данных измерениях. Измерений может быть несколько и каждое может иметь свою длину. Не всем Массивам длину можно задавать переменной, см. раздел Объявление Массива.

Описание

Ключевое слово Dim используется для создания новых Динамических Индексных Массивов . Динамический Массив (далее "Массив") – это динамическая структура данных в виде набора однотипных элементов (называемых элементами Массива). Элементы Массива аналогичны переменным, но имеют одно и то же имя и отличающихся друг от друга только своим Номером – значением так называемого индекса (или индексов, если измерений несколько). В отличие от Связного Списка или Хеш-карты, элементы Массива размещаются в памяти непосредственно друг за другом (единым блоком), поэтому невозможно быстро вставить или удалить произвольный элемент (кроме как добавить/удалить в конце Массива). С другой стороны, Массив предоставляет практически мгновенный доступ к произвольному элементу, который осуществляется с помощью имени Массива и одного или нескольких индексов.

Кроме Динамических Массивов в PureBasic так же существуют Статические Массивы.
Статические Массивы могут объявляться только в Структурах, без ключевого слова Array и обозначаются с квадратными скобками, в виде: Myarray.Type[x], где Myarray – это имя Массива, Type – это тип Массива, x – это длина Массива. В Структуре поддерживаются только одномерные Статические Массивы. После объявления размер такого Массива изменить нельзя!

В библиотеках Array и Sort можно найти несколько полезных функций для работы с Массивами.

Сравнить между собой характеристики Массивов, Связных Списков, Хэш-карт и выбрать из них подходящую структуру данных можно по таблице находящейся здесь.


Массив имеет атрибуты:

♦    Имя
♦    Тип
♦    Значения
♦    Адрес
♦    Размерность
♦    Длина измерения
♦    Область видимости
♦    Время жизни

Имя Массива задаётся программистом при создании программы и должно соответствовать данным требованиям (всё как у переменных):

•    Имя не должно начинаться с цифры и может состоять из латинских букв (a,s…), цифр (0,1...) и символов подчёркивания (_).
•    Имя не может совпадать с зарезервированными словами, используемыми в Purebasic: IF, For, Next и др.
•    Имя не должно содержать пробелов ( ), знаков пунктуации (.) , специальных символов (ß, ä, ö, ü...) или операторов (+,-...).
•    Длина имени не должна превышать 128 символов.
•    Имя строкового Массива может содержать знак ($) в качестве последнего символа имени, вместо использования суффикса (.s).
•    Имя Массива указателей должно содержать знак (*) в качестве первого символа имени.
•    В отличие от переменной, после имени Массива всегда указываются круглые скобки ( ), или квадратные скобки [ ] в случае статического Массива.

Все символы в имени Массива являются значимыми, но их регистр не имеет значения, поэтому имена "pure" и "PURE" считаются одним и тем же именем, с другой стороны, "PURE" отличается от "PURE1".
Использование осмысленных имен помогает документировать код программы и облегчает неизбежный процесс отладки.
Допустимые имена Массивов: "pure()", "PURE()", "_Pure()", "____()", "IF7()", "Fore()"…
Недопустимые имена Массивов: "7pure()", "P U R E()", "+Pure()" , "apu7re7()", "IF()"…

Определяет тип данных, которые могут принять на хранение элементы Массива. Тип Массива указывается суффиксом при объявлении Массива, например: Dim Myarray.w(5) будет означать, что Массив Myarray() объявлен с типом Word, таким образом можно объявить Массив любого стандартного типа поддерживаемого PureBasic, или Структурного типа определяемого пользователем. Если суффикс не указан, будет использован тип по умолчанию.
Также Массив можно объявить как Массив указателей, используя символ "*" в качестве первого символа имени Массива, например: Dim *Myarray(7). Каждый элемент такого Массива может хранить адрес объекта в памяти или другое целочисленное значение ограниченное рамками типа Integer. Массив указателей можно объявить со Структурным типом, например Dim *Myarray.Point(7), и использовать его элементы в качестве указателей для доступа к экземплярам данной структуры. Так как Purebasic является языком со статической типизацией, тип Массива после объявления не может быть изменён!

Это данные, которые хранятся элементами Массива. Способы хранения и обработки данных зависят от того, к какому типу они принадлежат.
Например, если Массив имеет тип Word, то каждый его элемент может хранить целочисленное значение в диапазоне от -32768 до +32767. Элементы Массива с типом String могут хранить только значения в виде строки. Если Массив объявлен со Структурным типом, то каждый его элемент будет содержать поля как указано в данной Структуре и сможет хранить значения соответствующие типам полей этой Структуры.
Начальное значение каждого элемента (или его полей) Массива зависит от типа Массива и равно 0, либо 0.0, либо пустой строке. Обычно значение элементу (или его полю) присваивается знаком '=' (равно), но так же можно использовать сокращенные формы оператора присваивания: Myarray(0) + 1 (сработает как Myarray(0) = Myarray(0) + 1).

Адрес Массива – это Номер ячейки памяти, где находится первый байт (самый младший байт) начального элемента Массива (элемента с индексом (0), или (0,0) и т. д. в зависимости от размерности и типа Массива), все последующие байты этого элемента выстроены в памяти друг за другом (от младшего к старшему). Например, если Массив типа Long (4 байта) имеет адрес 91700, то младший байт его начального элемента будет находиться по адресу 91700, а старший байт этого элемента по адресу 91703. По адресу 91704 будет находиться младший байт следующего элемента, и так далее.
Общее число занимаемых байт конкретным Массивом можно рассчитать, перемножив количество элементов во всех измерениях на размер одного элемента.
Размер элемента – зависит от типа Массива и соответствует размерам обычной переменной с указанным типом. Например, элемент типа Byte занимает 1 байт, элементы типов Integer, String или указательный - на 32-х разрядной системе занимают 4 байта, а на 64-х разрядной 8 байтов.
Размер элемента типа Fixed String равен удвоенному значению, указанному в фигурных скобках {Х} параметра используемого при объявлении Массива.
Размер элемента со Структурным типом равен сумме размеров полей используемой Структуры, которую можно получить с помощью функции SizeOf(Type), указав в качестве параметра (Type) имя этой Структуры.

Адрес Массива можно получить, подставив символ '@' перед именем Массива, этот адрес можно использовать для низкоуровневого обращения с помощью функций Poke/Peek к данным хранящимся в элементах Массива, например чтобы заменить штатные функции обработки текста, на что-либо более быстрое.

Более подробную информацию о памяти и устройстве многомерных Массивов можно найти в главе Указатели.

Размерность Массива — это количество индексов (количество измерений), необходимое для однозначной адресации элемента в рамках Массива.
Количество используемых индексов Массива может быть различным: Массивы с одним индексом называют одномерными, с двумя — двумерными, и т. д. одномерные Массивы можно представить себе в виде колонки или столбца, двухмерные – в виде матрицы, так же их можно считать Массивом одномерных Массивов. PureBasic поддерживает многомерные Массивы (больше 30 измерений), в том числе и в качестве членов структуры.

Длина измерения Массива – это количество элементов Массива в одном конкретном измерении. Длина одномерного Массива равна параметру <expression1> + 1, потому что нумерация элементов в PureBasic (как и в других BASIC'ах) начинается с элемента 0. Например, если Вы объявили Dim Myarray.i(10), в Массиве будет 11 элементов (считается от 0 до 10). Это поведение отличается в случае использования статических Массивов в структурах, там Myarray[10] имеет ровно 10 элементов. Purebasic имеет специальную команду ArraySize(), которая позволяет получить длину Массива в указанном измерении.
После создания динамического Массива, его размер всегда можно изменить, с помощью ключевого слова Dim (с обнулением данных в элементах), или ключевого слова ReDim (с сохранением данных в элементах).

Двумя важнейшими и взаимосвязанными параметрами определяющими доступность Массива в той или иной части кода являются Область видимости и Время жизни Массива.

Область видимости - обозначает область программы, в пределах которой имя (идентификатор) Массива продолжает быть связанным с этим Массивом и возвращать значения его элементов. За пределами области видимости тот же самый идентификатор может быть связан с другим Массивом, либо быть свободным (не связанным ни с чем).

Время жизни Массива – это период времени выполнения программы, в течение которого Массив существует и сохраняет значения своих элементов. В Purebasic этот параметр обычно напрямую связан с областью видимости.

По области видимости все Массивы можно разделить на два типа: локальные и глобальные.
Глобальный Массив после объявления обычно становится доступным в любом месте кода данного пространства имён и существует на протяжении всего времени выполнения программы.
Область видимости локального Массива обычно определяется местом его объявления. Это значит, что если Массив объявлен в процедуре, то он будет не доступен вне этой процедуры, и наоборот.

Так же как и обычные Переменные, Массивы можно объявлять с различными сочетаниями области видимости и времени жизни. Это делается с помощью одного из дополнительных ключевых слов, используемых для явного объявления обычных переменных, это: Global, Define, Protected, Threaded, Shared и Static. В результате, Вам будут доступны все шесть подтипов Массивов, то есть всё как у обычных переменных: Global, Local, Main, Threaded, Shared и Static. Эти обозначения можно увидеть в инструментах IDE поддерживающих просмотр Массивов. В верхней части показываются Переменные, Массивы, Связные списки и Хеш-карты основного кода, а в нижней части - объекты доступные в текущей процедуре:

Global (глобальный) – это Глобальный Массив, который может быть объявлен с помощью ключевого слова Global, помещённого перед Dim, в любом месте кода данного пространства имён (лучше в начале основного кода). Область его видимости распространяется на весь код данного пространства имён (от точки объявления), включая любые процедуры, за исключением случая использования в процедуре ключевых слов Protected или Static, которые локально ограничивают его видимость. Массив Global существует на всём протяжении работы программы.

Local (локальный) – это Локальный Массив, который может быть объявлен с помощью ключевого слова Define или Protected (либо без них), помещённого перед Dim, в любой процедуре данного пространства имён. При объявлении с помощью Protected можно использовать имя существующего Массива Global, при этом не будет конфликта имён. Область его видимости распространяется на текущую процедуру (от точки объявления). Массив Local существует на протяжении работы процедуры.

Main (основной) – это Локальный Массив, который может быть объявлен с помощью ключевого слова Define (либо без него) помещённого перед Dim, в основном коде данного пространства имён. Область его видимости распространяется на весь код данного пространства имён (от точки объявления), кроме любых процедур, за исключением случая использования в процедуре ключевого слова Shared, которое открывает доступ к этому Массиву из процедуры. В этой процедуре такой Массив представится как Shared. Массив Main существует на всём протяжении работы программы.

Threaded (потоковый) - это Глобальный Массив, который может быть объявлен с помощью ключевого слова Threaded, помещённого перед Dim, в основном коде данного пространства имён (лучше в начале основного кода). Область его видимости распространяется на весь код текущего потока (от точки объявления), данного пространства имён, кроме процедур, выполняемых в других потоках. У каждого потока будет свой экземпляр Массива. Массив Threaded основного потока существует на всём протяжении работы программы, а экземпляры остальных потоков (созданные вызовом функции CreateThread() ) – пока не завершится их поток.

Shared (разделяемый) – это Локальный Массив Main, который ранее был объявлен в основном коде и с помощью ключевого слова Shared стал доступен в текущей процедуре. Если при использовании ключевого слова Shared ввести имя несуществующего Массива Main - компилятор выдаст ошибку. Массив Global так же можно использовать как Shared (бессмысленно). Массивы Main и Global существуют на всём протяжении работы программы.

Static (статичный) – это Локальный Массив, который может быть объявлен с помощью ключевого слова Static помещённого перед Dim, в любой процедуре данного пространства имён. Область его видимости распространяется на текущую процедуру (от точки объявления). Этот Массив существует на всём протяжении работы программы и сохраняет значения своих элементов между вызовами процедур. Если уже существует Массив Global с таким же именем, видимость Массива Global в этой процедуре будет приостановлена, от момента объявления Static до выхода из процедуры.

Кроме перечисленных выше способов по управлению видимостью Массивов, дополнительно можно использовать разделение кода на пространства имён.
Программа в Purebasic изначально имеет одно Глобальное пространство имён, где есть свои Локальные и Глобальные Массивы (шесть подтипов), которые невидимы в дополнительных пространствах имён. При необходимости, Purebasic позволяет организовать в программе дополнительные пространства имён, в виде так называемых Модулей. Для того чтобы Массив, находящийся в Модуле был доступен в другом пространстве имён, он как и обычные переменные должен быть объявлен при создании Модуля, в специальном блоке команд DeclareModule / EndDeclareModule.


Сводная таблица характеристик Массивов в Purebasic:

Название подтипа.	Ключевое слово для объявления подтипа.	Область видимости.	Видимость в основном коде.	Видимость в процедурах.	Видимость в потоковых процедурах.	Видимость в других пространствах имён.	Возможность объявления без доп. ключевых слов.	Время жизни.
Global.	Global.	Глобальная.	Да.	Да.	Да.	Нет.	Нет.	Глобальное.
Local.	Define, Protected, Procedure.	Локальная.	Нет.	Только в своей процедуре.	Только в своей процедуре.	Нет.	Да.	Только в своей процедуре.
Main	Define.	Локальная.	Да.	Нет.	Нет.	Нет.	Да.	Глобальное.
Threaded.	Threaded.	Глобальная.	Да.	Да.	Для каждого потока свой экземпляр.	Нет.	Нет.	В пределах своего потока.
Shared.	Shared.	Локальная.	Да.	Только в своей процедуре.	Только в своей процедуре.	Нет.	Нет.	Глобальное.
Static	Static	Локальная	Нет	Только в своей процедуре.	Только в своей процедуре.	Нет.	Нет.	Глобальное.

При использовании дополнительных ключевых слов Global, Define, Protected и Static допускается объявление сразу нескольких Массивов в одной строке, поместив в неё несколько ключевых слов Dim через запятую. Например: Define.w Dim Myarray.b(10), Dim Myarray2(10). В этом случае с помощью суффикса (после доп. ключевого слова) можно указать тип по умолчанию для объявлений Массивов в этой строке, он будет использован, если для какого либо из них тип не указан. Если тип по умолчанию не указан, будет использован тип Integer.

Без дополнительных ключевых слов (используя только слово Dim) можно объявить только локальные Массивы Main и Local. Например: Dim Myarray.b(10)

При предоставлении доступа к уже существующим Массивам Main (и Global) с помощью ключевого слова Shared, можно указать в одной строке сразу несколько имён существующих Массивов с пустыми скобками после имени (без ключевого слова Dim). Например: Shared Myarray(), Myarray2().

При объявлении потоковых Массивов с помощью ключевого слова Threaded допускается объявлять только одномерные Массивы, и только по одному. Например: Threaded Dim Myarray(10).

При объявлении Массивов Threaded и Static, а так же всех Массивов – членов структуры, для задания их параметров допускается использовать только константы, числа и выражения из них.

Следует отметить, что ключевые слова Global, Define, Protected, Threaded, Shared и Static и EnableExplicit распространяют своё действие только на текущее пространство имён, будь то глобальное пространство имён или Модуль.

Необходимо помнить, что Purebasic это компилятор, и все именованные объекты (в том числе Массивы) объявляемые в коде, будут занесены в пространство имён ещё на этапе компиляции (до начала программы).
В то же время, если это Массив Global, Local, Main или Shared , то память под его элементы выделяется уже во время работы программы. С одной стороны это позволяет использовать переменные для указания параметров Массива, с другой стороны можно случайно обратиться к Массиву, которому ещё не выделена память под элементы, что приведёт к ошибке обращения к памяти.
Для Массивов Threaded (основного потока) и Static изначально память под элементы выделяется во время компиляции (именно поэтому для задания их параметров нельзя использовать переменные), но команды для изменения размера (длины) Массива Dim и ReDim для них так же успешно работают.

Как пример: если команды Global Dim помещены внутрь конструкции "If a>10 : Global Dim Myarray.i (10) : Endif : Myarray(0)=100 ", то ещё до начала программы будет установлено, что в этой строке объявляется глобальный Массив Myarray.i(), при этом условие a>10 может быть проверено только во время работы программы, следовательно, Массив Myarray.i() будет считаться объявленным раньше, чем произойдёт проверка условия If a>10 !!! Другими словами: команда Global Dim Myarray.i (10) объявит Массив Myarray.i() вне зависимости от выполнения условия a>10. В то же время, память под свои элементы Массив получит только после выполнения условия a>10, таким образом, присвоение Myarray(0)=100 вызовет ошибку доступа к памяти.

Несколько по-другому обстоит дело с командами Threaded и Static. В строке "If a>10 : Threaded Dim Myarray.i (10) : Endif : Myarray(0)=100" не будет ошибки, так как память под элементы для Массивов Threaded и Static выделяется ещё во время компиляции. Но если строку переделать так: "If a>10 : Threaded Dim Myarray.i (10): Myarray(0)=100 : Endif", то получится ситуация, что Массив будет объявлен в любом случае, а присвоение значения " Myarray(0)=100" будет выполнено только когда выполнится условие "a>10", что может вносить путаницу.

Это относится к объявлению Массивов в любых языковых конструкциях (циклы, процедуры, ветвления…). При этом компилятор считает такое объявление легальным и во время компиляции не выводит ошибки, в результате ошибка может возникнуть в уже готовой скомпилированной программе.
Кроме того, поскольку контроль нарушения границ Массива выполняется только когда включен отладчик, программист должен сам предупреждать такие ситуации, или впоследствии готовая программа будет просто прекращать работу.
Например: команда Dim Myarray.i(100) заявляет элементы от 0 до 100, и если обратиться к 150 элементу, то произойдёт ошибка, так как под этот элемент память не выделена. Кроме того, если к этому же Массиву впоследствии применить команду Dim Myarray(0) или ReDim Myarray(0), у Массива останется только 0-й элемент и обращение к любому другому элементу так же вызовет ошибку. После применения команды FreeArray(Myarray()) – у Массива не останется вообще ни одного элемента, при этом сам Массив будет доступен для операций! Описание всех команд для управления Массивами, можно посмотреть в библиотеке Array.

Пример: "Не корректные" объявления Массивов.

Define a=5
If a>10
    Define Dim q(1) ; Массив считается объявленным здесь, хотя условие a>10 не выполнено, память под элементы НЕ выделена.
    q(0) = 30        ; эта строка сработает если условие a>10 выполняется, но тогда память будет выделена и ошибки не будет.
EndIf
; Define Dim q(1,1) ; Вы не можете изменить размерность Массива q(), так как он уже доступен как одномерный!
; q(0) = 20  ; Массив доступен, но память под элементы не выделена, так как условие a>10 не выполнено. Будет ошибка.
; Debug q(0)  ; Массив доступен, но память под элементы не выделена, так как условие a>10 не выполнено. Будет ошибка.

If a>10
    Threaded Dim Array (10) ; Массив считается объявленным здесь, хотя условие a>10 не выполнено, и память под элементы ВЫДЕЛЕНА.
    Array(0)=10                ; значение не присвоено, так как условие a>10 не выполнено.
EndIf
Debug Array(0)    ; ошибки не будет, Массив доступен, память под элементы выделена, хотя условие a>10 не выполнено!

Procedure Change()
    Global Dim w(1)  ; Массив считается объявленным здесь, даже если процедуру никогда не вызовут !!!
    w(1) = 100
    ;Static Dim e(a+10) ; параметры Массивов Static и Threaded должны задаваться числами или константами.
EndProcedure
; Debug w(1)  ; Массив доступен, но память под элементы не выделена, так как процедуру не вызывали. Будет ошибка.
Change()      ; вызов процедуры.
Debug w(1)      ; После вызова процедуры наконец то под элементы выделена память!
              ; Debug w(2)  ; Массив доступен, но этот элемент не заявлен и память под него не выделена. Будет ошибка.
FreeArray(w()); Освобождаем память Массива w(), но он остаётся доступным!
              ; Debug w(1)  ; Массив доступен, но память у него отобрали. Будет ошибка.
End

Массивы с типом string содержат элементы, каждый из которых может принять на сохранение строку символов произвольной длины. Если Вас не устраивают такие "безразмерные" элементы, Вы можете ограничить число символов на каждый элемент, использовав для Массива тип Fixed String. Для этого при объявлении строкового Массива необходимо в фигурных скобках указать количество символов для строки, например: Dim Array.s {32}(5). В этом случае каждый элемент Массива будет занимать фиксированный объём памяти.

Пример: Применение Массивов String и Fixed String.

; В этом примере текст  из файла построчно считывается в Массив, в каждый элемент по строке.
Dim c$(2000)      ; Массив для сохранения 2000 строк произвольной длины.
Dim a${1}(2000)      ; Массив для 2000 строк с ограничением  в 1 символ на строку.
If ReadFile(0, "test.txt")  ; Открываем файл с несколькими строками текста. (создайте файл "test.txt")
    While Eof(0) = 0        ; Цикл, пока не достигнут конец файла.
        c$(a)= ReadString(0); Считываем строку в элемент Массива
        a$(a)= ReadString(0); Считываем строку в элемент Массива, но сохраняется только первый символ строки.
        a=a+1
    Wend
    CloseFile(0)    ; Закрываем файл
    For q=0 To a    ; выводим содержимое Массивов
        Debug c$(q)
        Debug a$(q)
    Next q
Else ; если файл открыть не удалось
    MessageRequester("Информация","Не возможно открыть файл!")
EndIf
End

Пример: Объявление разделяемых (Shared) Массивов в процедурах.

Define.l a=5, b=10 ; Объявление переменных
Global.w Dim Array(40), Dim Array2(a+b) ; объявление одномерных Массивов (Global) с типом Word.
Dim MultiArray(60, a+b)                    ; объявление двухмерного Массива (Main) с типом по умолчанию (integer).
Dim tripleArray.w(a+b, 50, a+b)            ; объявление трёхмерного Массива (Main) с типом Word, используя выражение.
Array(0) = 100
MultiArray(0, 0) = 200
tripleArray.w(0, 0, 0) = 300

Procedure Change()
    Debug Array(0)  ; 100
                    ; Debug MultiArray(0, 0)            ; эта строка не сработает, так как доступ к массиву ещё не открыт.
    Shared.w MultiArray(), tripleArray() ; указанные Массивы (Main) становятся  доступными в процедуре (Shared) .
    Debug  MultiArray(0, 0)                ; 200
    Debug    tripleArray.w(0, 0, 0)        ; 300
EndProcedure

Change() ; Вызов процедуры.
End

Пример: Объявление защищенных (от основного кода) Массивов в процедурах.

Global.w Dim Array(40), Dim Array2(50) ; объявление одномерных Глобальных Массивов (Global) с типом Word.
Array(0) = 100                          ; присваиваем значения начальным элементам
Array2(0) = 200

Procedure qwe()
    Protected Dim Array(70)  ; Объявление Массива Array() (local) и приостановка видимости Массива Array() (Global).
    Static Dim Array2(70)    ; Объявление Массива Array() (Static) и приостановка видимости Массива Array() (Global).
    Array(0)+20                ; Здесь используется сокращённая форма оператора присваивания.
    Array2(0) = Array2(0) +1 ; А здесь обычное присваивание.
    Debug Array(0)            ; Этот Массив НЕ сохраняет содержимое элементов, между вызовами процедуры.
    Debug Array2(0)            ; Этот Массив СОХРАНЯЕТ содержимое элементов, между вызовами процедуры.
EndProcedure

For q=0 To 8
    qwe()                  ; вызов процедуры
Next q
Debug Array(0)  ; Содержимое Массивов (Global) осталось нетронутым.
Debug Array2(0)    ; То же самое.
End

Пример: Объявление Массивов в потоках.

Define a = 50
Global Dim Array(a+a) ; объявление глобального (Global) Массива.
Array(0)=10              ; задаём значение начального элемента Массива
Threaded.l Dim ArrayT(50) ; объявление потокового (Threaded) Массива. Для указания длины не допускается использовать переменные.
ArrayT(0)=30              ;  присвоение значения 30 элементу (0), Массива Array(), являющегося экземпляром основного потока.

Procedure Thread(f)
    Debug Array(0)        ; Будет 10, поскольку переменная Массив Array() является глобальным (в любом потоке)
    Debug ArrayT(0)          ; Будет 0, при запуске в отдельном потоке и 30 в основном потоке (то есть, при простом вызове этой же процедуры).
EndProcedure

Thread = CreateThread(@Thread(), 0)  ; запуск процедуры в отдельном потоке
WaitThread(Thread)                    ; Ждём завершения потока.
Thread(f)                            ; простой вызов процедуры
End

Пример: Объявление Массивов в модуле.

Global Dim Array(50)  ; Объявляем глобальный (Global) Массив в Глобальном пространстве имён.
Array(0)= 50
DeclareModule varmudul ; Декларация доступа к объектам модуля (доп. пространства имён).
    Define Dim Array1(50); Объявляем локальный Массив и делаем его доступным вне этого модуля.
    Global Dim Array2(50); Тоже с глобальным Массивом
EndDeclareModule

Module varmudul
    Global Dim Array3(50)  ; объявляем глобальный (Global) Массив, приватный для этого модуля.
    Array1(0)= 100
    Array2(0)= 200
    Array3(0)= 300
    Debug Array1(0)  ; Внутри модуля есть доступ ко всем внутренним Массивам
    Debug Array2(0)
    Debug Array3(0)
    ; Debug Array(0) ; Здесь будет ошибка, так как Массив объявлен в Глобальном пространстве имён, но в модуле не доступен.
EndModule

Debug varmudul::Array1(0)  ; Здесь доступ к Массиву есть. Будет 100.
Debug varmudul::Array2(0)    ; Тоже. Будет 200.
                            ; Debug varmudul::Array3(0) ; Здесь будет ошибка, так как Массив Array3() не доступен вне модуля.
Debug Array(0)                ; В Глобальном пространстве имён Массив Array() доступен.
End

Пример: одномерный Массив со структурным типом (Структурированный Массив).

Define a = 50
Structure Test  ; Создаём шаблон структуры.
    x.l
    y.l
EndStructure

Dim MyArray.Test(a + a) ; Объявляем Массив со структурным типом (типом определяемым пользователем).
For q=0 To 5            ;  В цикле заносим данные во все экземпляры структуры (все элементы Массива).
    MyArray(q)\x=q        ; каждый элемент этого Массива состоит из независимых переменных ‘x.l’ и ‘y.l’
    MyArray(q)\y=q
Next q

For q=0 To 5  ;  В цикле отображаем содержимое всех полей всех экземпляров структуры Test
    Debug MyArray(q)\x
    Debug MyArray(q)\y
Next q

Массивы можно использовать в качестве членов структур.
Статические Массивы объявляются как члены структур, без ключевого слова Array.
Динамические Массивы объявляются как члены структур, с ключевым словом Array.
Длина Массивов - членов структур не может указываться переменными!

Пример: Использование Массивов в качестве членов структуры.

#a = 10
Structure Param  ; Создаём шаблон структуры Param.
    x.l            ; все члены этой структуры объявлены с типом Long
    y.l
    z.l[#a+0]      ; Статический Массив, 10 элементов (от 0 до 9).  Длина Массива указывается числами или константами.
    Array Age.l(10)    ; Динамический Массив, 11 элементов (от 0 до 10). Длина Массива указывается числами или константами.
EndStructure

Person.Param\x = 100  ; Создание экземпляра структуры Param, в виде переменной Person с типом Param, и присвоение полю "x" значения 100
Person\y = 200          ; Присвоение полю "y" значения 200
Person.Param\z[0] = 300; Присвоение полю "z" значения 300
Person\Age (0) = 400  ; Присвоение полю "Age(0)" (элементу 0 Массива Age() ) значения 400
Debug "вывод данных:  " + Person\x +" , "+ Person\y +" , "+ Person\z +" , "+ Person\Age (0)

Пример: Использование Массива указателей для доступа к экземплярам структуры Point.

Define Point1.Point, Point2.Point ; Объявляем 2 экземпляра структуры 'Point' в виде 2-х переменных с типом 'Point'.
Dim *myarray.Point(1)              ; Объявляем Массив указателей с типом 'Point', (Point - это предопределенный тип в PureBasic)
*myarray (0) = @Point1              ; Первый указатель сохраняет адрес переменной Point1
*myarray (1) = @Point2              ; Второй указатель сохраняет адрес переменной point2
*myarray (0)\x = 10                  ; Присваиваем значение 10 переменной Point1\x через указатель
*myarray (1)\x = 20                  ; Присваиваем значение 20 переменной Point2\x через указатель
Debug Point1\x                      ; Отображаем переменную Point1\x
Debug Point2\x                      ; Отображаем переменную Point2\x

Пример: Расчёт объёма занимаемой Массивом памяти.

Structure Type ; Создаём шаблон структуры "Type", он же составной тип определённый пользователем под именем "Type".
    Ascii.a      ; Занимает 1 байт
    Word.w      ; Занимает 2 байта
    Long.l      ; Занимает 4 байта
    Quad.q      ; занимает 8 байтов
EndStructure

Dim Myarray.l(99)  ; Объявляем Массив 100 элементов с типом "Long" (4 байта на элемент).
Debug SizeOf(Long) * (ArraySize (Myarray())+1)  ; Отобразит размер памяти занятой Массивом Myarray()

Dim Myarrayst.Type(99)  ; Объявляем Массив 100 элементов со структурным типом "Type" (1+2+4+8 байт на элемент)
Debug SizeOf(Type) * (ArraySize (Myarrayst())+1)  ; Отобразит размер памяти занятой Массивом Myarrayst()

Dim MyarrayD.w(99,9)  ; Объявляем двухмерный Массив 100 *10 элементов с типом "Word"
Debug SizeOf(Word) * (ArraySize (MyarrayD())+1) * 10  ; Отобразит размер памяти занятой Массивом MyarrayD()

С помощью ключевого слова Array, Массив можно передать в процедуру в качестве параметра. Массив в процедуру передаётся "по ссылке", это значит, что исходный Массив не копируется, а вместо этого функции в процедуре работают с самим исходным Массивом.

Пример: Массив как параметр процедуры.

Procedure fill(Array Numbers(1), Length)  ; Число 1 представляет собой количество измерений Массива.
    For i = 0 To Length
        Numbers(i) = i
    Next
EndProcedure

Dim Numbers(10)      ; Объявляем массив Numbers().
fill(Numbers(), 10)    ; Здесь Массив Numbers() будет передан как параметр.
For i = 0 To 10
    Debug Numbers(i)
Next i
FreeArray (Numbers())

Для быстрого обмена содержимого элементов Массива между собой предусмотрено ключевое слово Swap. Менять значения можно между элементами Массивов, Связных списков и Хеш-карт, а также переменными, причём они должны быть одного и того же базового типа (Float, Long…)

Пример: Обмен содержимого элементов Массива.

Dim Array1.l(5) ; Объявляем Массив с типом Long
a.l = 33        ; Объявляем переменную с типом Long (обменять можно только значения с одинаковым типом)
Array1(2) = 10    ; Установим начальное содержимое
Array1(3) = 44
Swap Array1(2), Array1(3)  ; Поменяем местами 2 элемента Массива

Debug "Содержимое Массива после обмена:"
Debug Array1(2)    ; Отобразит 44
Debug Array1(3)      ; Отобразит 10

Swap Array1(2), a  ; Заменим значение в элементе Массива на значение из переменной.
Debug Array1(2)      ; Отобразит 33

ReDim

ReDim name.<type>(<expression>, [<expression>], ...)

Описание

Ключевое слово ReDim используется для изменения размера уже существующего Динамического Индексного Массива с сохранением его содержимого. Новый размер может быть больше или меньше, но количество измерений Массива изменить нельзя. При увеличении размера Массива, данные сохраняются полностью. При уменьшении размера Массива, данные сохраняются только в оставшихся элементах, если снова применить ReDim для восстановления удалённых элементов – данных в них не окажется.
При применении оператора ReDim тип Массива остаётся прежним и не может быть изменён. Если ReDim используется с многомерным Массивом, то изменить можно только последнее измерение.
Также возможно изменение размера динамического Массива, который является членом конкретного экземпляра структуры, при этом размер Массивов в других экземплярах этой же структуры останется прежним. Данные сохраняются так же, как и в обычном случае.

Пример: Изменение размера одномерного Массива.

Dim MyArray.l(1) ; У нас есть 2 элемента
MyArray(0) = 1
MyArray(1) = 2

ReDim MyArray(4) ; Теперь будет 5 элементов
MyArray(2) = 3

For k = 0 To 2
    Debug MyArray(k)
Next

Пример: Изменение размера многомерного Массива.

Dim MyArray.l(4,2)  ; Объявляем двумерный Массив с размерами 5 и 3 элемента (общее количество элементов 5x3=15)

r1=ArraySize(MyArray() , 1)
r2=ArraySize(MyArray() , 2)
Debug "Размеры: " + r1 + " , " + r2

ReDim MyArray(4,4) ; Размер последнего измерения Массива изменяем с 2 на 4, теперь в нём 5x5 элементов.

r1=ArraySize(MyArray() , 1)
r2=ArraySize(MyArray() , 2)
Debug "Размеры: " + r1 + " , " + r2

Пример: Изменение размера динамического Массива, который является членом структуры.

Structure Par      ; Создаём шаблон структуры Par.
    Array Age.l(10); Динамический Массив с типом Long, 11 элементов в запасе (от 0 до 10)
EndStructure

Pers.Par\Age (10) = 100  ; Создание экземпляра структуры Par, в виде переменной "Pers" с типом Par, присвоение полю "Age(10)" значения 100.
ReDim Pers\Age (20)
Pers\Age (15) = 200    ; Присвоение полю "Age(15)" (элементу 15 Массива Age() ) значения 400.

;Person.Par\Age (15) = 100 ; эта строка выдаст ошибку, так как Массив экземпляра Person имеет размер заданный шаблоном структуры (10+1).

Debug "Вывод данных: " + Pers\Age(10) + "  ,  " + Pers\Age(15)