Массивы visual basic: Массивы — Visual Basic | Microsoft Learn

5) Массивы VB.Net — CoderLessons.com

Что такое массив?

Массив – это структура данных, используемая для хранения элементов одного типа данных. Элементы упорядочены последовательно, причем первый элемент имеет индекс 0, а последний элемент – индекс n-1, где n – общее количество элементов в массиве.

В этом уроке вы узнаете:

• Что такое массив?
• Как объявить и инициализировать массив
• Массивы фиксированного размера
• Динамические массивы
• Извлечение содержимого массива
• Добавление новых элементов в массив
• Стирание массива
• Функция разделения
• Функция соединения

Как объявить и инициализировать массив

В VB.NET массивы объявляются с помощью оператора Dim. Например:

Dim myData() As Integer

В приведенном выше примере мы определили массив с именем myData, и он должен содержать элементы целочисленного типа данных. В следующем примере демонстрируется, как мы можем объявить массив для хранения строковых элементов:

Dim myData(10) As String

Мы определили массив с именем myData для хранения 10 строк.

Мы можем инициализировать массивы во время их объявления. Например:

Dim myData() As Integer = {11, 12, 22, 7, 47, 32}

Мы объявили массив myData и добавили в него 6 целочисленных элементов. Это также может быть сделано для случая строк:

Dim students() As String = {"John", "Alice", "Antony", "Gloria", "jayden"}

Мы создали массив с именем студентов и добавили к нему 5 имен.

Массивы фиксированного размера

Массив фиксированного размера содержит фиксированное количество элементов. Это означает, что вы должны определить количество элементов, которые будут храниться при его определении. Предположим, вам нужен массив для хранения только 3 имен учеников. Вы можете определить и инициализировать массив следующим образом:

Dim students(0 to 2) As String 
      
students(0) = "John"
students (1) = "Alice"
students (2) = "Antony"

Мы начали с объявления массива строк с именем студентов. От 0 до 2 объявляет, что массив будет хранить элементы от его индекса 0 до индекса 2, что означает, что у нас будет всего 3 элемента.

Чтобы добавить элементы в массив, мы использовали имя массива и указали индекс, в котором будет храниться элемент. Например, имя John будет храниться в индексе 0 массива, что означает, что оно будет формировать первый элемент массива. Антоний будет последним элементом массива.

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

Это массив, который может содержать любое количество элементов. Размер массива может увеличиться в любое время. Это означает, что вы можете добавлять новые элементы в массив в любое время. Чтобы продемонстрировать это, давайте сначала определим массив целых чисел:

Dim nums() As Integer

Мы определили целочисленный массив с именем nums. Теперь вам нужно добавить два элемента в массив, оставляя место для его изменения. Вы должны использовать оператор ReDim следующим образом:

ReDim nums(1)
nums(0) = 12
nums(1) = 23

Наш массив теперь имеет два элемента в индексах 0 и 1. Нам нужно добавить третий элемент в индекс 3, сохранив два элемента, которые у него уже есть. Мы можем сделать это следующим образом:

ReDim Preserve nums(2)
nums(2) = 35

Массив теперь имеет три элемента.

Извлечение содержимого массива

Получение означает доступ к элементам массива. Чтобы получить доступ к элементу массива, мы используем его индекс. Давайте продемонстрируем это на примере.

Шаг 1) Начните с создания нового консольного приложения.

Шаг 2) Добавьте следующий код в приложение:

Module Module1
    Sub Main()
       Dim students(0 to 2) As String 
        students(0) = "John"
        students(1) = "Alice"
        students(2) = "Antony"
        Console.WriteLine("First student is {0} ", students(0))
        Console.WriteLine("Second student is {0} ", students(1))
        Console.WriteLine("Third student is {0} ", students(2))
        Console.ReadKey()
    End Sub
End Module

Шаг 3) Запустите код, нажав кнопку «Пуск» на панели инструментов. Вы получите следующее окно:

Мы использовали следующий код:

Объяснение кода:

1. Создание модуля с именем Module1.
2. Создание основной подпроцедуры.
3. Создание массива с именем студентов для хранения строковых элементов. Массив будет хранить элементы от индекса 0 до индекса 2, что означает, что он будет иметь в общей сложности 3 элемента.
4. Добавляя имя John в качестве первого элемента массива, то есть John хранится с индексом 0.
5. Добавляем имя Алиса в качестве второго элемента массива, то есть Алиса хранится по индексу 1.
6. Добавляя имя Антоний в качестве третьего элемента массива, то есть Антоний хранится в индексе 2.
7. Печать некоторого текста и элемента, сохраненного с индексом 0 массива студентов на консоли. Students (0) помогает нам получить доступ к элементу по индексу 0 массива с именем Students.
8. Печать некоторого текста и элемента, хранящегося в индексе 1 массива студентов на консоли. Студенты (1) помогают нам получить доступ к элементу в индексе 1 массива с именем студентов.
9. Печать некоторого текста и элемента, хранящегося в индексе 2 массива студентов на консоли. Студенты (2) помогают нам получить доступ к элементу в индексе 2 массива с именем студентов.
10. Пауза в окне консоли или ожидание действия пользователя для его закрытия.
11. Конец подпроцедуры.
12. Конец модуля.

Добавление новых элементов в массив

Это произойдет, только если у вас есть динамический массив. Если вы объявили размерный массив фиксированного размера, и он полон элементов массива, вы не можете добавлять в него новые элементы. В следующем примере показано, как добавить новые элементы в динамический массив:

Шаг 1) Начните с создания нового консольного приложения.

Шаг 2) Добавьте следующий код в приложение:

Module Module1
    Sub Main()
        Dim nums() As Integer
        ReDim nums(1)
        nums(0) = 12
        nums(1) = 23
        For x = 0 To nums.Length - 1
            Console.WriteLine("Initial array element: {0}", nums(x))
        Next
        ReDim Preserve nums(2)
        nums(2) = 35
        For x = 0 To nums. Length - 1
            Console.WriteLine("Final array element: {0}", nums(x))
        Next
        Console.ReadKey()
    End Sub
End Module

Шаг 3) Нажмите кнопку «Пуск» на панели инструментов, чтобы запустить код. Вы должны получить следующее окно:

Мы использовали следующий код:

Объяснение кода:

1. Создание модуля с именем Module1.
2. Создание основной подпроцедуры.
3. Создание массива с именем nums для хранения целочисленных значений.
4. Указание того, что в приведенном выше массиве будут храниться два элемента, то есть с индексами 0 и 1, в то же время оставляя место для изменения размера.
5. Добавление элемента 12 в индекс 0 массива номеров.
6. Добавление элемента 23 в индекс 1 массива nums.
7. Использование цикла for для создания переменной x, чтобы помочь нам перебирать от первого до последнего элемента массива nums. Обратите внимание, что массив теперь имеет два элемента, 12 и 23.
8. Печать некоторого текста и элементов массива на консоли.
9. Завершение цикла for и переход к следующей части кода.
10. Измените размеры массива, чтобы элементы могли иметь индексы от 0 до 2. Теперь он сможет хранить 3 элемента, а не 2. Ключевое слово Preserve помогает нам поддерживать текущие элементы массива, то есть 12 и 23.
11. Добавление элемента 35 в индекс 2 массива. Массив теперь имеет три элемента: 12, 23 и 35.
12. Использование цикла for для создания переменной x, чтобы помочь нам перебирать от первого до последнего элемента массива nums. Обратите внимание, что теперь массив состоит из трех элементов: 12, 23 и 35.
13. Печать некоторого текста и элементов массива на консоли.
14. Завершение цикла for и переход к следующей части кода.
15. Приостановите окно консоли, ожидая действий пользователя, чтобы закрыть его.
16. Конец подпроцедуры.
17. Конец модуля.

Удаление массива

Рекомендуется стирать массив после того, как с ним покончено, в основном, когда вы имеете дело с динамическим массивом. Это поможет вам освободить место в памяти.

Чтобы удалить массив, вам нужно просто вызвать оператор Erase, а затем имя массива. Например:

Dim nums(1) As Integer
        nums(0) = 12
        nums(1) = 23
Erase nums

Мы объявили массив целых чисел с именем nums и добавили к нему два элемента. Оператор Erase nums удалит массив.

Функция разделения

Функция разбиения, предоставляемая Visual Basic .NET, помогает нам разбить строку на части и сохранить их в массиве. В следующем примере показано, как использовать эту функцию:

Шаг 1) Создайте новое консольное приложение.

Шаг 2) Добавьте следующий код в приложение:

Module Module1
    Sub Main()
        Dim myarray() As String
        Dim guru99 As String
        Dim x As Integer
        guru99 = "Welcome, to, Guru99"
        myarray = Split(guru99, ", ")
        For x = LBound(myarray) To UBound(myarray)
            Console.WriteLine(myarray(x))
        Next
        Console. ReadKey()
    End Sub
End Module

Шаг 3) Запустите код, нажав кнопку «Пуск» на панели инструментов. Вы должны получить следующее окно:

Мы использовали следующий код:

Объяснение кода:

1. Создание модуля с именем Module1.
2. Начало основной подпроцедуры.
3. Создание массива с именем myarray для хранения строковых значений.
4. Создание строковой переменной с именем guru99.
5. Создание целочисленной переменной с именем x.
6. Присвоение строки переменной guru99.
7. Разбиваем строку выше на части и помещаем их в массив с именем myarray. “,” (Запятая) – это разделитель, поэтому функция разбиения будет использовать его для обозначения конца различных частей строки.
8. Использование переменной x для перебора массива с именем myarray. LBound и UBound определяют нижние и верхние границы массива соответственно.
9. Печать значений массива с именем myarray на консоли.
10. Завершение цикла и

Функция соединения

Функция join помогает нам объединять несколько массивов в одну строку. Следующий пример демонстрирует это:

Шаг 1) Начните с создания нового консольного приложения.

Шаг 2) Добавьте следующий код в приложение:

Module Module1
    Sub Main()
        Dim students(0 To 2) As String
        students(0) = "John"
        students(1) = "Alice"
        students(2) = "Antony"
        Dim classmates As String
        classmates = Join(students, ", ")
        Console.WriteLine(classmates)
        Console.ReadKey()
    End Sub
End Module

Шаг 3) Запустите код, нажав кнопку «Пуск» на панели инструментов:

Мы использовали следующий код:

Объяснение кода:

1. Создание модуля с именем Module1.
2. Создание основной подпроцедуры.
3. Создание массива с именем студентов для хранения 3 строковых значений.
4. Добавление имени Джона в индекс 0 массива.
5. Добавление имени Алиса в индекс 1 массива.
6. Добавление имени Антония в индекс 2 массива.
7. Определение переменной с именем одноклассников типа данных строки.
8. Соединение всех элементов массива студентов и разделение их с помощью, (запятая). Результат этой операции будет присвоен переменной одноклассники.
9. Печать содержимого переменной одноклассников на консоли.
10. Приостановка окна консоли в ожидании действий пользователя по его закрытию.
11. Завершение основной подпроцедуры.
12. Завершение модуля.

Резюме

• Массивы используются для хранения элементов данных, принадлежащих к одному типу данных.
• Динамический массив позволяет пользователю изменять его размер, добавляя в него больше элементов. Вы используете команду ReDim для добавления элементов в существующий массив
• Размер массива фиксированного размера не может быть изменен.
• Элементы массива упорядочены с использованием индексов, причем первый элемент имеет индекс 0, а последний элемент – индекс n-1, где n – общее количество элементов массива.
• Массивы могут быть удалены с помощью функции стирания
• Вы можете использовать функции split и join для разделения или объединения строкового массива соответственно

Массивы в Visual Basic

Visual
Studio 2012

Другие
версии

4
из 8 оценили этот материал как
полезный — Оценить
эту тему

Массив
представляет собой набор значений,
логически связанных друг с другом,
например, число учеников в каждом классе
в школе.

С
помощью массива, можно обратиться к
этим связанным значениям тем же именем
и использовать номер, вызвав индексом
или подстрочным, который необходимо
сообщить им врозь. Отдельные
значения, называются элементами
массива. Они
сопредельны от индекса 0 до наибольшее
значение индекса.

В
отличие от массива, переменная, содержащая
одно значение называется скалярной переменной.

• Элементы
  массива в простом массиве

• Создание
  массива

• Объявление
  массива

• Сохранение
  значений в массиве

• Заполнение
  массива начальными значениями

• Итерация
  через массив

• Массивы
  массивов

• Массивы
  нулевой длины

• Размер
  массива

• Типы
  массива и другие типы

• Коллекции
  как альтернатива массивам

Элементы
массива в простом массиве

В
следующем примере объявляется переменная
массива для хранения числа учеников в
каждом классе школы.

VB

Dim
students(6) As
Integer

Массив students в
предыдущем примере содержит 7
элементов. Индексы
элементов лежат в диапазоне от 0 до
6. Использовать
этот массив проще, чем 7 объявление
переменных.

На
следующем рисунке показан массив students. Для
каждого элемента массива:

Элементы
массива «учеников»

В
следующем примере показано обращение
к первому, второму и последнему элементу
массива students.

VB

Dim
kindergarten As
Integer
= students(0)

Dim
firstGrade As
Integer
= students(1)

Dim
sixthGrade As
Integer
= students(6)

MsgBox(«Students
in kindergarten = »
& CStr(kindergarten))

MsgBox(«Students
in first grade = »
& CStr(firstGrade))

MsgBox(«Students
in sixth grade = »
& CStr(sixthGrade))

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

Считается,
что массив students в
пользах предыдущего примера и одноразмерн
один индекс.  Массив,
использующий более одного индекса,
называется многомерным массивом. Дополнительные
сведения см. в разделе остальная часть
этих разделах и Размерность
массивов в Visual Basic.

Создание
массива

Можно
указать размер массива можно несколькими
способами. Можно
указать размер если массив объявляется,
как показано в следующем примере.

VB

Dim
cargoWeights(10) As
Double

Dim
atmospherePressures(2, 2, 4, 10) As
Short

Dim
inquiriesByYearMonthDay(20)()() As
Byte

Можно
также использовать предложение New,
чтобы указать размер массива, когда он
создал, как показано в следующем примере.

VB

cargoWeights
= New
Double(10)
{}

atmospherePressures
= New
Short(2,
2, 4, 10) {}

inquiriesByYearMonthDay
= New
Byte(20)()()
{}

Если
уже существует массив, можно переопределить
его размер с помощью оператора Redim. Можно
указать, что оператор Redim должна
содержать значения, которые в массиве
или можно указать, что она создает пустой
массив.  В
следующем примере показаны различные
варианты использования оператора Redimдля
изменения размера существующего массива.

VB

‘
Assign a new array size and retain the current element values.

ReDim
Preserve
cargoWeights(20)

‘
Assign a new array size and retain only the first five element
values.

ReDim
Preserve
cargoWeights(4)

‘
Assign a new array size and discard all current element values.

ReDim
cargoWeights(15)

Дополнительные
сведения см. в разделе Оператор
ReDim (Visual Basic).

Объявление
массива

Переменная
массива объявляется так же, как любая
другая переменная, с помощью
инструкции Dim. Выполните
типом или именем переменной с одним или
несколькими парой скобок, чтобы показать,
что он будет содержать массив, а не
скаляр, переменная, содержащая одно
значение.

После
того как объявить массив, можно указать
его размер с помощью Оператор
ReDim (Visual Basic).

В
следующем примере объявляется переменная
одномерного массива, добавив пару скобок
после типа.  В
этом примере также определяется измерения
массива с помощью Оператор
ReDim (Visual Basic).

VB

Dim
cargoWeights() As
Double

В
следующем примере объявляется переменная
многомерного массива путем добавления
пару скобок после типа и установив
запятые внутри скобок для отделения
измерений. В
этом примере также определяется измерения
массива с помощью Оператор
ReDim (Visual Basic).

VB

Dim
atmospherePressures(,,,) As
Short

Для
объявления переменной массива массивов
добавьте пару скобок после имени
переменной для каждого уровня вложенных
массивов.

VB

Dim
inquiriesByYearMonthDay()()() As
Byte

Предыдущие
примеры объявляют переменных массива
массивов, но не присвоено. По-прежнему
необходимо создать массив, инициализировать
его и присвоить его переменной.

Сохранение
значений в массиве

К
любому местоположению в массиве можно
получить доступ, используя индекс
типа Integer. Можно
сохранять и извлекать значения массива,
ссылаясь на местоположение в массиве
с помощью индекса места, приведенного
в скобках. 2)

Dim
firstGuess = estimates(i, j, k)

Заполнение
массива начальными значениями

С
помощью литералов массива можно создать
массив, содержащий начальный набор
значений. Литерал
массива состоит из списка разделенных
запятыми значений, заключенных в фигурные
скобки ({}).

При
создании массива с помощью литерала
массива можно либо указать тип массива,
либо использовать вывод типа для
определения типа массива. В
следующем коде показаны оба параметра.

VB

Dim
numbers = New
Integer()
{1, 2, 4, 8}

Dim
doubles = {1.5, 2, 9.9, 18}

При
использовании определение типа, тип
массива определяется доминантным
введите список значений, передаваемого
для литерала массива. Главный
тип уникальный тип, к которому все другие
введите литерал массива может
расширить. Если
этот уникальный тип не может быть
определен, то главный тип уникальный
тип, к которому все другие типа в массив
может уменьшить. Если
ни один из указанных уникальных типов
нельзя определить, главным типом
будетObject.  Например,
если список значений, передаваемого в
литерал массива содержит значения
типа Integer, Long и Double,
то результирующий массив
типаDouble. и Integer и Long расширяют
только к Double. Поэтому Double является
главным типом. Дополнительные
сведения см. в разделе Расширяющие
и сужающие преобразования (Visual Basic). Эти
правила зависимости применяются к
типам, которые в результате вывода
становятся основанием для массивов,
локальные переменные, определенные в
члена класса. Хотя
можно использовать литералы массива
при создании переменных класс- уровня,
нельзя использовать определение типа
на уровне класса. В
результате литералы массива, которые
определены на уровне класса вывести
значения, которые предоставляются для
литерала массива как тип Object.

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

VB

Dim
values As
Double()
= {1, 2, 3, 4, 5, 6}

Массивы в Visual Basic

Массив Visual Basic — это набор элементов, который хранится в одной переменной и доступен по индексу.

Для объявления массива необходимо дополнить имя переменной символом скобки ();

Dim arr() As Double 'объявление массива двойников
 

Элементы массива доступны по индексу

Тусклый обр(2) как строка
Dim elem As String
elem = arr(0) 'получение первого элемента
 

Инициализация массивов в Visual Basic

Массивы — набор фиксированного размера. Размер можно указать при объявлении.

Dim arr(2) As Double 'объявление массива из 3 удвоений (от 0 до 1)
 

Единственное число в скобках представляет собой верхнюю границу массива. По умолчанию массивы отсчитываются от 0. Таким образом, указание (5) в качестве размера массива означает, что в массиве будет 6 элементов.

Можно явно указать верхнюю и внутреннюю границы массива

Dim arr(1 To 5) As Double 'объявление массива из 5 двойников (от 1 до 5)
 

Рекомендуется использовать массив с отсчетом от 0, так как это обычная практика для разных языков программирования.

Элементы массива доступны и могут быть изменены по их индексу. Если указанный индекс находится за пределами массива, возникает ошибка времени выполнения.

В некоторых случаях размер массива не может быть известен во время компиляции и будет определен во время выполнения. В этом случае массив может быть объявлен без размера (т.е. не инициализирован). Размер такого массива может быть изменен динамически с помощью Ключевое слово ReDim .

Dim arr() как двойной
ReDim arr(2) 'инициализация размера массива
 

Для получения верхней и нижней границ массива можно использовать UBound и LBound соответственно.

Функцию UBound нельзя использовать для определения того, инициализирован ли массив, поскольку она вызовет исключение при использовании на неинициализированном массиве. Используйте функцию IsArrayInitialized из приведенного ниже примера, чтобы безопасно определить состояние массива.

Ошибка выполнения 9: нижний индекс вне диапазона при чтении верхней границы неинициализированного массива

Подпрограмма InitializeArray()
    
    Dim doubleArr() As Double 'не инициализированный массив
    
    'Массив инициализирован = False
    Debug.Print "Массив инициализирован =" & IsArrayInitialized(doubleArr)
    
    ReDim doubleArr(2) 'изменение размера массива для хранения 3 двойных значений
    
    'Массив инициализирован = True размера 3
    Debug.Print "Инициализируется массив = " & IsArrayInitialized(doubleArr) & "размера" & GetArraySize(doubleArr)
    
    Dim textArr(4) As String 'инициализируется при объявлении
    'Массив инициализирован = True размера 5
    Debug.Print "Инициализируется массив = " & IsArrayInitialized (textArr) & " размера " & GetArraySize (textArr)
    
    'инициализация с пользовательскими границами
    Dim intArr (от 1 до 5) как целое число
    'Массив инициализирован = True размера 5 (от 1 до 5)
    Debug. Print "Инициализируется массив = " & IsArrayInitialized (intArr) & " размера " & GetArraySize (intArr) & " (" & LBound (intArr) & " to " & UBound (intArr) & ")"
    
    'Debug.Print intArr(0) 'Ошибка выполнения 9: индекс вне диапазона
    
Конец сабвуфера
Функция IsArrayInitialized (vArr As Variant) как логическое значение
    Если Массив(Арр) Тогда
        
        При ошибке GoTo End_
        
        Если UBound(vArr) >= 0 Тогда
            ИсАррайИнициализед = Истина
            Выход из функции
        Конец, если
        
    Конец, если
Конец_:
    ИсАррайИнициализед = Ложь
    
Конечная функция
Функция GetArraySize (vArr как вариант) как целое число
    
    Если IsArrayInitialized(vArr) Тогда
        GetArraySize = UBound(vArr) - LBound(vArr) + 1
    Еще
        GetArraySize = 0
    Конец, если
    
Конечная функция
 

Заполнение массива данными

Элементы массива можно рассматривать как отдельные переменные, и к элементам массива применяются те же правила чтения и редактирования данных, что и к любой другой переменной. Обратитесь к статье Переменные для получения дополнительной информации.

Тусклый обр(2) как двойной
arr() = 10 'изменение значения переменной в 
Debug.Print arr() 'чтение значения переменной в 
 

Sub FillArray ()
    
    Dim doubleArr(2) As Double 'массив, инициализированный из объявления
    Dim i как целое число
    
    Для i = 0 To UBound(doubleArr)
        двойнойАрр(я) = я + 1
    Следующий
    
    '1 2 3
    Для i = 0 To UBound(doubleArr)
        Debug.Print doubleArr(i)
    Следующий
    Dim vArr как вариант
    vArr = Array("A", "B", "C", "D") 'заполнение массива вариантов при инициализации
    
    'А Б В Г
    Для i = 0 To UBound(vArr)
        Отладка. Печать vArr(i)
    Следующий
    
Конец сабвуфера
 

Изменение размера массива

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

.
Dim arrCanResize() As Integer 'размер этого массива может быть изменен
Dim arrCannotResize(3) As Integer 'размер этого массива не может быть изменен
 

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

Ошибка компиляции: размер массива уже определен

Удаление существующих значений

Ключевое слово ReDim позволяет изменить размер массива. В этом случае все существующие значения будут очищены.

Sub ResizeAndClearArray()
    
    Dim doubleArr() как двойной
    Dim i как целое число
    
    ReDim doubleArr(2)
    
    Для i = 0 To UBound(doubleArr)
        двойнойАрр(я) = я + 1
    Следующий
    
    'изменение размера и очистка массива
    ReDim doubleArr(3)
    двойнойАрр(3) = 4
    
    0 0 0 4
    Для i = 0 To UBound(doubleArr)
        Debug.Print doubleArr(i)
    Следующий
Конец сабвуфера
 

Сохранение существующих значений

Для сохранения существующих значений массива необходимо использовать ключевое слово ReDim Preserve .

Sub ResizeAndPreserveArray()
    Dim doubleArr() As Double 'массив, инициализированный из объявления
    Dim i как целое число
    ReDim doubleArr(3)
    
    Для i = 0 To UBound(doubleArr)
        двойнойАрр(я) = я + 1
    Следующий
    
    'изменение размера массива и сохранение значений
    ReDim Preserve doubleArr(4)
    двойнойАрр(4) = 5
    
    '1 2 3 4 5
    Для i = 0 To UBound(doubleArr)
        Debug. Print doubleArr(i)
    Следующий
Конец сабвуфера
 

Динамическое изменение размера массивов

В некоторых случаях может быть заранее неизвестно размер массива или когда будет добавлен первый элемент (если он есть).

В этом случае целесообразно инициализировать массив только при необходимости. Можно использовать следующий оператор, чтобы определить, не инициализирован ли массив (не массив) = -1 , и инициализировать с первым элементом или динамически изменить размер с сохранением существующих значений.

Dim evenNumbersArr() как целое число
Dim i как целое число
Для i = от 0 до 100
    Если i Mod 2 = 0, то
                
        Если (Не четныйЧислоАрр) = -1 Тогда
            ReDim evenNumbersArr (0)
        Еще
            ReDim Preserve evenNumbersArr (UBound (evenNumbersArr) + 1)
        Конец, если
        
        дажеNumbersArr (UBound (evenNumbersArr)) = i
    Конец, если
Следующий
 

Двумерный массив

Двумерный массив позволяет хранить табличные данные и может быть объявлен в следующем формате

Dim table(, ) как строка
 

Размер двумерного массива можно изменить, но если это необходимо для сохранения значений, можно изменить размер только второго (столбцового) измерения.

Поддвумерные массивы ()
    
    '3 строки и 4 столбца
    Dim matrixArr() как строка
    ReDim matrixArr(2, 3)
        
    Dim i как целое число
    Dim j как целое число
    
    Для i = 0 To UBound (matrixArr, 1)
        Для j = 0 To UBound (matrixArr, 2)
        matrixArr(i, j) = (i + 1) & "." & (j + 1)
        Следующий
    Следующий
    
    'первое измерение не может быть изменено
    'ReDim Preserve matrixArr(5, 5) 'Ошибка выполнения 9: индекс вне диапазона
    
    'второе измерение может быть изменено с сохранением данных
    ReDim Сохранить матрицуArr(2, 4)
    
    ReDim matrixArr(5, 5) 'размеры массива могут быть изменены при очистке
    
Конец сабвуфера
 

Значения двумерного массива (matrixArr) в окне Watch из кода выше

Учебное пособие по массивам Visual Basic

Адам Веманн

В этом уроке вы узнаете разницу между массивом фиксированного размера и динамическим массивом, как правильно объявить
каждый, как получить к ним доступ, как пройтись по ним, как их стереть и кое-что еще.
Этот учебник применим ко всем версиям Visual Basic, однако версии до Visual
Базовая версия 6.0 не включает функцию разделения и объединения.
Ниже приведен список основных тем, которые будут обсуждаться.

• Типы массивов
• Массивы фиксированного размера
• Динамические массивы
• Получение содержимого массива
• Добавление новых элементов на лету
• Стирание массива
• Функция разделения
• Функция соединения
• Многомерные массивы

Если вы не можете найти то, что вам нужно здесь, вы можете проверить
основной раздел программирования
для дополнительного кода VB и учебных пособий.

Типы массивов

Массив очень похож на стойку для компакт-дисков. Вы знаете: одна из тех прямоугольных коробок с прорезями для компакт-дисков, один над другим.
Существует два типа массивов Visual Basic: фиксированного размера и динамические.

Массивы фиксированного размера

Массив фиксированного размера наиболее точно соответствует аналогии с нашей стойкой для компакт-дисков. Существует ограниченное количество слотов, в которые вы можете вставлять компакт-диски. Представьте, что у вас есть три компакт-диска: один от Deftones, другой от Tool и третий от Disturbed. Чтобы все это поместилось в стойку, в стойке должно быть не менее трех слотов. Таким образом, вы объявляете свою стойку для компакт-дисков как имеющую три слота:

 Dim strCDRack(от 0 до 2) Как строка 

Вы только что создали переменную strCDRack, которая содержит три слота (#0, #1 и #2) и имеет тип данных String. Теперь вы можете вставлять в него свои компакт-диски:

 Dim strCDRack(от 0 до 2) Как строка
      
strCDRack(0) = "Защитные тона"
strCDRack(1) = "Инструмент"
strCDRack(2) = "Нарушен" 

Обратите внимание, что каждая из трех новых строк начинается с имени переменной, а затем указывается номер элемента, прежде чем будет присвоено значение. Это все равно, что пронумеровать слоты на вашей стойке для компакт-дисков, начиная с 0 до 2, а затем вставить компакт-диск в каждый слот.
Формат объявления массива следующий:

Dim|Public|Private ArrayName ( Subscript ) As DataType

• Dim , Public и Private объявляют массив и его область действия. Использование Dim в процедуре сделает массив доступным только внутри этой процедуры. Использование его в разделе «Общие объявления» сделает его доступным для всех процедур в этом модуле. Частный имеет тот же эффект и должен использоваться только на модульном уровне. Использование Public сделает массив доступным на протяжении всего проекта.
• ArrayName — имя массива.
• Нижний индекс — это размеры массива.
• DataType — любой допустимый тип данных.

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

Вышел новый компакт-диск Шарлотты Черч, но в вашей стойке всего три слота. Вы не хотите выбрасывать ни один из своих компакт-дисков, чтобы освободить место для нового, поэтому вы решаете использовать свои высшие строительные навыки, чтобы добавить еще один слот. Вы начинаете строить:

 Dim strCDRack() как строка
      
ReDim strCDRack (от 0 до 2) как строка
      
strCDRack(0) = "Защитные тона"
strCDRack(1) = "Инструмент"
strCDRack(2) = "Нарушен" 

Что вы наделали? Ничего плохого, вы только что измерили свой массив другим способом, который допускает расширение. Обратите внимание, что индекс оператора Dim отсутствует. Хорошо; он сообщает VB, что ваш массив является динамическим массивом, а это означает, что вы можете изменить его размер с помощью ReDim .

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

 Dim strCDRack() как строка
      
ReDim strCDRack (от 0 до 2) как строка
      
strCDRack(0) = "Защитные тона"
strCDRack(1) = "Инструмент"
strCDRack(2) = "Встревожено"
      
ReDim сохранить strCDRack (от 0 до 3) как строку
      
strCDRack(3) = "Шарлотта Черч" 

В этом фрагменте есть еще две строки, первая из которых изменяет размер массива на один элемент больше, а вторая устанавливает значение этого элемента. Обратите внимание на ключевое слово Preserve : оно заставляет Visual Basic сохранять значения всех существующих элементов. Без этого ключевого слова все ваши старые компакт-диски будут потеряны, и вы застрянете только с Шарлоттой Черч.

Синтаксис ключевого слова ReDim:

ReDim [Сохранить] ArrayName ( Нижний индекс ) Как Тип данных

• ReDim — это ключевое слово, обозначающее, что мы изменяем размеры массива.
• Сохранить — это необязательное ключевое слово, которое заставляет Visual Basic сохранять значения всех существующих элементов. Без него все элементы вернутся к своим значениям по умолчанию. (Числовые типы данных в 0, строки переменной длины в «» (строка нулевой длины), строки фиксированной длины, заполненные нулями, и пустые варианты.)
• ArrayName — имя массива.
• Нижний индекс — это размеры массива.
• DataType — любой допустимый тип данных. Тип данных не может быть изменен по сравнению с его первоначальным объявлением при использовании ключевого слова ReDim . (Если он изначально не был объявлен как Variant.)

Извлечение содержимого массива

Теперь, когда вы знаете, как построить массив, вы можете спросить, как получить его содержимое. Скажем, вы создали массив имен ваших друзей:

 Dim strFriends(от ​​0 до 6) Как строка
      
strFriends(0) = "Бьянка"
strFriends(1) = "Жана"
strFriends(2) = "Сэм"
strFriends(3) = "Дженна"
strFriends(4) = "Эрин"
strFriends(5) = "Кэролин"
strFriends(6) = "Кейт" 

Это все хорошо и красиво, но вы хотите отображать их имена в последовательных окнах сообщений, поэтому вы создаете цикл:

 Dim strFriends(0 to 6) As String, lngPosition as Long
      
strFriends(0) = "Бьянка"
strFriends(1) = "Жана"
strFriends(2) = "Сэм"
strFriends(3) = "Дженна"
strFriends(4) = "Эрин"
strFriends(5) = "Кэролин"
strFriends(6) = "Кейт"
      
Для lngPosition = LBound(strFriends) To UBound(strFriends)
    MsgBox strFriends(lngPosition)
Далее lngPositionlngPositionlngPosition 

В этом фрагменте кода есть две новые функции. LBound и UBound используются для определения нижней и верхней границ массива. Поскольку strFriends имеет нижнюю границу 0 и верхнюю границу 6. Эти
функции позволяют вам перебирать массив с динамическим размером, и они избавляют вас от необходимости отслеживать размер массива самостоятельно.
С каждой итерацией этого цикла lngPosition будет считать от 0 до 6. Обращаясь к массиву как strFriends(lngPosition) , вы значительно сокращаете объем кода, который вам нужно написать.

Добавление новых элементов на лету

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

 Dim strSongNames() As String 'Массив названий песен
Dim blDimensioned As Boolean 'Размерен ли массив?
Dim strText As String 'Для временного хранения имен
Dim lngPosition as Long 'Counting
      
'Массив еще не определен:
blDimensioned = Ложь
      
Делать
          
    'Спроси название песни
    strText = InputBox("Введите название песни:")
              
    Если СтрТекст "" Тогда
              
        'Был ли размер массива?
        Если blDimensioned = True Тогда
                  
            'Да, поэтому расширите массив на один элемент больше, чем его текущая верхняя граница. 
            'Без приведенного ниже ключевого слова "Сохранить" предыдущие элементы в нашем массиве
            'было бы стерто с изменением размера
            ReDim Сохранить strSongNames (от 0 до UBound (strSongNames) + 1) как строку
                      
        Еще
                  
            «Нет, поэтому измерьте его и отметьте его как размерный.
            ReDim strSongNames (от 0 до 0) как строка
            blDimensioned = Истина
                      
        Конец, если
                  
        'Добавить название песни в последний элемент массива.
        strSongNames(UBound(strSongNames)) = strText
              
    Конец, если
          
Цикл до strText = ""
      
'Отображение введенных названий песен:
      
Для lngPosition = LBound(strSongNames) To UBound(strSongNames)
      
    MsgBox strSongNames(lngPosition)
          
Следующая длинная позиция
      
'Стереть массив
      
Стереть имя песни
 

Обратитесь к комментариям за объяснением того, что происходит.

Удаление массива

Вы всегда должны стирать свой массив, когда закончите его использовать, особенно если вы используете динамические массивы. Это довольно просто:

 Dim strFriends(от ​​0 до 2) Как строка
      
strFriends(0) = "Бьянка"
strFriends(1) = "Жана"
strFriends(2) = "Эрин"
      
Стереть strFriends 

Функция разделения

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

 Dim cdList как строка
cdList = «Неважно, ОК, компьютер, мне не все равно, потому что ты делаешь, Icky Thump» 

Было бы неплохо, если бы мы могли легко взять этот список и поместить его в массив, не так ли?
Это можно сделать с помощью встроенных в Visual Basic строковых функций, однако написание и
обновление этого кода может оказаться трудоемким и утомительным. К счастью для нас, Visual Basic 6.0 предоставляет встроенную
в функции под названием разделить , которая позволяет нам легко извлекать информацию из строки и помещать ее
в массив. В нем есть
следующий синтаксис:

ArrayName = split( Строковый ввод [ Разделитель [ Ограничение длины [ Режим сравнения ]]])

• String Input — это строка, которую вы хотите проанализировать.
• Разделитель — необязательный параметр, указывающий, какой тип строки разделяет элементы во входной строке. По умолчанию этот параметр установлен на » «. Это означало бы, что входная строка «Это тест» даст массив из 4 элементов («Это», «есть», «а», «тест»).
• Ограничение длины — это максимальный размер выходного массива. Оставшийся для анализа текст будет установлен в качестве последнего элемента в массиве.
• Режим сравнения . По умолчанию Visual Basic сравнивает строки посимвольно, используя их значения ASCII. Однако вы можете использовать разные режимы, которые заставят Visual Basic сравнивать строки по-разному. Например, vbTextCompare делает сравнение строк нечувствительным к регистру. Этот параметр влияет на то, как разделитель анализирует входную строку .

Ниже приведен пример, показывающий, как анализировать список, который мы показали ранее:

 Dim strCDRack() как строка
Dim cdList как строка
Dim i как целое число
          
cdList = «Неважно, ОК, компьютер, мне не все равно, потому что ты делаешь, Icky Thump»
strCDRack = Разделить (cdList, ",")
          
Для i = LBound(strCDRack) в UBound(strCDRack)
          
    MsgBox strCDRack(i)
          
Следующие 

Функция соединения

Функция split позволила нам разбить строки на массивы, есть ли функция, которая позволяет нам
взять массивы и сделать из них одну большую длинную строку? Да, да есть, и называется он присоединяюсь к .
join — очень простая функция. Он имеет следующий синтаксис:

StringName = соединение ( Ввод массива [ Разделитель ])

• Входной массив — это массив, который вы хотите поместить в строку.
• Разделитель — это необязательный параметр, который указывает, что вы хотите поместить между элементами, добавляемыми в строку. По умолчанию этот параметр установлен на «».

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

 Dim strFriends(0 to 6) As String, lngPosition as Long
      
strFriends(0) = "Бьянка"
strFriends(1) = "Жана"
strFriends(2) = "Сэм"
strFriends(3) = "Дженна"
strFriends(4) = "Эрин"
strFriends(5) = "Кэролин"
strFriends(6) = "Кейт"
Dim myFriends As String
'Это создаст следующую строку: "Бьянка, Джина, Сэм, Дженна, Эрин, Кэролайн, Кейт"
мои друзья = присоединиться (strFriends, ",")
MsgBox myFriends 

Многомерные массивы

До сих пор во всех рассмотренных нами примерах использовались одномерные массивы, но массивы могут быть и многомерными.
Многомерные массивы можно рассматривать как массивы массивов. Например, для визуализации двумерного массива
мы могли представить себе ряд стоек для компакт-дисков. Чтобы упростить задачу, мы можем представить, что каждая стойка для компакт-дисков может быть предназначена для разных целей.
художник. Как и компакт-диски, стойки можно было бы идентифицировать по номеру. Ниже мы определим двумерный массив, представляющий
ряд стоек для компакт-дисков. Строки внутри массива будут представлять названия альбомов.

 ' Здесь мы определим массив, в котором первое измерение содержит 2 элемента и
' второе измерение содержит 4 элемента
ReDim cdRack (от 0 до 1, от 0 до 3) как строка
' Стойка для компакт-дисков для Beatles
cdRack(0, 0) = "Резиновая душа"
cdRack(0, 1) = "Револьвер"
cdRack(0, 2) = "Белый альбом"
cdRack(0, 3) = "Пусть будет"
Стойка для компакт-дисков Rolling Stones
cdRack(1, 0) = "Липкие пальцы"
cdRack(1, 1) = "Банкет нищих"
cdRack(1, 2) = "Пусть истекает кровью"
cdRack(1, 3) = "Татуирую тебя"
 

Первый элемент первого измерения — это массив компакт-дисков Beatles, а второй элемент первого измерения — массив.
для компакт-дисков Rolling Stones. Вы также можете добавить третье измерение, если хотите. Продолжая аналогию с нашей стойкой для компакт-дисков, вы можете представить
это третье измерение как коридор с несколькими комнатами. Внутри каждой комнаты будет ряд стоек для компакт-дисков. Если вы хотели, чтобы ваш
коридоры, чтобы иметь 10 комнат, каждая со стойками для компакт-дисков, как в приведенном выше примере, вы можете объявить свой массив
следующее:

 Dim cdRackHallway(от 0 до 9, от 0 до 1, от 0 до 3) Как строка 

В Visual Basic 6.0 можно создавать массивы, содержащие до 60 измерений. В Visual Basic .NET максимальное количество измерений
массив может иметь 32. Большинство массивов, с которыми вам придется иметь дело, будут иметь только одно или два измерения.
Многомерные массивы могут потребовать приличного объема памяти, поэтому используйте их с осторожностью.
особенно большие многомерные массивы.

903:30
Наконец, для многомерных массивов следует отметить, что можно изменить размер только последнего измерения. Это означает, что данный
В нашем примере выше, как только мы создадим массив с двумя стойками для компакт-дисков, мы не сможем добавить больше стоек, мы сможем только
изменить количество компакт-дисков в каждой стойке. Пример:

 ' Здесь мы определим массив, в котором первое измерение содержит 2 элемента и
 ' второе измерение содержит 4 элемента
 ReDim cdRack (от 0 до 1, от 0 до 3) как строка
 ' Стойка для компакт-дисков для Beatles
 cdRack(0, 0) = "Резиновая душа"
 cdRack(0, 1) = "Револьвер"
 cdRack(0, 2) = "Белый альбом"
 cdRack(0, 3) = "Пусть будет"
 Стойка для компакт-дисков Rolling Stones
 cdRack(1, 0) = "Липкие пальцы"
 cdRack(1, 1) = "Банкет нищих"
 cdRack(1, 2) = "Пусть истекает кровью"
 cdRack(1, 3) = "Татуирую тебя"
 ReDim Preserve cdRack (от 0 до 1, от 0 до 4) как строка
 ' Давайте добавим еще один диск Битлз
 cdRack(0, 4) = "Эбби Роуд"
 ' Давайте добавим еще один компакт-диск Rolling Stones
 cdRack(1, 4) = "Изгнание на Главной улице.