Основы программирования на языке VBA
ЛАБОРАТОРНАЯ РАБОТА №4
Основы программирования на языке VBA
Цель работы –Изучение основных операторов и реализации основных конструкций программирования в языке VBA.
Основные этапы работы с программами на VBA в Excel
Для подготовки и выполнения программы на языке VBA требуется выполнить следующее:
- в Excel выбрать из меню команду Сервис – Макрос – Редактор Visual Basic;
- в появившемся окне выбрать из меню команду Insert – Module. Создается модуль, т.е., упрощенно говоря, открывается окно, в котором можно вводить текст программы.
В начале модуля может указываться инструкция Option Explicit. Если она указана, то все переменные, используемые в программе, необходимо будет объявлять в операторе Dim (подробнее об этом см. в подразделе 4.3).
В некоторых случаях, в зависимости от настройки среды VBA, инструкция Option Explicit указывается в начале модуля автоматически. Если программист желает использовать переменные, не объявляя их в операторе Dim, то инструкцию Option Explicit необходимо удалить.
Для запуска программы на выполнение необходимо выбрать из меню команду Run – Run Sub/UserForm.
4.2 Простейший пример программы на языке VBA
Пример 4.1 – Программа, возводящаяуказанное число a в указанную степень b.
Sub primer4_1()
‘Первый пример программы на VBA
Dim a As Single, b As Single
a = InputBox(“Введите основание: ”)
b = InputBox(“Введите показатель степени: ”)
x = a^b ‘Возведение в степень
MsgBox(“Результат равен ” & x)
End Sub
Здесь слово Sub обозначает начало процедуры; ее имя в данном случае – primer4_1. Программа на языке VBA всегда состоит из одной или нескольких процедур (в данном случае – из одной).
Символ ‘ (одиночная кавычка) обозначает начало комментария. Текст комментария может быть любым.
Dim – оператор объявления переменных. В данном случае указано, что переменные a и b имеют тип Single. т.е. могут представлять собой как целые, так и дробные числа. Подробнее типы данных и объявление переменных будут рассмотрены в подразделе 4.3.
InputBox – функция для ввода значения переменной. Строка a = InputBox (“Введите основание: ”) означает, что вводится значение переменной a; при этом на экран выводится сообщение “Введите основание:”. Строка x = a^b – оператор присваивания: вычисляется значение правой части (в данном случае переменная a возводится в степень b), и результат присваивается переменной, указанной в левой части (в данном случае – переменной x). Строка MsgBox(“Результат равен ” & x)означает, что на экран выводится сообщение “Результат равен ” и значение переменной x.
Примечание – Знак & в функции MsgBox предназначен для сцепления нескольких элементов данных, которые требуется вывести на экран, в данном примере – строки “Результат равен” и переменной x. Аналогично знак & может использоваться в функции InputBox (примеры такого использования будут приведены далее). Перед знаком & и после него обязательно должны быть указаны пробелы.
В одной строке можно разместить несколько операторов языка VBA. Для этого они разделяются символами «двоеточие». Так, программу из примера 4.1 можно было записать, например, следующим образом:
Sub primer4_1()
‘Первый пример программы на VBA
Dim a As Single, b As Single
a = InputBox(“Введите основание: ”) : b = InputBox(“Введите показатель степени: ”)
x = a^b : MsgBox(“Результат равен ” & x) ‘Возведение в степень и вывод результата
End Sub
В рассмотренном примере использована процедура, называемая подпрограммой. Такая процедура начинается со слова Sub. В программе на VBA всегда имеется хотя бы одна процедура-подпрограмма. Кроме того, в языке VBA имеется еще один вид процедур – функции. Процедура-функция начинается со слова Function. Использование таких процедур будет рассмотрено в подразделе 4.9.
Типы данных. Объявление переменных и констант
Типы данных
Тип данных, указанный для переменной, определяет, какие значения может принимать эта переменная. Основные типы данных, используемые в VBA, приведены в таблице 4.1.
Таблица 4.1 – Основные типы данных в VBA
| Тип данных | Допустимые значения |
| Byte (байт) | от 0 до 255 (только целые) |
| Boolean (логический) | True или False |
| Integer (целое) | от -32768 до 32767 (только целые) |
| Long(длинное целое) | от -2147483648 до 2147483647 (только целые) |
| Single(с плавающей точкой, обычной точности) | от -3,402823×1038 до 3,402823×1038 |
| Double(с плавающей точкой, двойной точности) | от -1,79769313486231×10308 до 1,79769313486232×10308 |
| Date (дата) | от 01.01.100 до 31.12.9999 |
| String (строка) | строки из любых символов, практически неограниченной длины |
Примечание – В данной таблице приведены только основные типы данных. Более подробные сведения о типах данных имеются в литературе по VBA, а также в справочной системе.
Объявление переменных
Тип переменной указывается при ее объявлении. Переменные обычно объявляются в начале программы, до их первого использования, как правило – сразу после оператора начала процедуры (Sub или Function). Основной оператор языка VBA для объявления переменных – оператор Dim.
Пусть, например, требуется, чтобы переменная a могла принимать любые числовые значения (как целые, так и дробные), переменные b и c – только целые (причем как положительные, так и отрицательные), переменная d – только положительные целые значения (причем небольшие), переменная x - строковые значения, переменная y– булевы значения (т.е. только True или False). Эти переменные можно объявить следующим образом:
Dim a As Single, b As Integer, c As Integer, d As Byte, x As String, y As Boolean
После этого, например, попытка присвоить переменной d любое значение, превышающее 255, вызовет сообщение об ошибке из-за несоответствия типов.
Если переменная не объявлена в операторе Dim, то ей назначается тип Variant. В этом случае тип переменной определяется автоматически в зависимости от значения, присваиваемого ей. Например, если переменная z не указана в операторе Dim, то в одной части программы ей может быть присвоено значение z=”Минск” (т.е. строковое значение), а в другой части программы – значение z=5 (т.е. числовое). Использование переменных типа Variant приводит к увеличению затрат памяти и времени выполнения программы, а в некоторых случаях может приводить к ошибкам. Поэтому при разработке сложных программ, как правило, желательно объявлять с помощью оператора Dim все переменные.
Объявление в операторе Dim обязательно для массивов (см. подраздел 4.7), а также для некоторых сложных типов данных, не рассматриваемых в данном пособии.
Рекомендуется объявлять в операторе Dim все переменные, вводимые с клавиатуры, т.е. с помощью функции InputBox. Если, например, переменная z не указана в операторе Dim, и для нее с клавиатуры вводится числовое значение (например, 7), то оно может быть распознано программой не как число, а как строка символов (в данном случае – как строка “7”). Это приводит к ошибкам, например, в операциях сравнения.
Следует обратить внимание, что в операторе Dim тип должен указываться для каждой переменной отдельно. Так, в примере, приведенном выше, объявление b, c As Integer было бы неправильным: тип Integer в этом случае относится только к переменной c, а переменная b остается необъявленной, и ей назначается тип Variant.
Объявление констант
Константы обычно указываются в начале процедуры, как правило – сразу после оператора начала процедуры (Sub или Function) или операторов объявления переменных (Dim). Для объявления констант используется оператор Const.
Пусть, например, в процедуре требуется использовать цену некоторого изделия, равную 250, и вес изделия, равный 3,5. Эти величины удобно задать в начале процедуры в виде констант:
Const cena = 250, ves = 3.5
Изменять константу в программе нельзя. В рассмотренном примере попытка указать в программе оператор cena = cena + 10 или cena = 220 приведет к сообщению об ошибке.
Оператор If
Общий вид условного оператора Ifследующий:
If условие1 Then
действия, выполняемые, если условие1 верно
Elseif условие2 Then
действия, выполняемые, если условие1 неверно, а условие2 верно
Else
действия, выполняемые, если и условие1, и условие2 неверны
End If
Части Elseif и Else необязательны, поэтому оператор If может иметь следующий вид:
If условие Then
действия, выполняемые, если условие верно
Else
действия, выполняемые, если условие неверно
End If
или следующий:
If условие Then
действия, выполняемые, если условие верно
End If
Если оператор If записывается в одну строку, то слова End If после него не указываются.
Пример 4.3 – Программа запрашивает число и умножает его на 2, если оно меньше 5, или на 3, если оно больше или равно 5.
Sub primer4_3()
Dim x As Single
x = InputBox(“Введите число: ”)
If x < 5 Then x=x*2 Else x=x*3
MsgBox(“Результат равен ” & x)
End Sub
Здесь оператор If записан в одну строку, поэтому слова End If не требуются.
Пример 4.4 – Программа для решения квадратного уравнения.
Sub primer4_4()
Dim a As Single, b As Single, c As Single
a = InputBox ("Введите коэффициент a")
b = InputBox ("Введите коэффициент b")
c = InputBox ("Введите коэффициент c")
d = b ^ 2 - 4 * a * c
If d > 0 Then
x1 = (-b - Sqr(d)) / (2 * a): x2 = (-b + Sqr(d)) / (2 * a)
MsgBox ("x1=" & x1)
MsgBox ("x2=" & x2)
Elseif d = 0 Then
x = -b / (2 * a)
MsgBox ("x=" & x)
Else
MsgBox ("Вещественных корней нет")
End If
End Sub
Цикл ДО. Оператор For
Цикл ДО (т.е. цикл, повторяющийся заданное количество раз) реализуется в VBA оператором For, имеющим следующий вид:
For переменная_цикла = начальное_значение To конечное_значение Step шаг
операторы, составляющие цикл
Next переменная_цикла
При выполнении такого оператора переменная цикла сначала принимает указанное начальное значение. Затем выполняются операторы, составляющие цикл. После этого вычисляется следующее значение переменной цикла: к ее текущему значению прибавляется величина шага. Если слово Step (а значит, и величина шага) не указано, то переменная изменяется с шагом, равным 1. Снова выполняются операторы, составляющие цикл. Процесс завершается, когда переменная цикла превышает конечное значение.
Пример 4.6 – Программа, вычисляющая сумму всех четных чисел от 0 до 100, т.е. 0+2+4+6+…+100.
Sub primer4_6()
sum = 0
For x = 0 To 100 Step 2
sum = sum + x
Next x
MsgBox(“Сумма = ” & sum)
End Sub
Пример 4.7 – Программа, вычисляющая и выводящая на экран значения ex для x=1, 4, 7, 10, 13, 16, 19.
Sub primer4_7()
For x = 1 To 19 Step 3
y = exp(x)
MsgBox(“x = ” & x & “ y = ” & y)
Next x
End Sub
Массивы
Массив в языке VBA, как и в других языках – объект программы, состоящий из нескольких элементов. Массивы необходимо объявлять в начале программы с помощью оператора Dim. Например, следующее объявление
Dim a(1 To 6) As Integer, b(1 To 3, 1 To 10) As Single, c (1 To 6, 1 To 3) As String
означает, что переменная a – одномерный массив, который может содержать не более шести элементов (целых чисел, так как указан тип Integer). Переменная b– двумерный массив из трех строк и десяти столбцов; элементы этого массива – вещественные числа (тип Single). Переменная c – массив из шести строк и трех столбцов; его элементы – строки символов.
Использование переменных для указания размеров массивов в операторе Dim не допускается. Например, объявление Dim a(1 To m) As Integer недопустимо, даже если переменной m уже присвоено некоторое значение.
Во многих случаях удобно задавать размеры массива не в операторе Dim (т.е. не в начале программы), а позже, в ходе выполнения программы. Для этого используется оператор ReDim. Массив в этом случае называется динамическим.
Пусть требуется использовать в программе массив из целых чисел, но количество этих чисел сначала неизвестно (например, его нужно запрашивать у пользователя). Объявление массива в этом случае может быть следующим:
Dim a() As Integer, m As Byte
m = InputBox ("Введите количество элементов массива ")
ReDim a(1 To m)
Как видно из этого примера, для указания размеров динамического массива можно использовать переменные. Если массив объявлен как динамический, то изменять его размеры, используя оператор ReDim, можно неоднократно.
При обращении в программе к отдельным элементам массива номера элементов указываются в круглых скобках. Если массив двумерный, то сначала указывается номер строки, затем – номер столбца. Примеры:
a(2) = 15
b(2,7) = 8.3
c(1,4) = “Минск”
Здесь второму элементу массива a присвоено значение 15. Элементу массива b, расположенному во второй строке и седьмом столбце, присвоено значение 8,3. Элементу массива c, расположенному в первой строке и четвертом столбце, присвоено значение “Минск”.
Пример 4.8 – Программа запрашивает количество элементов, которые должны содержаться в одномерном массиве (имя массива – a, максимально допустимое количество элементов – 20), затем – сами элементы массива a. Запрашивается также некоторое число x. Все элементы массива a, превосходящие x, умножаются на два. Подсчитывается также количество элементов, которые потребовалось умножить.
Sub primer4_8a()
Dim a(1 To 20) As Single, x As Single, m As Byte
m = InputBox("Введите количество элементов: ")
MsgBox(“Вводите элементы массива”)
For i = 1 To m
a(i) = InputBox("a(" & i & "): ")
Next i
x = InputBox("Введите число x: ")
For i = 1 To m
If a(i) > x Then
a(i) = a(i)*2
umnozheno = umnozheno + 1
End If
Next i
MsgBox(“Измененный массив ”)
For i = 1 To m
MsgBox("a(" & i & ") = " & a(i))
Next i
MsgBox ("Умножено: " & umnozheno)
End Sub
Здесь оператор Dim – объявление переменных: массива a и обычных (скалярных) переменных x и m. Запись Dim a(1 To 20) As Single означает, что переменная a – одномерный массив, который может содержать не более двадцати элементов. Эти элементы могут быть как целыми, так и дробными числами (тип данных Single).
Для обработки массива используются циклы. Например, для ввода элементов массива a применяется следующий цикл:
For i = 1 To m
a(i) = InputBox("a(" & i & "): ")
Next i
Здесь переменная i принимает сначала значение 1. При i=1 выполняется оператор InputBox, т.е. вводится значение первого элемента массива a(1). Затем выполняется оператор Next i, где переменная i принимает значение 2. Цикл повторяется: запрашивается элемент a(2). Аналогично вводятся остальные элементы.
Затем в программе выполняются еще два цикла. В одном из них каждый элемент массива сравнивается с переменной x, и если выполняется условие a(i) > x, то умножается на два. В последнем цикле элементы измененного массива выводятся на экран.
Примечание – Приведенная в примере 4.8 реализация программы имеет ряд недостатков. Так, массив a в любом случае хранится в памяти компьютера как массив из двадцати элементов, даже если фактическое количество элементов массива (т.е. значение переменной m) меньше. В то же время ввести значение переменной m, превышающее 20, нельзя: при выполнении цикла произойдет выход за объявленную границу массива, и программа будет прервана с выдачей сообщения об ошибке. Разрешить эти проблемы можно, используя динамические массивы. В этом случае начало программы будет иметь следующий вид:
Sub primer4_8b()
Dim a() As Single, m As Byte
m = InputBox("Введите количество элементов: ")
ReDim a (1 To m)
Теперь размер массива a может быть любым, в зависимости от введенного значения переменной m.
Пример 4.9 – В программе вводится одномерный массив a и некоторое число x (аналогично примеру 4.8). Из элементов массива a должны составляться два новых массива: в один из них включаются все элементы, превышающие x, а в другой – все остальные.
Sub primer4_9()
Dim a() As Single, bol() As Single, men() As Single, m As Byte, x As Single
m = InputBox("Введите количество элементов: ")
ReDim a (1 To m), bol (1 To m), men (1 To m)
MsgBox(“Вводите элементы массива”)
For i = 1 To m
a(i) = InputBox("a(" & i & "): ")
Next i
x = InputBox("Введите число x: ")
For i = 1 To m
If a(i) > x Then
j = j+1 : bol(j) = a(i)
Else
k = k+1 : men(k) = a(i)
End If
Next i
MsgBox(“Элементы больше ” & x)
For i = 1 To j
MsgBox(bol(i))
Next i
MsgBox(“Элементы меньше ” & x)
For i = 1 To k
MsgBox(men(i))
Next i
End Sub
Здесь каждый элемент массива a сравнивается с переменной x. Если выполняется условие a(i) > x, то элемент a(i) включается в массив bol. Для этого увеличивается на единицу переменная j – номер очередного элемента массива bol. Затем создается новый (j-й) элемент массива bol: bol(j) = a(i). Если же условие a(i) > x не выполняется, то элемент a(i) включается в массив men. Для определения номера очередного элемента массива men используется переменная k.
Пример 4.10 – В программе вводится двумерный массив (имя массива – a). Для этого запрашивается сначала количество строк и столбцов (переменные m и n), затем – сами элементы массива. Вычисляются суммы столбцов массива. Из них составляется новый массив – одномерный массив asum.
Sub primer4_10a()
Dim a(1 To 5, 1 To 10) As Single, asum(1 To 10) As Single
m = InputBox("Введите количество строк: ")
n = InputBox("Введите количество столбцов: ")
For i = 1 To m
For j = 1 To n
a(i, j) = InputBox("a(" & i & "," & j & "): ")
Next j
Next i
For j = 1 To n
For i = 1 To m
asum(j) = asum(j) + a(i, j)
Next i
Next j
For j = 1 To n
MsgBox ("Сумма " & j & "-го столбца = " & asum(j))
Next j
End Sub
Здесь оператор Dim – объявление переменных (в данном случае – массивов). Объявление Dim a(1 To 5, 1 To 10) As Single означает, что переменная a – двумерный массив, который может содержать не более пяти строк и не более десяти столбцов. Элементы массива – числа, которые могут быть как целыми, так и дробными (тип Single).
Для ввода массива a и для суммирования его столбцов используются вложенные циклы. Рассмотрим, например, вложенные циклы для суммирования столбцов массива:
For j = 1 To n
For i = 1 To m
asum(j) = asum(j) + a(i, j)
Next i
Next j
Здесь переменная j (номер столбца) принимает сначала значение 1. При j=1 выполняется вложенный цикл:
For i = 1 To m
asum(j) = asum(j) + a(i, j)
Next i
т.е. переменная i (номер строки) принимает значения от 1 до m, и выполняется суммирование элементов a(1,1), a(2,1),…,a(m,1). В результате вычисляется величина asum(1) – первый элемент нового массива asum, сумма элементов первого столбца массива a.
Затем переменная j (номер столбца) принимает значение 2. Снова выполняется вложенный цикл, т.е. переменная i (номер строки) принимает значения от 1 до m, и выполняется суммирование элементов a(1,2), a(2,2),…,a(m,2). В результате вычисляется величина asum(2). Аналогичные действия выполняются для значений j=3,…,n, т.е. для каждого столбца массива a.
Для вывода элементов массива asum на экран используется следующий цикл:
For j = 1 To n
MsgBox ("Сумма" & j & "-го столбца = " & asum(j))
Next j
Здесь переменная j изменяется от 1 до n с шагом 1, т.е. принимает значения 1, 2, 3, …, n. В каждом цикле (т.е. n раз) выполняется оператор MsgBox ("Сумма" & j & "-го столбца = " & asum(j)), т.е. на экран выводится j-й элемент массива asum.
Примечание – Чтобы массивы a и asum могли иметь любые размеры в соответствии с введенными значениями переменных m и n, следует объявить их как динамические массивы. В этом случае начало программы будет иметь следующий вид:
Sub primer4_10b()
Dim a() As Single, asum() As Single, m As Byte, n As Byte
m = InputBox("Введите количество строк")
n = InputBox("Введите количество столбцов")
ReDim a (1 To m, 1 To n), asum(1 To n)
Пример 4.11 – Программа запрашивает элементы массива из пяти строк и трех столбцов (массив a), а также некоторое число (переменная x). Затем программа подсчитывает в каждой строке массива a количество элементов, равных переменной x. Если строка полностью состоит из чисел x, то номер строки выводится на экран.
Sub primer4_11a()
Dim a(1 To 5, 1 To 3) As Single, x As Single
m = 5 : n = 3
MsgBox(“Вводите массив”)
For i = 1 To m
For j = 1 To n
a(i, j) = InputBox("a(" & i & "," & j & "): ")
Next j
Next i
x = InputBox("Введите число x: ")
For i = 1 To m
kol = 0
For j = 1 To n
If a(i,j) = x Then kol = kol + 1
Next j
If kol = n Then MsgBox (i & "-я строка состоит из чисел " & x)
Next i
End Sub
Здесь для подсчета количества элементов строки, равных числу x, используется переменная kol. Цикл For i = 1 To m используется для перебора строк, цикл For j = 1 To n – для перебора элементов строки. В начале перебора очередной (i-й) строки выполняется оператор kol=0, т.е. переменная kol обнуляется. Затем каждый элемент i-й строки проверяется на равенство переменной x, и если равенство выполняется, то переменная kol увеличивается на единицу (If a(i,j) = x Then kol = kol + 1). Таким образом, после завершения цикла For j = 1 To n (т.е. по окончании перебора элементов i-й строки) переменная kol оказывается равной количеству элементов строки, значение которых совпало с переменной x. В операторе If kol = n Then MsgBox (i & "-я строка состоит из чисел " & x) проверяется значение переменной kol. Если оно равно количеству столбцов массива (т.е. количеству элементов в строке), значит, вся строка состояла из переменных, равных числу x. В этом случае номер строки выводится на экран. Затем выполняется возврат к началу цикла For i = 1 To m, т.е. переменная i увеличивается на единицу, и проверяется очередная строка.
Следует обратить внимание, что переменная x, вводимая с клавиатуры, объявлена в операторе Dim с типом Single, т.е. с тем же типом, что и элементы массива. В данном случае такое объявление обязательно. Если не объявить переменную x, то при ее сравнении с элементом массива a(i,j)(в операторе If a(i,j) = x Then …) эти величины всегда будут распознаваться как разные, так как элементы массива имеют тип Single (т.е. представляют собой десятичные числа), а переменная x будет рассматриваться как строка символов, а не как число (например, значение 7 будет распознано как строка “7”).
Рассмотрим еще один способ решения данной задачи. Чтобы определить, состоит ли вся строка массива из чисел x, воспользуемся логической переменной vse.
Sub primer4_11b()
... См. программу primer4_11a …
For i = 1 To m
vse = True
For j = 1 To n
If a(i,j) <> x Then vse = False
Next j
If vse = True Then MsgBox (i & "-я строка состоит из чисел " & x)
Next i
End Sub
Здесь в начале перебора каждой строки переменной vse присваивается значение True. Затем каждый элемент строки проверяется на равенство переменной x, и если равенство не выполняется, то переменная vse получает значение False. Таким образом, по окончании перебора элементов строки переменная vse будет иметь значение False, если хотя бы один элемент строки будет иметь значение, отличное от x (и останется равной True, если все элементы строки будут равны переменной x). В операторе If vse = True Then …проверяется значение переменной vse. Если эта переменная равна True, значит, вся строка состояла из переменных, равных числу x. В этом случае номер строки выводится на экран.
Пример 4.12 – В программу вводится двумерный массив. Программа определяет в каждом столбце массива максимальное число и выводит его на экран.
Sub primer4_12()
Dim a(1 To 3, 1 To 5) As Single
m = 3 : n = 5
MsgBox(“Вводите массив”)
For i = 1 To m
For j = 1 To n
a(i, j) = InputBox("a(" & i & "," & j & ")")
Next j
Next i
For j = 1 To n
maximum = a(1,j)
For i = 1 To m
If a(i,j) > maximum Then maximum = a(i,j)
Next i
MsgBox ("В " & j & "-м столбце максимальный элемент равен " & maximum)
Next j
End Sub
Здесь цикл For j = 1 To n используется для перебора столбцов, цикл
For i = 1 To m – для перебора элементов столбца. Переменная maximum используется для запоминания максимального элемента столбца. Сначала она принимается равной первому элементу столбца: maximum = a(1,j). Если в ходе перебора столбца обнаруживается элемент, превышающий текущее значение переменной maximum, то он присваивается этой переменной. В результате по окончании перебора столбца переменная maximum будет равна его максимальному элементу.
Пример 4.13 – В программу вводится двумерный массив. Программа определяет в каждом столбце массива максимальное число и меняет его местами с первым элементом данного столбца. Измененный массив выводится на экран.
Sub primer4_13()
Dim a(1 To 3, 1 To 5) As Single
m = 3 : n = 5
MsgBox(“Вводите массив”)
For i = 1 To m
For j = 1 To n
a(i, j) = InputBox("a(" & i & "," & j & ")")
Next j
Next i
For j = 1 To n
maximum = a(1,j)
nomer = 1
For i = 1 To m
If a(i,j) > maximum Then
maximum = a(i,j)
nomer = i
End If
Next i
x = a(1,j)
a(1,j) = a(nomer,j)
a(nomer,j) = x
Next j
For i = 1 To m
For j = 1 To n
MsgBox("a(" & i & "," & j & ") = " & a(i,j))
Next j
Next i
End Sub
Поиск максимального элемента столбца выполняется аналогично предыдущему примеру. В переменной maximum запоминается максимальный элемент столбца, а в переменной nomer – номер этого элемента (или, другими словами, номер строки, в которой находится максимальный элемент данного столбца). В следующей группе операторов первый и максимальный элемент j-го столбца меняются местами:
x = a(1,j)
a(1,j) = a(nomer,j)
a(nomer,j) = x
Здесь x – вспомогательная переменная, используемая для промежуточного хранения первого элемента столбца.
Пример 4.14 –В программу вводится двумерный массив. По каждой строке вычисляется среднее значение. Составляется массив из средних значений, превышающих некоторую заданную величину (эта величина вводится с клавиатуры и обозначается как переменная predel). Этот массив выводится на экран.
Sub primer4_14()
Dim a() As Single, sred() As Single, predel As Single, m As Byte, n As Byte
m = InputBox("Введите количество строк ")
n = InputBox("Введите количество столбцов ")
ReDim a(1 To m, 1 To n), sred (1 To m)
For i = 1 To m
For j = 1 To n
a(i, j) = InputBox("a(" & i & "," & j & ")")
Next j
Next i
predel = InputBox(“Введите минимально допустимое среднее”)
k = 0
For i = 1 To m
sum = 0
For j = 1 To n
sum = sum + a(i,j)
Next j
sred_stroki = sum/n
If sred_stroki > predel Then
k=k+1 ‘Вычисляется номер нового элемента массива sred
sred(k) = sred_stroki
End If
Next i
For i = 1 To k
MsgBox (sred(i))
Next i
End Sub
Здесь sred – массив из средних значений, превышающих заданную величину predel. Каждый раз, когда среднее значение строки превышает переменную predel (т.е. выполняется условие sred_stroki > predel), вычисляется новое значение переменной k - номер очередного элемента массива sred. Для этого переменная k увеличивается на единицу (k=k+1). Затем создается новый (k-й) элемент массива sred: sred(k) = sred_stroki.
Примечание – Здесь для переменной k обнуление необязательно, так как все переменные по умолчанию сначала равны нулю. Оператор k=0 приведен в программе только для наглядности. Для переменной sum обнуление обязательно, так как она вычисляется для каждой строки заново.
Пример 4.15 –В программу вводится двумерный массив, и по каждой его строке вычисляется среднее значение. Составляется новый двумерный массив (обозначенный в программе как nov): в него включаются строки исходного массива, для которых среднее значение превышает некоторую заданную величину (переменная predel).
Sub primer4_15()
Dim a() As Single, nov() As Single, predel As Single, m As Byte, n As Byte
m = InputBox("Введите количество строк ")
n = InputBox("Введите количество столбцов ")
ReDim a(1 To m, 1 To n), nov(1 To m, 1 To n)
… ‘Ввод исходного массива (имя массива – a), как в примере 4.14
predel = InputBox(“Введите минимально допустимое среднее”)
k = 0
For i = 1 To m
sum = 0
For j = 1 To n
sum = sum + a(i,j)
Next j
sred_stroki = sum/n
If sred_stroki > predel Then
k=k+1 ‘Вычисляется номер новой строки массива nov
For j = 1 To n
nov(k,j) = a(i,j) ‘i-я строка исходного массива, в которой среднее превышает
Next j ‘предел, копируется в очередную (k-ю) строку нового массива
End If
Next i
MsgBox("Составлен новый массив”)
For i = 1 To k
For j = 1 To n
MsgBox("nov(" & i & "," & j & ") = " & nov(i,j))
Next j
Next i
End Sub
Loop
Цикл повторяется, пока заданное в нем условие верно, и прекращается, когда оно становится неверным. Условие проверяется перед началом цикла. Если условие сразу оказывается неверным, то цикл не выполняется ни разу.
Примечание – В VBA имеется также оператор цикла Do Until, по структуре аналогичный оператору Do While. Цикл, заданный оператором Do Until, повторяется, пока заданное в нем условие неверно, и прекращается, когда оно становится верным.
Пример 4.16 – В программе вводится одномерный массив из восьми чисел, и выполняется суммирование его элементов (начиная с первого), пока сумма не превысит 20.
Sub primer4_16a()
Dim a(1 To 8) As Integer
MsgBox(“Вводите массив”)
For i = 1 To 8
a(i) = InputBox("a(" & i & ")")
Next i
sum = 0 : i = 0
Do While sum <= 20
i = i + 1
sum = sum + a(i)
Loop
MsgBox ("Сумма достигнута на " & i & "-м элементе и равна" & sum)
End Sub
Здесь переменная sum сначала равна нулю, поэтому условие sum<=20 верно. Выполняются операторы цикла:
i = i + 1
sum = sum + a(i)
Таким образом, переменная sum становится равной первому элементу массива a. Если он превышает 20, то цикл завершается, так как условие sum<=20 оказывается неверным. Выполняется оператор, следующий за циклом, т.е. выводится сообщение о найденной сумме. Если же элемент a(1) не превышает 20, то условие sum<=20 остается верным, и цикл повторяется снова: переменная i принимает значение 2, и к переменной sum прибавляется величина a(2). Цикл повторяется, пока переменная sum не превысит 20.
Следует обратить внимание, что рассмотренная программа не вполне правильная: в ней не предусмотрено, что сумма элементов массива может оказаться меньше 20. В этом случае программа завершится с выдачей сообщения об ошибке, когда переменная i превысит объявленное количество элементов массива (в данном примере оно равно 8). Чтобы исправить эту ошибку, можно изменить программу, как показано ниже.
Sub primer4_16b()
Dim a(1 To 8) As Integer
MsgBox ("Вводите массив")
For i = 1 To 8
a(i) = InputBox("a(" & i & ")")
Next i
sum = 0: i = 0
Do While (sum <= 20) And (i < 8)
i = i + 1
sum = sum + a(i)
Loop
If sum > 20 Then
MsgBox ("Сумма достигнута на " & i & "- м элементе и равна " & Sum)
Else
MsgBox ("Сумма не достигнута")
End If
End Sub
Здесь цикл Do While выполняется до тех пор, пока верны два условия: переменная sum не превышает 20, и переменная i меньше 8. Если хотя бы одно из этих условий нарушается, то цикл прекращается. Поэтому, если в ходе выполнения цикла переменная sum достигает значения, превышающего 20, то цикл прекращается, так как нарушается условие sum <= 20. Если же оказывается, что сумма всех элементов массива меньше 20, то цикл прекращается из-за нарушения условия i < 8 (так как переменная i увеличивается на единицу в каждом цикле и достигает значения 8, когда вычислена сумма всех элементов массива). После прекращения цикла в операторе If проверяется достигнутое значение переменной sum, и выводится соответствующее сообщение.
Пример 4.17– Вычислить сумму ряда 
с точностью до 0,0001.
Sub primer4_17()
n=0 : element = 1 : sum = 0
Do While Abs (element) >= 0.0001
sum = sum + element
n=n+1
factorial = 1
For i=1 To n
factorial = factorial * i
Next i
element = ((-1)^n)/(factorial*(2*n+1))
Loop
MsgBox(“Сумма ” & sum & “достигнута при n = ” & n-1)
End Sub
Здесь Abs – встроенная (стандартная) функция языка VBA, вычисляющая модуль. Для вычисления факториала использован цикл For, рассмотренный ранее. Вычитание при выводе результата (n-1) требуется из-за того, что в цикле переменная n увеличивается, вычисляется очередной (n-й) элемент ряда, и только после этого проверяется условие окончания цикла (превышает ли вычисленный элемент ряда заданную величину 0,0001). Цикл завершится, когда вычисленный элемент ряда окажется меньше 0,0001. Этот элемент уже не прибавляется к вычисляемой сумме. Поэтому на момент окончания цикла переменная n будет иметь значение, на единицу превышающее количество элементов вычисленной суммы.
Подпрограммы
Во многих случаях удобно выделить часть программы в отдельную процедуру (подпрограмму) и вызывать ее для выполнения из другой процедуры. Подпрограмма может иметь входные и выходные параметры. Входные параметры – это величины, передаваемые в подпрограмму из другой (вызывающей) процедуры и являющиеся для вызываемой подпрограммы «исходными данными». Этими величинами могут быть как переменные, так и константы (например, конкретные числа). Выходные параметры – это переменные, являющиеся результатами выполнения вызываемой подпрограммы.
Пример 4.18 – Требуется разработать программу для составления массива из элементов арифметической прогрессии. Первый элемент прогрессии a1, шаг прогрессии d и необходимое количество элементов n указываются пользователем. Составление массива требуется реализовать как подпрограмму.
Sub primer4_18()
Dim a1 As Single, d As Single, n As Byte, a() as Single
a1 = InputBox("Введите первый элемент прогрессии ")
d = InputBox("Введите шаг прогрессии ")
n = InputBox("Укажите, сколько элементов требуется ")
ReDim a (1 To n) ‘a – массив из элементов прогрессии, который требуется составить
Call arif_progr(a1, d, n, a)
For i = 1 To n
MsgBox(i & “-й элемент прогрессии равен “ & a(i))
Next i
End Sub
Sub arif_progr(nach, shag, kol, elem)
elem(1) = nach
For i=2 To kol
elem(i) = elem(i-1)+shag
Next i
End Sub
Здесь подпрограмма primer4_18 является вызывающей (или основной) подпрограммой, а arif_progr – вызываемой подпрограммой. Таким образом, данная программа в целом состоит из двух подпрограмм. При ее запуске курсор должен находиться в пределах текста основной подпрограммы.
В начале основной подпрограммы выпо<