0.2.Объявление переменных величин
Когда на бал к графине N приезжает герцог M, то слуга объявляет на весь зал: "Герцог M!", отчего все гости сразу узнают, что перед ними герцог, а не какой-нибудь там баронишко, и обращаются к нему соответственно. Все хорошо, все прилично. Если бы слуга проморгал и забыл объявить герцога, то в большинстве случаев тоже ничего страшного бы не произошло. Однако иногда все же могли бы приключиться досадные недоразумения. Например, к герцогу могли бы обратиться так: "Эй, человек, подай-ка лимонад!", а это уже скандал!
Бал - это проект в режиме работы. Гости - это переменные. Слуга - это вы. До сих пор вы никого не объявляли и тем не менее все шло как по маслу. Это потому что Visual Basic умный, он по глазам определяет, кто герцог, а кто нет. Однако не на каждом балу глаза говорят правду. Прежде чем убедиться в этом, изучим еще один полезный и приятный элемент Visual Basic:
InputBox
Как мы можем задать компьютеру какую-нибудь величину? Оператором присваивания - раз. Введя ее в текстовое поле, как мы делали в калькуляторе - два. Есть еще один удобный и приятный способ - InputBox.
В вашем проекте о прямоугольнике вы можете хоть сто раз нажимать на кнопку - результаты все время будут одинаковые. Это потому что исходные данные a=27018 и b=3954 никто не меняет. Скучно. Хорошо бы компьютер при нажатии на кнопку каждый раз спрашивал нас, чему равны стороны прямоугольника. А мы бы ему отвечали. А уж потом он вычислял.
Для этого нам нужно слегка изменить программу:
Private Sub Command1_Click()
a = InputBox("Введите ширину прямоугольника")
b = InputBox("Введите высоту прямоугольника")
S = a * b
p = 2 * a + 2 * b
Debug.Print S, p
End Sub
Как видите, заменены первые две строки: a=27018 и b=3954.
Конструкция
a = InputBox("Введите ширину прямоугольника")
есть оператор присваивания и означает она приказ компьютеру вывести сначала на экран вот такое окно:
после чего человек вводит в белое текстовое поле этого окна любое число и нажимает ОК. После этого компьютер присваивает переменной a введенное значение и продолжает работу, то есть переходит к выполнению следующего оператора.
Запустите проект и посмотрите, как он работает.
Если вам не нравится строка Project1 в заголовке окна, то вы можете задать свою строку, так дополнив оператор:
a = InputBox("Введите ширину прямоугольника", "Ввод данных")
Результат:
Почему плохо не объявлять переменные величины
Посмотрим, где Visual Basic дает сбой, если не объявлять переменные величины. Рассмотрим простую задачу: Даны три стороны треугольника. Вычислить его периметр.
Создаем новый проект с кнопкой для задачи о треугольнике. По аналогии с процедурой о прямоугольнике легко пишем процедуру для треугольника:
неправильная процедура:
Private Sub Command1_Click()
a = InputBox("Введите первую сторону треугольника")
b = InputBox("Введите вторую сторону треугольника")
c = InputBox("Введите третью сторону треугольника")
p = a + b + c
Debug.Print p
End Sub
Запускаем проект, вводим стороны - 2, 3, 4 и какой результат мы видим? Вместо 9 мы видим 234! Почему? Здесь тот же случай, что и с калькулятором, там было то же самое, пока мы не применили Val. Почему? Первое: Visual Basic считает содержимое текстового поля окна InputBox (точно так же, как и содержимое обычного текстового поля) текстом, а не числом, если даже оно состоит из цифр. А раз так, то и переменные a, b, c, берущие свое значение из текстового поля, он тоже считает текстовыми, а не числовыми. Не пей из копытца - козленочком станешь! Второе: Visual Basic знает, что по правилам языка знак + имеет несколько смыслов в зависимости от того, к чему он применяется. В частности, при работе с текстом это не приказ складывать, а приказ выстраивать в цепочку. А раз так, то и результат получился тот, что мы видели.
Наши необъявленные переменные, как голодные дворняги, готовы есть все, что им дают. Введите вместо трех чисел три таких текста: Ко, ро, бочка. Результат - Коробочка.
Почему же тогда в примере о прямоугольнике все прошло нормально? Потому что там было еще умножение. Visual Basic знает, что по правилам языка знак умножения * не имеет смысла при работе с текстом. Значит (догадывается умный и услужливый Visual Basic) мой господин - человек не хочет, чтобы переменные a, b, c были текстовыми. Значит быть им числовыми! Проверьте: подсуньте компьютеру вместо чисел коробочку - Visual Basic запротестует.
В примере о прямоугольнике Visual Basic догадался правильно, а в примере о треугольнике ума не хватило. Ну что, теперь везде при сложении применять Val? Не хочется, программы будут получаться громоздкими. Да и разве все дело только в сложении? Как узнаешь, где в следующий раз соломки подстелить?
Так вот, чтобы не перенапрягать умственные способности Visual Basic и предохранить себя от неприятностей, нужно все переменные величины объявлять!
Как объявлять переменные величины
Добавим в окно кода нашего проекта, на самый верх, над заголовком процедуры четыре строки. Получится:
правильная процедура:
Dim a As Integer
Dim b As Integer
Dim c As Integer
Dim p As Integer
Private Sub Command1_Click()
a = InputBox("Введите первую сторону треугольника")
b = InputBox("Введите вторую сторону треугольника")
c = InputBox("Введите третью сторону треугольника")
p = a + b + c
Debug.Print a, b, c, p
End Sub
Объявление
Dim |
a |
As |
Integer |
переводится так:
Переменная величина |
a |
как |
целое число |
то есть вы обязуете Visual Basic обращаться с переменной величиной a как с целым числом и ничем иным. Говорят, что "переменная a имеет тип Integer". Аналогично объявлены и переменные b, c, p. Объявления будем пока писать выше процедур. Подробнее о местах, где можно делать объявления, написано в 4.2.
Запустите проект. Проверьте его работу.
Вместо четырех строк
Dim a As Integer
Dim b As Integer
Dim c As Integer
Dim p As Integer
можно для краткости написать одну:
Dim a As Integer, b As Integer, c As Integer, p As Integer
Но если вы захотите написать еще короче:
Dim a, b, c, p As Integer
то Visual Basic неправильно вас поймет.
Типы данных
Много ли прав на нашем балу у барона Integer? Посмотрим. Попробуем ввести дробное значение первой стороны треугольника - 2,3. Именно так - с запятой, а не точкой. Посмотрим результат. Visual Basic считает a целым числом 2. А теперь - 2,6. Visual Basic считает a целым числом 3. Все правильно. Наш барон высокомерно отказывается быть дробным числом и поэтому любое число, которое мы ему предлагаем, округляет до целого.
Предположим, мы этим недовольны. Мы желаем, чтобы все числа могли быть дробными. Пожалуйста! Для этого достаточно всех гостей объявить князьями. Вот так:
Dim a As Single
Dim b As Single
Dim c As Single
Dim p As Single
Private Sub Command1_Click()
a = InputBox("Введите первую сторону треугольника")
b = InputBox("Введите вторую сторону треугольника")
c = InputBox("Введите третью сторону треугольника")
p = a + b + c
Debug.Print a, b, c, p
End Sub
Объявление
Dim |
a |
As |
Single |
переводится так:
Переменная величина |
a |
как |
десятичная дробь обычной точности |
то есть вы обязуете Visual Basic обращаться с переменной величиной a как с десятичной дробью и ничем иным. Десятичная дробь - это любое число, которое может иметь целую и дробную часть (например, 27,3908), в частности это и целое число. Об обычной точности попозже. Говорят, что "переменная a имеет тип Single ".
Законный вопрос: зачем нам нужен тип Integer, когда тип Single "гораздо лучше"? Ответ: Не во всем и не всегда он лучше, иначе не стали бы его создавать вообще. Подробнее об этом - в 0.5.
На бал к Visual Basic вхожи не только бароны и князья, то есть типов данных в Visual Basic довольно много и каждый полезен по-своему. Рассматривать новые типы я буду по мере надобности. А сейчас отмечу главное - в солидном проекте не объявлять переменные неприлично! Поэтому переменные величины нужно объявлять всегда. А чтобы по нашей человеческой рассеянности какая-нибудь переменная не проскочила на бал необъявленной, поручим компьютеру не пускать таких на бал, то есть прикажем Visual Basic выдавать соответствующее сообщение при нашей попытке запустить проект с необъявленными переменными. Для этого - ToolsOptionsEditorRequire Variable Declaration. Отныне в окне кода любого создаваемого вами проекта будет появляться строка Option Explicit, что означает требование обязательно объявлять переменные этого проекта. В общем, "Посторонним В!…" Тем не менее, свобода есть свобода, и вы всегда можете с песней "Мама - Анархия!" в каком-нибудь проекте стереть строку Option Explicit.
Я сам в примерах этой книги поначалу все, что можно, буду объявлять, но затем для экономии "места и смысла" перестану это делать. Не берите с меня пример!
Вот еще причина, по которой удобно использовать Option Explicit. Как по вашему, что напечатал у меня следующий фрагмент:
x = 2
Debug.Print х
Если вы думаете, что 2, то ошибаетесь. Ничего не напечатал. Потому что в первой строке присутствует латинская буква "икс", а во второй строке я нечаянно написал русскую букву "хэ". Я был в недоумении. Не помогло и объявление переменной "икс" (не помогло бы, между прочим, и объявление "хэ"). Visual Basic не нашел в программе никаких ошибок. И только применение Option Explicit дало намек на истинную причину ошибки.
Вот какие типы данных вы найдете в этой книжке:
Integer, Single -0.2
Long, Double, Currency -0.5
String -0.7
Date -7.1
Boolean -7.3
Перечислимый -7.3
Массивы -Глава 0.
Variant -1.1
Пользовательский -1.2
Коллекции -1.3
Объекты -1.3, Глава 7.
Переменные величины и память
Полностью механизм работы переменных величин не понять, если не узнать, как они хранятся в оперативной памяти компьютера.
Оперативнвя память нужна компьютеру для того, чтобы хранить во время выполнения программы саму эту программу и данные, с которыми программа работает.
Как устроена оперативная память (или просто память)? Представьте себе тетрадный листок в клеточку. В каждую клетку вы имеете право записать карандашом какую-нибудь букву или цифру или знак + или вообще любой символ, который можно найти на клавиатуре. А можете и стереть ластиком и записать другой символ. Много ли букв можно записать на листе? Ровно столько, сколько на нем клеток.
Оперативная память компьютера устроена аналогично такому листу. Только клеточек в ней гораздо больше. Каждая клеточка называется байтом. Для запоминания слова КОШКА понадобится 5 байтов. Подробнее о работе памяти см. в Приложении 1.
Значения переменных величин во время выполнения программы компьютер хранит в оперативной памяти (потому что диски для этого слишком медлительны). Для этого он предварительно под каждую переменную отводит в памяти место. При этом компьютер "рассуждает" так: Раз в программе упомянута переменная величина, значит она в каждый момент времени будет иметь какое-то значение, которое, хочешь не хочешь, надо помнить. Лучше, чтобы не спутаться, отвести в памяти определенное место для запоминания текущего значения каждой переменной величины. Будем называть место, отведенное в памяти под данную переменную, ячейкой. Представьте себе город, в котором имеются разные по размерам комнаты и каждому жильцу отведена ровно одна комната. Это тот самый случай.
Теперь о размере комнат. В городе размер комнат меряют в квадратных метрах, в памяти размер ячейки выражают в байтах. Герцогу нужна более вместительная комната, чем барону. Переменной типа Single нужна более вместительная ячейка, чем переменной типа Integer. Так оно и есть на самом деле: под переменную типа Integer в памяти отводится ячейка размером 2 байта, а под переменную типа Single - 4 байта. Только не думайте, что переменная типа Single не может быть длиннее 4 цифр, компьютер для записи чисел в ячейки использует более компактную систему, чем для записи символов.
Что делает оператор присваивания с памятью
Я только что рассказывал о работе оператора присваивания, используя такие выражения, как "компьютер знает", "компьютер помнит". Но нам необходимо более строгое понимание работы этого оператора, понимание "ближе к железу".
Рассмотрим пример программы:
Dim a As Integer
Dim b As Integer
Dim y As Integer
Private Sub Command1_Click()
a = 10 : b = 6 : y = a + b + 1
Debug.Print y + 200
End Sub
В программе встречаются три переменные, поэтому все они объявлены. Компьютер отведет для них в памяти три двухбайтовые ячейки. Вот как будет работать оператор присваивания:
Выполняя оператор присваивания (например, y=a+b+1), компьютер сначала смотрит на его правую часть (a+b+1). Если в ней встречаются переменные (в нашем случае это a и b ), то компьютер перед вычислением ищет их значения в отведенных под них ячейках памяти (и находит там 10 и 6, так как их туда записали операторы а=10 и b = 6), подставляет эти значения в правую часть и вычисляет ее. Затем вычисленное значение (17) компьютер записывает в ячейку памяти, отведенную под переменную, поставленную в левой части (y).
Таким образом, когда мы говорим "Компьютер запомнил, что а равно 2", мы подразумеваем "Компьютер записал в ячейку памяти, предназначенную для а, число 2".
А теперь рассмотрим, как будут заполняться информацией ячейки a,b,y в процессе выполнения нашей программы. В самом начале выполнения программы в них находятся нули. Первым выполняется оператор а=10. Согласно только что приведенному определению оператора присваивания в ячейку a будет записано число 10. Затем выполняется оператор b= 6 и в ячейке b появляется шестерка. Затем выполняется оператор y= a+b+1. Компьютер смотрит, что находится в ячейках a и b, видит там 10 и 6, подставляет их в выражение a+b+1, получает 17 и записывает в ячейку y. Наконец выполняется оператор Debug.Print y + 200. Компьютер заглядывает в ячейку y, видит там 17, вычисляет 17+200 и выводит 217 в окно Immediate.
Схематически этот процесс можно изобразить так:
ПОРЯДОК ИСПОЛНЕНИЯ ОПЕРАТОРОВ |
ЧТО НАХОДИТСЯ В ЯЧЕЙКАХ ПАМЯТИ |
ЧТО ВИДИМ В ОКНЕ Immediate |
||
Ячейка для a |
Ячейка для b |
Ячейка для y |
||
a= 10 |
10 |
0 |
0 |
|
b= 6 |
10 |
6 |
0 |
|
y= a+b+1 |
10 |
6 |
17 |
|
Debug.Print y + 200 |
10 |
6 |
17 |
217 |
Теперь мы можем также уточнить работу оператора Debug.Print :
Если в операторе Debug.Print встречаются выражения с переменными величинами, то Visual Basic находит в памяти значения этих величин, подставляет их в выражения, вычисляет выражения и результат выводит на экран. В память же ничего не записывается.
Задание 7: Ответьте устно, что произойдет, если поменять местами операторы b= 6 и y= a+b+1?
Режим прерывания. Пошаговый режим выполнения программы
Компьютер выполняет программу со страшной скоростью. Не успели мы нажать кнопку - а результаты уже получены. Пока все идет хорошо, это нас восхищает. Когда же результаты не те, что надо (а ошибок в программе мы не видим), это начинает раздражать. Хотелось бы, чтобы компьютер работал помедленнее и хорошо бы как-нибудь подсмотреть во время работы значения переменных в памяти, это помогло бы найти ошибку. Режим прерывания для этого и предназначен.
Запустите предыдущий проект на выполнение не кнопкой Start, как вы привыкли, а клавишей F8 на клавиатуре. Это горячая клавиша для DebugStep Into. Проект начнет выполняться как обычно. Нажмите, как водится, кнопку Command1. И тут вы почувствуете разницу. Вместо того, чтобы полностью выполниться и показать результат, проект остановится на самой первой строке процедуры, а именно, на Private Sub Command1_Click(), в знак чего эта строка окажется подсвечена желтым цветом. Итак, только-только начав выполняться, наш проект замерз до тех пор, пока следующее нажатие F8 его не разморозит. "Мгновение остановилось".
Интересно, чему во время остановки равны значения переменных в памяти компьютера? Для того, чтобы узнать это, достаточно поместить мышиный курсор на обозначение переменной в тексте процедуры в окне кода. Как и положено, "на табло пока одни нули".
Еще раз F8. Ничего не происходит, только полоса подсветки прыгает на следующую строку. В ней находится первый исполняемый оператор вашей процедуры – a = 10.
F8. Visual Basic выполняет a = 10, а следующий оператор подсвечивается. Проверьте, чему сейчас равны a, b, y в памяти.
F8. Visual Basic выполняет b = 6, а следующий оператор подсвечивается. Проверьте, чему сейчас равны a, b, y в памяти.
Итак, правило простое – при нажатии на F8 Visual Basic выполняет очередной оператор программы и подсвечивает тот оператор, которому предстоит быть выполненным.
Обратите внимание, что сменился режим Visual Basic. Мы знаем пока два режима: режим проектирования [design] и режим работы [run]. Теперь в заголовке главного окна Visual Basic вы видите слово [break]. Это означает, что Visual Basic сейчас находится в режиме прерывания. Можно сказать, что режим прерывания - это режим работы с остановками. Вы можете указать Бэйсику, на каких именно операторах останавливаться. О том, как это сделать, написано в Глава 3.. Когда же вы нажимаете на F8, вы приказываете Бэйсику останавливаться на каждом операторе. Такая разновидность режима прерывания называется пошаговым режимом.
F8. Visual Basic выполняет y= a+b+1, а следующий оператор подсвечивается. Проверьте, чему сейчас равны a, b, y в памяти.
F8. Visual Basic выполняет Debug.Print y + 200, а следующий оператор подсвечивается. В окне Immediate возникает число 217.
F8. Подсветка уходит, так как процедура выполнена. Можно снова жать на кнопку Command1.
Замечание об отладке в пошаговом режиме: При отладке в пошаговом режиме вам часто нужно на экране видеть одновременно окно кода, окно Immediate и саму форму. Но при нажатии на F8 то одно, то другое часто пропадает из вида, будучи закрыто другими окнами. Чтобы этого не происходило, еще до начала отладки расположите окно кода и окно Immediate так, чтобы они не перекрывали друг друга, а главное окно Visual Basic уменьшите до части экрана. Затем после запуска отладки форму перетащите на освободившуюся часть экрана. Тогда окно Visual Basic не будет перекрывать форму и проблема исчезнет.
Итак, компьютер сделал все то, что сделал бы при нажатии Start, но только в медленном темпе.
В любой момент пошагового выполнения программы вы можете вместо F8 нажать Start, которая по такому случаю переименовывается в Continue, и программа продолжит выполняться в обычном режиме.
Оператор присваивания меняет значения переменных величин
Пока я не рассматривал программы, в которых переменные меняют свою величину. Теперь настало время такую программу рассмотреть:
Dim k As Integer
Private Sub Command1_Click()
k = 10: Debug.Print k: k = 25: Debug.Print k: k = 4: Debug.Print k
End Sub
Запишем схематически процесс изменения информации в ячейке k:
ПОРЯДОК ИСПОЛНЕНИЯ ОПЕРАТОРОВ |
ЧТО НАХОДИТСЯ В ЯЧЕЙКЕ ПАМЯТИ k |
ЧТО ВИДИМ В ОКНЕ Immediate |
k=10 |
10 |
|
Debug.Print k |
10 |
10 |
k=25 |
25 |
|
Debug.Print k |
25 |
25 |
k=4 |
4 |
|
Debug.Print k |
4 |
4 |
Как видите, в процессе работы программы содержимое ячейки k меняется. Так, при выполнении оператора k=25 там вместо значения 10 появляется 25. А куда же девается десятка? Она стирается, то есть компьютер забывает ее безвозвратно. Здесь действует общий принцип работы всех компьютеров:
Если в какое-нибудь место памяти или диска записывается новая информация, то старая информация, записанная там раньше, автоматически стирается, даже если она кому-то и нужна.
Раз теперь вместо 10 в ячейке k находится 25, то оператор Debug.Print k печатает уже 25. (Слова "печатает" и "Print" устарели, они остались от тех времен, когда мониторов еще не было, а вместо них были принтеры. Когда я по старинке говорю, что информация печатается, я подразумеваю, что она появляется на мониторе в том или ином окне.) Следующий оператор k=4 запишет на место 25 четверку, а Debug.Print k ее напечатает. Проверьте.
А что напечатает следующая программа?
Dim f As Integer
Private Sub Command1_Click()
f = 30: f = f + 4: Debug.Print f
End Sub
Оператор f=30 запишет в ячейку f число 30. А что сделает странный оператор f=f+4 ? Не думайте, что это уравнение или что-нибудь в этом роде. Это оператор присваивания, а значит и выполнится он согласно определению оператора присваивания, то есть сначала вычислит правую часть f+4 , подставив туда вместо f его значение, взятое из ячейки, и получит 34. Затем число 34 будет записано в ячейку, отведенную под переменную, обозначенную в левой части, то есть опять в ячейку f. При этом старое значение 30 будет стерто. Debug.Print f напечатает 34.
Таким образом, оператор f=f+4 просто увеличивает число в ячейке f на четверку или, другими словами, увеличивает f на 4.
Зачем это нужно? Узнаете позже. Очень даже нужно.
Задание 8:
Определите без компьютера, что будет напечатано при выполнении следующих фрагментов программ:
a=100 : a=10*a+1 : Debug.Print a
a=100 : a= -a : Debug.Print a
a=10 : b=25 : a=b-a : b=a-b : Debug.Print a, b