Бернд  Вайланд  Visual  Basic  6  для  детей
 Бернд  Вайланд
 Visual  Basic  6
 Незаменимое  пособие
по  обучению  любого  пользователя
вполне  профессиональному
компьютерному  программированию

Visual  Basic  6  для  детей

Bernd  Weiland
 Visual  Basic  6
 fur  Kids
 mitp

Бернд  Вайланд
 Visual  Basic  6
 для  детей
 Издательство  «Интерэксперт»
Москва  2002

УДК  087.5  :  004.434
ББК  32.973.26  =  018.1
В14
 Перевод  Ю.  Д.  Селюцкого
 Все  права,  в  том  числе  и  на  переведенную  версию,  сохраняются.  Ни  одна  часть  книги  в  любом  виде  (будь
то  издание,  фотокопия,  микрофильм  или  иная  форма)  не  может  быть  воспроизведена  либо  обработана,
размножена  или  распространена  без  письменного  на  то  разрешения  издательства.
 Употребление  товарных,  торговых  и  фирменных  наименований  в  этой  книге  без  воспроизводства  товарных
знаков  и  торговых  марок  может  в  соответствии  с  законом  о  защите  товарных  знаков  и  торговых  марок  не
рассматриваться  как  употребление  товарных  знаков  и  торговых  марок,  и  потому  объявлено  свободным
для  использования.
 ISBN  3-8266-0501-2  (Германия) 	©verlag  moderne  'Industrie,
 Landsberg/Lech,  1999
 ISBN  5-85523-065-1  (Россия) 	©Перевод  на  русский  язык
 и  оформление
АО  «Интерэксперт»,  2002

Оглавление
 ПРЕДИСЛОВИЕ 	7
 ВВЕДЕНИЕ 	8
 1. 	ЯЗЫК  ПРОГРАММИРОВАНИЯ  VISUAL  BASIC 	9
 Что  такое  программирование? 	10
 2. 	ВВОДНЫЙ  ПРИМЕР 	13
 Потихоньку  осваиваемся 	14
 Первая  программа 	15
 3. 	УПРАВЛЯЮЩИЕ  ЭЛЕМЕНТЫ  И  ИХ  СВОЙСТВА 	25
 Два  уровня  разработки  программы 	26
 Создание  папки 	26
 Элементы  Label  и  TextBox 	27
 Элементы  CheckBox  и  OptionButton 	32
 Элементы  ListBox  и  ComboBox 	36
 Элементы  Scroll  Bars 	41
 Таймер 	45
 Элементы  PictureBox  и  Image 	50
 4. 	ПЕРВЫЕ  ШАГИ 	53
 Режимы  выполнения  программы 	54
 Понятие  переменной 	64
 Вычисления  в  системе  Visual  Basic 	71
 Операция  деления 	75
 Подсчет  продолжается... 	79
 Усложненная  конструкция  if 	84
 5. 	ДАЛЬНЕЙШЕЕ  ИЗУЧЕНИЕ  VISUAL  BASIC 	89
 Создание  циклов 	90
 Игра  в  мяч 	91
 Цикл  for 	93
 Циклы  While 	97
 Еще  один  цикл  While 	98
 Новое  приложение  «Игра  в  мяч» 	100
 Работа  с  таймером 	102
 Мяч  продолжает  скакать 	112

6. 	ОБЪЕДИНЕНИЕ  ПЕРЕМЕННЫХ 	117
 Что  такое  масси  в? 	118
 Вторая  форма 	121
 Переменные  и  их  область  определения 	138
 Потребность  в  модуле 	142
 Работа  с  процедурами 	149
 7. 	СОЗДАНИЕ  СОБСТВЕННЫХ  ТИПОВ  ДАННЫХ 	159
 База  данных  увеличивается 	160
 Объединение  переменных 	160
 Расширение  программы 	163
 Изменения  в  программном  коде 	165
 8. 	МЕНЮ 	173
 Создание  меню 	178
 Новые  конкуренты  корпорации  Майкрософт 	184
 Полужирное  начертание  шрифта 	186
 Последний  рывок 	190
 Возвращаемые  значения 	194
 Функция  InputBox 	198
 9. 	РАБОТА  С  ДАННЫМИ 	201
 Как  открыть  файл? 	202
 Обработка  ошибок 	206
 Операции  с  переменными  типа  String 	212
 Работа  с  файлами 	214
 Сохранение  данных 	219
 ЗАКЛЮЧЕНИЕ 	224
 ПРИЛОЖЕНИЕ  А 	225
 ПРИЛОЖЕНИЕ  В 	231
 АЛФАВИТНЫЙ  УКАЗАТЕЛЬ 	235

Предисловие
 Раз  ты  взял  в  руки  эту  книгу,  ты,  очевидно,  хочешь  научиться  про¬
граммированию.  Я  могу  только  приветствовать  твое  желание.  Тот,  кто
использует  только  чужие  программы,  всегда  находится  в  зависимой  ситу¬
ации,  ожидая,  что  предоставят  в  его  распоряжение  другие  програм¬
мисты.  Но  насколько  было  бы  лучше  реализовывать  собственные  идеи,
писать  свои  игры,  создавать  новые  приложения  так,  как  того  хочется!
 Все  это  возможно.  Ты  должен  только  решиться  сделать  шаг  от  простого
пользователя  к  разработчику.  Расстояние  между  ними,  возможно,
меньше,  чем  ты  думаешь.  А  когда  ты  сделаешь  этот  шаг,  компьютер  уже
перестанет  быть  для  тебя  только  тем,  чем  был  раньше...
 Почему  именно  Visual  Basic?  Если  ты  немного  вникнешь  в  вопрос,  то
увидишь,  что  существуют  разные  языки  программирования,  подобно
тому,  как  существуют  разные  иностранные  языки  —  французский,
английский,  или,  скажем,  латынь.  Для  начинающего  Visual  Basic,
пожалуй,  является  лучшим  выбором,  так  как  этот  язык  позволяет
достаточно  быстро  получить  впечатляющие  результаты.  Уже  совсем
скоро  ты  научишься  заставлять  мяч  весело  прыгать  по  экрану  и
освоишь  основы  программирования  игр.
 Для  понимания  книги  достаточны  лишь  базовые  навыки  работы  с  Windows
95  или  Windows  98.  Ты  должен  уже  знать,  как  запускается  программа  под
Windows  и  подобные  элементарные  вещи.  Если  в  твоих  знаниях  еще  много
пробелов,  рекомендую  прочитать  сначала  какую-нибудь  книгу  по  системе
Windows  95  для  начинающих  пользователей.  Никаких  предварительных
знаний  в  области  программирования  не  требуется:  мы  начинаем  изучать
его  так,  чтобы  каждый  мог  делать  это  вместе  с  нами.
 Из  программного  обеспечения  тебе  понадобится  операционная
система  Windows  95/98  и  Visual  Basic  6.0.  Речь  идет  о  так  называемой
«рабочей  модели»,  которая  (с  некоторыми  ограничениями,  о  которых
будет  сказано  позже)  соответствует  полной  версии  и  прекрасно
годится  для  начального  ознакомления  с  языком.
 Программирование  доставляет  массу  удовольствия,  особенно  такое,
когда  результат  не  заставляет  себя  ждать.  Именно  так  и  бывает,  если
работаешь  с  языком  Visual  Basic.  Попробуй  сам,  и  ты  увидишь!
 Бернд  Вайланд,  апрель  1999

Введение
 Прежде  всего,  о  самом  главном.  Для  работы  с  книгой  необходимо,  что¬
бы  на  твоем  компьютере  была  установлена  операционная  система
Windows  95  или  Windows  98.  Кроме  того,  для  выполнения  примеров  и  за¬
даний  из  книги  тебе  понадобится  установить  Visual  Basic  на  жесткий  диск
компьютера.  Подробно  процесс  установки  системы  программирования
Visual  Basic  и  работа  с  материалами  для  выполнения  упражнений  описа¬
ны  в  приложениях  А  и  В.  Рассматриваемые  в  книге  примеры  сопровож¬
даются  подробными  объяснениями.  На  всех  этапах  создания  программ¬
ного  кода  приводятся  промежуточные  результаты.  Заглядывай  в  них
только  для  проверки  или  в  том  случае,  если  что-то  никак  не  получается.
 Чтобы  материал  книги  легче  усваивался,  и  ты  смог  быстрее  в  нем  разо¬
браться,  в  ней  используются  некоторые  символы,  которые  будут  со¬
провождать  тебя  во  время  чтения.
 Эта  стрелка  указывает  на  то,  что  ты  должен  выполнить  определенное
действие:  например,  ввести  текст  программы,  создать  форму  и  т.д.
 При  знакомстве  с  материалом  книги  ты  можешь  столкнуться  с
некоторыми  проблемами  или  оказаться  в  сложной  ситуации.  В
таком  случае  внимательно  прочти  текст,  помеченный  этим
вопросительным  знаком.
 С  помощью  рисунка  морковки  на  полях  книги  отмечена  наиболее
важная  информация.
 А  когда  в  тексте  появляется  рисунок  кролика,  это  значит,  что  ты
получишь  подсказку  или  узнаешь  маленькую  хитрость.
Хорошего  программиста  отличает  именно  знание  мелочей.
 Ну  что  же,  с  введением  покончено.  Пора  начинать!

1.  Язык  программирования
Visual  Basic
 В  первую  очередь,  на  компьютер  следует  установить  программу  Visual
Basic  версии  6.0  (в  приложении  А  детально  описаны  все  этапы  ее
установки).  Если  ты  относишься  к  тем,  кто  делает  в  программировании
первые  шаги,  то,  прежде  всего,  я  хотел  бы  объяснить,  каких
результатов  можно  достичь  с  помощью  системы  Visual  Basic.
 В  этой  главе  ты  узнаешь:
 • 	что  такое  программирование;
 • 	что  такое  язык  программирования;
 • 	что  можно  делать  с  помощью  языка  Visual  Basic.

Что  такое  программирование?
 Итак,  что  же  такое  Visual  Basic?  И  что  такое  программирование?
 В  памяти  твоего  компьютера,  наверное,  уже  находятся  некоторые  про¬
граммы:  возможно,  это  текстовый  редактор  Word,  несколько  игр  и,  ра¬
зумеется,  операционная  система,  например  Windows  95  или  Windows
98.  Как  уже  было  сказано,  все  это  —  программы,  которые  кто-то  со¬
здал  или  написал.  При  написании  программы  компьютеру  указывают,
что  от  него  требуется.  Например:  «Выведи  такое-то  изображение  на
экран,  а  когда  игрок  нажмет  на  спусковой  крючок,  сымитируй  выст¬
рел».  Или:  «Когда  пользователь  введет  текст  и  нажмет  кнопку  для  его
сохранения,  проследи,  чтобы  текст  был  записан  на  жесткий  диск».  По¬
дробное  описание  действий,  которые  должен  выполнить  компьютер,
называется  программированием.
 А  как  программируют,  то  есть  как  устанавливают  контакт  с  компьюте¬
ром?  Просто  разговаривать  с  ним  бесполезно  —  он  никак  не  отреаги¬
рует.  Поэтому  нужна  программа,  которая  бы  сообщала  компьютеру,
что  от  него  хотят.  Она  содержит  так  называемый  язык  программиро¬
вания,  понятный  вычислительной  машине.
 Языков  программирования  существует  великое  множество.  И  одним  из
них,  как  ты  уже  догадываешься,  является  Visual  Basic.
 Таким  образом,  Visual  Basic  —  это  среда  разработки,  предназна¬
ченная  для  написания  компьютерных  программ.
 Это  означает,  что,  освоив  материал  книги,  ты  научишься  самостоя¬
тельно  писать  программы  для  компьютера.  Наверное,  ты  хочешь  уз¬
нать,  что  это  за  программы,  которые  можно  написать  с  помощью
Visual  Basic.  Ответ  прост:  с  его  помощью  можно  написать  практи¬
чески  все  что  угодно.  Овладев  языком  Visual  Basic,  ты  сможешь  пи¬
сать  игры,  разрабатывать  базы  данных  по  видеокассетам,  компакт-
дискам  или  адресам  друзей  и  делать  другие  интересные  вещи.

Тем  не  менее,  кое-какие  ограничения  все-таки  имеются.  Игры  совре¬
менного  уровня,  отличающиеся  большим  количеством  действий  (на¬
пример,  Ego-Shooter),  вряд  ли  удастся  написать  с  помощью  Visual
Basic.  Для  этих  целей  используются  более  сложные  языки  программи¬
рования,  позволяющие  создавать  продукты  с  высоким  быстродействи¬
ем.  Кроме  того,  для  написания  больших  приложений  требуется  нема¬
ло  времени.  Над  такими  программами,  как  Microsoft  Word,  работает
множество  людей  в  течение  нескольких  лет,  да  и  создание  новых  игр
является  слишком  сложной  задачей  для  одного  разработчика,  учиты¬
вая,  что  над  ними  трудятся  также  композиторы  и  художники.
 Visual  Basic  является  идеальным  языком  почти  для  всех  про¬
грамм,  которые  ты  напишешь  в  обозримом  будущем.  А  если  по¬
том  ты  захочешь  профессионально  заниматься  программирова¬
нием,  и  тебе  потребуется  изучить  другие  языки,  то  это  получится
быстрее,  если  ты  уже  изучил  Visual  Basic.
 Если  окажется,  что  создаваемая  тобой  программа  слишком  гро¬
моздкая,  можно  попытаться  найти  единомышленников  и  продол¬
жить  работу  вместе  с  ними.  Многие  программисты  ищут  коллег  в
Интернете  для  совместного  создания  игр  или  приложений.

2*  вводный  пример
 Итак,  этап  установки  программы  Visual  Basic  с  компакт-диска  пройден
и  можно  двигаться  дальше.
 В  этой  главе  ты  узнаешь:
 • 	как  запустить  Visual  Basic;
 • 	что  такое  пользовательская  оболочка;
 • 	что  можно  сделать  с  помощью  окна  свойств  и  панели  инструментов;
 • 	чем  отличается  окно  объекта  от  окна  кода;
 • 	для  чего  нужно  окно  проекта;
 • 	как  сохранить  программу.
 Кроме  того,  ты  напишешь  свою  первую  программу!

Потихоньку  осваиваемся
 ^  Вначале  запусти  Visual  Basic.  В  меню  Start  (Пуск)  системы  Windows
95/98  укажи  последовательно  команды  Programs  (Программы)  и
Microsoft  Visual  Basic  6.0.  В  центре  экрана  появится  следующее  окно:
 Окно,  появляющееся  при  запуске  Visual  Basic
 Если  мы  хотим  написать  программу,  нам  нужно  выбрать  значок
Standard.EXE.  Этот  вариант,  как  вариант  по  умолчанию,  уже  выделен
синим  цветом.  Поэтому  мы  просто  нажимаем  клавишу  Enter.
Появляется  окно  с  разными  элементами.
 Рассмотрим  его  повнимательнее,  чтобы  ты  быстрее  освоился  в  среде
Visual  Basic  и  не  испытывал  трудностей  при  создании  первой
программы.
 Перед  тобой  на  экране  так  называемая  пользовательская  оболочка.
Собственно  говоря,  Visual  Basic  —  не  только  язык  программирования,
но  и  набор  вспомогательных  средств,  облегчающих  работу  с  ним.  Не
смущайся,  что  на  экране  много  незнакомых  элементов,  —  я  подробно
расскажу  тебе  о  них  позже.

Все  готово  для  создания  первой  программы
 Настоятельно  советую  не  просто  читать  книгу,  но  работать  с  ней.
Запусти  программу  Visual  Basic  и  рассмотри  пользовательскую
оболочку.  Программы,  которые  будут  рассматриваться  далее,
пиши  самостоятельно.  Чем  больше  ты  сделаешь  сам,  тем
быстрее  всему  научишься.
 Первая  программа
 Прежде  чем  переходить  к  деталям  разработки  приложений,  я  хотел
бы  на  коротком  и  простом  примере  показать,  что  такое
программирование  на  языке  Visual  Basic.  Если  ты  не  вполне  поймешь
то,  о  чем  сейчас  пойдет  речь,  —  не  страшно,  так  как  этот  материал
более  подробно  описан  в  следующих  главах.

Вначале  обратимся  к  окну,  которое  называется  FORM1  и  расположено
почти  в  центре  экрана.  В  нем  отображаются  те  элементы,  с  которыми
пользователь  может  работать  после  создания  программы.  При
желании  его  размер  меняется,  но  мы  оставим  его  таким,  как  он  есть.
Хочешь,  изменим  заголовок  FORM1  на  Первая  программа
кролика?  Если  предложенное  название  тебе  не  нравится,  выбери
другое.  В  любом  случае  тебе  нужно  знать,  как  изменить  заголовок.
Для  этого  рассмотрим  другую  часть  окна  разработки  —  окно  свойств.
Оно  находится  справа  от  центрального  окна  и  называется  Properties  -
Forml.  Впоследствии  оно  нам  еще  очень  пригодится.  Окно  выглядит
следующим  образом:
 Окно  свойств
 Слева  в  этом  окне  находится  список  разных  свойств,  а  справа
приведены  значения,  соответствующие  свойствам  в  текущий
момент.  Найди  свойство  Caption  (Заголовок).  В  данный  момент
справа  в  этой  строке  написано  Forml.
 Чтобы  изменить  название,  щелкни  дважды  левой  кнопкой  мыши
правую  сторону  поля  Caption.  Надпись  Caption  выделится  синим
цветом.  Это  говорит  о  том,  что  значение  данного  свойства  изменяется
на  вводимое  с  клавиатуры.
 Введи  название  Первая  программа  кролика  (или  какое-либо
другое)  и  постарайся  увидеть,  как  название  центрального  окна
меняется  вслед  за  набираемым  на  клавиатуре  текстом.

Новое  название  программы
 Итак,  название  окна  изменилось.  После  этого  необходимо  сохранить
полученный  результат.  Данную  операцию  следует  производить  как
можно  чаще:  если  программа  или  компьютер  дадут  сбой,  то  внесенные
изменения  не  запишутся,  и  все  придется  делать  заново.
 Как  сохранить  программу?  Посмотри  на  первую  строку  в  среде
разработки  Visual  Basic,  расположенную  под  строкой  названия.
Ты  увидишь  набор  имен  меню:  File  (Файл),  Edit  (Правка)  и  т.д.
Это  —  строка  меню.  Выбери  меню  File.  Раскроется  следующий
список  с  отдельными  командами  меню.
 Меню  File

Обрати  внимание  только  на  команды  сохранения,
расположенные  чуть  выше  середины  раскрывшегося  меню.  Как
видишь,  Visual  Basic  делает  различие  между  сохранением
проекта  и  сохранением  формы.  С  чем  это  связано?
 У  нас  имеется  только  одна  форма  —  та,  которая  в  начале  работы
появилась  на  экране.  Но  в  дальнейшем  количество  форм
увеличится.  Например,  если  в  текстовом  редакторе  Word  в  меню
File  указать  команду  Open  (Открыть),  откроется  окно  для
открытия  файлов.  Подобное  окно  в  системе  Visual  Basic
называется  формой.  Таким  образом,  проект  —  под  ним  Visual
Basic  понимает  все  программы,  —  может  состоять  из  нескольких
форм.  Проект  и  каждая  форма  сохраняются  отдельно.  Название
проекта  имеет  окончание  vbp,  формы  —  f  rm.  Их  система  Visual
Basic  добавляет  сама.
 Для  начала  выбери  какую-нибудь  папку  (ты  знаешь,  как  создать  папку
в  Windows  95/98?),  затем  укажи  одну  за  другой  обе  команды  и
сохрани  проект  под  именем  Первая  программа  кролика.  Итак,
результат  записан.  В  дальнейшем  сохранять  его  будет  проще:  на
панели  инструментов  (под  строкой  меню)  находится  изображение
дискеты.  Подведи  к  нему  курсор  мыши  и  задержи  его  ненадолго.
Появится  подсказка  Save  Project  (Сохранить  проект).  Это  та  команда,
которая  требуется.  Щелкни  этот  значок  левой  кнопкой  мыши.
 Если  после  завершения  работы  с  программой  Visual  Basic  ты
захотел  вернуться  к  проекту,  укажи  в  меню  File  команду  Open
Project  (Открыть  проект)  или  найди  в  самом  низу  указанного
меню  названия  четырех  последних  проектов  Visual  Basic,  над
которыми  ты  трудился,  и  выбери  требуемый.

Вернемся  к  нашей  программе  и  попробуем  создать
управляющую  кнопку  Выход,  при  нажатии  которой
должна  завершиться  работа  программы.  Данный  пример
поможет  тебе  уяснить  основы  программирования  на
языке  Visual  Basic.  Итак,  создадим  в  открытом  окне
кнопку.  Посмотри  на  панель  со  значками,  находящуюся
слева  от  главного  окна.  Это  панель  инструментов
General  (Общие).
 Панель  инструментов
 Подведи  курсор  мыши  к  какому-нибудь  значку,  не  щелкая  его,  —  на
экране  снова  всплывет  подсказка.  С  самыми  важными  из  этих  значков
мы  познакомимся  впоследствии.  Нам  нужен  значок  CommandButton  —
на  панели  инструментов  он  третий  сверху  в  правом  столбце.  Дважды
щелкни  его  мышью,  чтобы  в  центре  формы,  как  по  мановению
волшебной  палочки,  появилась  кнопка.
 На  кнопке  написано  Command  1.  Назовем  ее  Выход.
 Снова  посмотри  направо,  на  окно  свойств.  Теперь  оно  должно
называться  Command  1  CommandButton.  Если  это  не  так,  то  щелкни
кнопку  мышью.
 Обрати  внимание,  что  справа  от  свойства  Caption  в  настоящий  момент
написано  Command  1.  Щелкни  этот  текст  мышью  и  измени  его  на
Выход.  Ты  увидишь,  что  надпись  на  кнопке  изменится
соответствующим  образом.

Первая  программа  с  кнопкой  Выход
 Снова  сохрани  программу,  щелкнув  мышью  значок  дискеты.  Затем
выполни  программу.  Это  делается  очень  просто:  нажми  клавишу  F5
(почему  именно  эту  клавишу,  не  знает  никто,  кроме  разработчиков
компании  Майкрософт).
 В  окне  выполняющейся  программы  отсутствуют  только  панели
инструментов,  имеющиеся  в  окне  разработки.  В  остальном  она
выглядит  точно  так  же.
 Поздравляю:  ты  написал  и  запустил  первую  программу  на  языке  Visual
Basic.
 Нажми  кнопку  Выход,  чтобы  программа  завершила  свою  работу.
 Однако  программа  и  не  думает  этого  делать.  Кнопка  нажата,  но  ничего
не  происходит.
 Если  вдуматься,  такое  поведение  программы  совершенно
естественно.  Откуда  она  знает,  что  при  нажатии  этой  кнопки  ей
следует  завершить  работу?  Только  потому,  что  на  кнопке
написано  Выход?  Вот  с  этого-то  момента  и  начинается
собственно  работа  программиста,  —  внешний  вид  программы
может  оформить  любой,  в  том  числе  и  тот,  кто  не  имеет  никакого
представления  о  компьютере.

Выйдем  из  программы  и  вернемся  в  среду  разработки.  Если  ты
хотя  бы  немного  знаком  с  операционной  системой  Windows
95/98,  то  знаешь,  что  для  завершения  работы  программы  нужно
нажать  кнопку  с  изображением  крестика,  расположенную  в
верхнем  правом  углу  окна.  Этот  способ  выхода  принадлежит  к
числу  функций,  представленных  в  качестве  готовых  частей
системы  Visual  Basic.
 Снова  переходим  в  окно  разработки,  чтобы  определить
 функциональные  возможности  кнопки  Выход.
 Ты  уже  видел,  что  однократный  щелчок  мышью  этой  кнопки  в
окне  разработки  выделяет  ее.  Она  отчетливо  обозначается,  и  ее
можно  изменить,  например  с  помощью  окна  свойств.  Попробуем
дважды  щелкнуть  мышью  эту  кнопку.  Что  произошло?  На  экране
появилось  новое  окно,  которое  в  нашем  случае,  если  ты  не  менял
названия,  должно  называться  Projectl  -  Forml  (Code).
 Окно  программного  кода
 Слово  Code  указывает  на  то,  что  перед  нами  окно
программного  кода.  Под  кодом  понимается  текст  программы,
то  есть  то,  что  определяет  ее  функциональные  возможности.

Повторю:  в  результате  двойного  щелчка  программного  объекта
(например,  кнопки)  происходит  переход  из  окна  объекта  (в
котором  мы,  сами  того  не  зная,  находились  все  это  время)  в
окно  кода.  Если  в  окне  объекта  определяется  внешний  вид
программы,  то  в  окне  кода  с  клавиатуры  вводятся  команды,
заставляющие  ее  работать.
 Можно  легко  переходить  из  окна  объекта  в  окно  программного
кода  и  наоборот.  В  правой  части  экрана  над  окном  свойств
находится  окно  проекта.  Щелкни  мышью  значок  слева  вверху  и
перейди  в  окно  программного  кода.  Соседний  значок  справа
поможет  вернуться  в  окно  объекта.
 Окно  проекта
 Внимательнее  рассмотри  окно  проекта.  Если  при  загрузке
программы  на  экране  не  появляется  окна  формы,  может
оказаться,  что  она  еще  не  выбрана.  Щелкни  в  окне  проекта
перед  словом  Forms  небольшой  знак  плюса  и  выбери  нужную
форму  из  имеющихся  в  программе.

Займемся  текстом  программы  и  окном  кода.  Под  заголовком  окна
система  Visual  Basic  предоставила  каркас  программы.  Мы  обсудим,
что  означают  слова  Option  Explicit,  в  главе  4,  а  пока  рассмотрим
в  окне  следующий  текст:
 Private  Sub  Comnandl_Click  ()
 End  Sub
 Это  —  рамки,  в  которые  программист  вводит  команды,  выполняющие¬
ся  при  нажатии  кнопки.  В  нашем  случае  работу  программы  завершает
следующая  простая  команда:
 End
 Введи  текст  этой  команды  в  каркас  программы  (курсор  уже  в  нем
находится).
 Команду  можно  печатать  как  прописными,  так  и  строчными
буквами.  В  отличие  от  других  языков,  например  C/C++,  Visual
Basic  не  делает  различия  между  регистрами.
 Снова  сохрани  программу  и  выполни  ее,  нажав  клавишу  F5.  Затем
нажми  кнопку  Выход.
 Итак,  ты  создал  первую  программу.  Несмотря  на  то,  что  в  ней  нет
ничего  особенного,  ты  все  же  получил  представление  о  том,  какие
возможности  предоставляет  Visual  Basic  и,  вероятно,  самое  главное  —
удовольствие  программировать  на  этом  языке.  И  хотя  путь  до  мастера
еще  далек,  поверь  мне,  твои  усилия  оправдаются.

3. 	Управляющие  элементы
и  их  свойства
 После  «пробного  забега»  тебе,  конечно,  хочется  узнать,  что  еще
может  предложить  язык  Visual  Basic,  как  писать  более  сложные
программы  и  т.д.  Мы  постепенно  приблизимся  к  ответу  на  эти  вопросы.
 В  этой  главе  ты  узнаешь:
 • 	как  создавать  папки,  и  зачем  они  нужны;
 • 	что  такое  управляющие  элементы  и  как  с  ними  работать;
 • 	как  использовать  основные  элементы  управления
 • 	чем  может  быть  полезен  таймер.
 С  помощью  управляющих  элементов  PictureBox  и  Image  ты  войдешь
в  мир  графического  программирования.

Два  уровня  разработки  программы
 Ты  не  забыл,  что  такое  панель  инструментов,  и  где  она  находится?
Верно,  она  находится  слева  в  окне  разработки  языка  Visual  Basic.
Отдельные  значки  этой  панели,  из  которых  ты  уже  знаешь  командную
кнопку  CommandButton,  называются  управляющими  элементами
(controls).  Начнем  систематически  знакомиться  с  ними.
 Разницу  между  двумя  уровнями  программирования  ты,
наверное,  почувствовал  уже  на  вводном  примере.  На  всякий
случай  замечу,  что  в  нем  к  пользовательской  оболочке  относится
командная  кнопка  Выход,  являющаяся  графическим  элементом.
Она  всего  лишь  отображается  на  экране,  в  то  время  как  за  ее
функциональные  возможности  (то  есть  реальное  окончание
работы  программы  при  нажатии  кнопки)  отвечает  текст
программы  —  в  нашем  случае  команда  end.
 Поскольку  в  этой  и  последующих  главах  мы  будем  выполнять
большое  количество  примеров,  тебе  следует  создать  на  жестком
диске  папку,  в  которой  они  будут  храниться.  В  операционной
системе  Windows  95/98  это  делается  следующим  образом.
 Создание  папки

• 	Дважды  щелкни  мышью  значок  My  computer  (Мой  компьютер),
затем  значок  нужного  жесткого  диска  (если  у  тебя  их  несколько)
и  в  меню  File  последовательно  укажи  команды  New  (Создать)  и
Folder  (Папку).  Разумеется,  для  этого  можно  воспользоваться  и
проводником.
 • 	Присвой  папке  имя,  какое  тебе  больше  нравится;  на  мой  взгляд,
разумно  было  бы  назвать  ее  УВПрограммы  или  подобным  обра¬
зом.
 • 	Внимательно  следи  за  тем,  чтобы  разные  проекты  на  Visual  Basic,
а  также  формы  (ты  понимаешь  разницу  между  ними?)  назывались
по-разному,  —  иначе  неизбежна  путаница.  Для  полной  надежнос¬
ти  в  новой  папке  можно  создать  дополнительные  вложенные  пап¬
ки  (непосредственно  из  среды  Visual  Basic),  воспользовавшись  в
окне  сохранения  на  панели  инструментов  кнопкой  New  Folder
(Создать  папку).  Профессионалы  для  полной  уверенности  созда¬
ют  для  каждого  проекта  отдельную  папку.  Хорошо,  если  ты  при¬
учишься  поступать  так  же.
 Кнопка  New  Folder  (третья  справа)
 Элементы  Label  и  TextBox
 Управляющие  элементы  Label  (Метка)  и  TextBox  (Текстовое  окно)
обычно  расположены  во  второй  строке  панели  инструментов.

Подведи  к  ним  курсор  мыши,  чтобы  увидеть  подсказку.
 Оба  управляющих  элемента  могут  содержать  текст.  Разница
между  ними  состоит  в  том,  что  пользователь  не  может  изменять
текст  элемента  Label,  а  текст  TextBox  —  может.  Элемент
TextBox  часто  служит  для  ввода  пользователем  некоторых  дан¬
ных.
 Создай  новый  проект.  Для  этого  в  меню  File  следует  указать  команду
New  Project  (Создать  проект).
 Дважды  щелкни  мышью  значок  Label  на  панели  инструментов.
 Как  и  следовало  ожидать,  в  середине  формы  появляется
управляющий  элемент  с  надписью  Label  1.  Прежде  всего,  заменим  это
название  на  Введи  свое  имя  —  ты  помнишь,  как  это  сделать?
 В  окне  свойств  щелкни  мышью  строку  Caption  и  замени  текст  в  поле
справа.  Видно,  что  он  не  помещается  в  управляющем  элементе
полностью.  Значит,  необходимо  изменить  размер  элемента.
 По  сторонам  управляющего  элемента  находятся  квадратики.  Они
называются  держателями,  так  как  за  них  можно  ухватить  и  растянуть
его  до  нужной  формы.
 Подведи  курсор  к  среднему  квадратику  на  правой  стороне,  щелкни
его  мышью  и  перемести  ее  вправо,  удерживая  нажатой  левую
кнопку.  Растягивай  элемент  до  тех  пор,  пока  в  нем  не  поместится
весь  текст.
 Изменим  положение  элемента  Label  в  форме.  Он  слишком  далеко
смещен  вправо  (посередине  он  выглядел  бы  красивее).  Кроме  того,
под  ним  нужно  еще  оставить  место  для  элемента  TextBox,  в  который
пользователь  сможет  ввести  свое  имя.  Поэтому  сдвинь  Label  налево  и
вверх.
 Подведи  указатель  мыши  к  элементу  Label  и  щелкни  его.  Удерживая
левую  кнопку  мыши  нажатой,  можно  перемещать  управляющий
элемент  в  любом  направлении.

Если  тебе  не  удается  горизонтально  расположить  элемент  точно
посередине,  в  меню  Format  (Формат)  выбери  последовательно
команды  Center  in  Form  (Разместить  по  центру  формы)  и
Horizontally  (По  горизонтали).
 Рассмотрим  некоторые  свойства  управляющего  элемента  Label  1.  Ты
знаешь,  где  их  увидеть?  В  правой  части  экрана  окна  свойств.  Сначала
изменим  имя.
 Имя  (Name)  (оно  находится  в  верхней  части  окна  свойств)  не
имеет  ничего  общего  с  Caption.  Caption  —  это  лишь  название  или
заголовок  управляющего  элемента  либо  формы,  в  то  время  как
вся  работа  с  ними  происходит  с  использованием  имени.
Помнишь  пример  из  главы  2?  Мы  присвоили  кнопке  название
Выход.  Таким  образом,  Выход  —  значение  свойства  Caption
данной  кнопки.  Если  же  ты  вдруг  захочешь  обратиться  к
управляющему  элементу,  например,  для  того  чтобы  изменить
текст  во  время  работы  программы,  то  тебе  придется
воспользоваться  именем  этого  элемента.  Как  конкретно  это
происходит,  я  расскажу  в  следующих  главах.  Сейчас  просто
запомни,  что  Name  и  Caption  —  вовсе  не  одно  и  то  же.
 Какое  имя  лучше  всего  присвоить  элементу  Label?  Оно  должно
быть  по  возможности  информативным.  Для  этого  принято  в  его
начале  указывать  тип  элемента  управления  (в  данном  случае
Label),  как  правило,  в  сокращенном  виде  (1Ы).  Далее  следует
конкретное  обозначение,  например  Namelnput  (Ввод  имени).
Полностью  элемент  Label  получает  название  lblNamelnput  —
разумеется,  ты  можешь  придумать  что-то  лучшее.

Щелкни  мышью  поле,  расположенное  справа  от  слова  Name  в  окне
свойств,  и  введи  новое  название.
 Может  быть,  тебе  не  нравится  тип  шрифта  или  его  размер?  Тогда
воспользуйся  свойством  Font  (Шрифт).
 Снова  щелкни  мышью  правую  часть  строки  этого  свойства  в
соответствующем  окне  (возможно,  сейчас  в  нем  указано  название
определенного  шрифта  —  MS  Sans  Serif).  Ты  увидишь  кнопку  с
многоточием.  Это  означает,  что  имеются  другие  возможности,
которые  можно  выбрать  из  раскрывающегося  меню.  Нажми  ее  и
выбери,  что  хочешь.
 Наконец,  присвой  свойству  Autosize  (Автоподстройка  размера)
значение  True  (Верно).  При  этом  величина  управляющего  элемента
автоматически  подгонится  под  размер  текста,  и  лишних  полей  не
останется.  Сделать  это  очень  просто:  щелкни  мышью  правую  часть
строки  этого  свойства,  где  сейчас,  видимо,  указано  False  (Ложно).
Справа  появится  стрелка,  которую  тоже  нужно  щелкнуть  мышью.
Выбери  значение  True.
 Потребуется  время,  чтобы  научиться  выполнять  указанные
действия.  Но  можешь  быть  уверен:  немного  попрактиковавшись,
ты  станешь  совершать  их  не  задумываясь.
 Форма  должна  выглядеть
примерно  так:

Создадим  управляющий  элемент  TextBox,  чтобы  пользователь  мог
выполнить  наше  требование,  введя  свое  имя.  Ты  уже  знаешь,  как  это
сделать.
 В  панели  инструментов  дважды  щелкни  мышью  значок  TextBox.  На
экране  (точнее,  в  центре  формы)  появится  элемент  TextBox.  Замени
его  имя  на  txtName  (txt  —  общепринятое  сокращение  от  TextBox).
 Значение  по  умолчанию  Textl  поля  нашего  элемента  мы,  конечно,  не
будем  использовать.  Оно  должно  быть  пустым.  Для  этого  выбери
свойство  Text  (Текст)  в  окне  свойств  и  удали  текст,  стоящий  в  правой
части  соответствующей  строки.
 Кроме  того,  поле  слишком  небольшое,  чтобы  в  него  можно  было
ввести  имя  целиком.  Поэтому  щелкни  мышью  управляющий  элемент  и
растяни  его  за  держатели  до  нужной  длины  и  высоты.  Форма  станет
выглядеть  примерно  так:
 Окончательный  вид  формы
 Настало  время  для  пробного  запуска  программы.
 Ты  знаешь,  что  нужно  сделать:  нажать  кнопку  F5.  После  этого  введи  в
поле  элемента  TextBox  свое  имя  (или  какое-либо  другое).
 Для  завершения  работы  программы  нажми  кнопку  с  изображением
крестика  в  правой  верхней  части  экрана.  Таким  образом,  мы  создали
целую  программу  на  Visual  Basic,  не  написав  ни  единой  строчки
программного  кода!

Несколько  небольших  заданий
 Добавь  в  программу  кнопку  Выход  с  соответствующим  программным
кодом.
 В  строке  заголовка  нашей  программы  написано  Forml.  Замени
заголовок  на  какой-нибудь  более  конкретный.  Советую  учесть,  что  при
этом  изменится  значение  свойства  Caption  формы.
 Измени  шрифт  управляющего  элемента  TextBox  так,  чтобы  введенный
текст  имел  больший  размер  и  был  полужирным.
 Элементы  CheckBox  и  OptlonButton
 От  пользователя  не  всегда  требуется,  чтобы  он  ввел  какой-то  текст,  как
в  случае  с  элементом  TextBox.  Иногда  необходимо,  чтобы  он  всего
лишь  выбрал  один  из  нескольких  предоставленных  ему  вариантов.  И
такая  возможность  существует,  что  иллюстрирует  следующий  пример.
 Начнем  создавать  программу,  выбрав  в  меню  File  команду  New
Project.  Так  как  нам  понадобится  довольно  много  места,  растяни
форму  в  длину  и  ширину.  Для  этого  щелкни  держатель  в  нижнем
правом  углу  и  перемести  мышь,  удерживая  нажатой  ее  левую  кнопку.
 Найди  на  панели  инструментов  значок  с  галочкой  и  подсказкой
CheckBox  (Флажок)  и  дважды  щелкни  его  мышью.
 Растяни  появившийся  управляющий  элемент  влево  и  повтори
описанные  действия  еще  дважды.  Расположи  три  созданных  элемента
управления  друг  под  другом.
 В  левой  части  формы  находятся  три  управляющих  элемента  Checkl,
Check2  и  Check3.  Для  сравнения  взгляни  на  полученный  мною
результат:

Три  элемента  CheckBox
 Тебе  трудно  расположить  три  элемента  CheckBox  точно  друг
под  другом  и  на  одинаковом  расстоянии?  Укажи  последователь¬
но  в  меню  Format  команды  Align  (Выровнять)  и  Vertical
Spacing  (Иинтервал  по  вертикали).  Но  прежде  чем  их  выбрать,
выдели  все  три  элемента  одновременно.  Как  это  сделать?  Щелк¬
ни  мышью  первый  из  них,  затем  нажми  клавишу  Shift  и,  удержи¬
вая  ее  в  таком  положении,  выбери  оба  других  элемента.  В  ре¬
зультате  все  они  выделятся.
 Запусти  программу,  нажав  клавишу  F5  (далее  я  уже  не  буду  этого
повторять).  Если  затем  щелкнуть  мышью  управляющий  элемент
(выделить  его),  то  появится  галочка.  При  следующем  щелчке  она
исчезает.  Заметь,  что  управляющие  элементы  можно  щелкать  мышью
независимо  друг  от  друга,  одновременно  выделяя  несколько  из  них.

Элементы  CheckBox  используют  для  одновременного  указания
нескольких  разных  вариантов.  Представь  себе,  что  ты
разрабатываешь  форму  для  анкеты,  в  которой  пользователь
должен  указать,  является  ли  он  лицом  мужского  пола  и  женат  ли
он:  вполне  возможно,  что  на  эти  вопросы  будут  даны  два
положительных  ответа.
 Другое  дело,  если  необходимо  узнать  его  пол.  В  этом  случае
возможен  только  один  из  двух  имеющихся  вариантов,  поэтому
элемент  CheckBox  не  используется.
 Вместо  него  мы  выберем  элемент  OptionButton  (Кнопка  выбора
вариантов)  (называемый  также  RadioButton  (Переключатель)),
который  обычно  расположен  на  панели  инструментов  рядом  с
элементом  CheckBox.
 Расположи  эти  два  управляющих  элемента  в  форме  один  под  другим,
справа  от  трех  элементов  CheckBox,  и  запусти  программу.
 Ты  видишь,  что  одновременно  эти  элементы  не  выделяются.  Кстати,
именно  по  этой  причине  в  их  названии  используется  слово  radio  (в
переводе  с  английского  оно  означает  «радио»:  радиоприемник  может
ловить  в  определенный  момент  времени  только  одну  волну).  Чтобы
выбрать  значение  по  умолчанию,  необходимо  установить  свойство
Value  (Значение)  равным  True.  Тогда  соответствующий  элемент  при
выполнении  программы  автоматически  станет  выделенным.
Разумеется,  это  можно  сделать  только  с  одним  из  элементов
OptionButton.
 Для  того  чтобы  наша  конструкция  заработала,  мы  напишем
небольшой  кусок  программного  кода.
 Присвой  верхнему  элементу  OptionButton  имя  optMasculine;  в
строке  Caption  укажи  Мужской.  И  то,  и  другое  делается  с  помощью
окна  свойств,  когда  верхний  элемент  OptionButton  выделен.

Второму  элементу  OptionButton  присвой  имя  optFeminine,  а  в  строке
Caption  укажи  Женский.  Значение  свойства  Value  обоих  элементов
оставим  равным  False,  —  пользователь  должен  определиться  самосто¬
ятельно.
 Форма  примет  следующий  вид:
 Окончательный  вид  формы
 Дважды  щелкнув  мышью  верхний  элемент,  перейди  в  окно
программного  кода.
 В  нем,  как  ты  уже  догадываешься,  нас  ожидает  текст
 Private  Sub  optmasculine_Click
End
 Введи  в  него  следующую  строку:
 MsgBox  "Вы  мужчина"
 MsgBox  —  это  сокращение  от  MessageBox  (окно,  в  котором  выдается
сообщение).  В  простейшей  форме  такие  окна  содержат  только  текст
(указываемый  в  кавычках  после  команды  MsgBox)  и  кнопку  ОК,
которую  пользователь  нажимает  для  того,  чтобы  программа
продолжила  работу.
 Запускаем  программу.  Щелкнув  мышью  верхний  элемент
OptionButton,  пользователь  увидит  на  экране  следующее:

О/сяо  работающего  приложения  и  окно  сообщения
 Несколько  небольших  заданий
 Напиши  аналогичный  программный  код  для  элемента  OptionButton
optFeminine  и  выполни  программу.
 Придумай  разумное  применение  трем  элементам  CheckBox  (располо¬
женных  в  левой  части  формы),  измени  их  имена  и  создай  подходящие
окна  сообщений.
 Управляющие  элементы  ListBox  (Окно  списка)  и  ComboBox  (Комбини¬
рованное  окно)  расположены  обычно  в  пятой  строке  панели  инструмен¬
тов.  Начнем  с  элемента  ListBox.  Он  предлагает  пользователю  на  выбор
один  из  имеющихся  вариантов.  Типичный  случай  —  выбор  шрифта  в  тек¬
стовом  редакторе.  В  качестве  учебного  примера  мы  предложим  пользо¬
вателю  список  имен,  из  которых  он  должен  выбрать  одно.
 Создай  новый  проект.  Присвой  форме  имя  frmName,  а  ее  исходный
заголовок  (Caption)  замени  на  Выбор  имени.  Немного  увеличь  ее
размер.
 Дважды  щелкни  мышью  значок  ListBox  на  панели  инструментов,  рас¬
тяни  появившийся  элемент  до  нужных  размеров  и  сдвинь  его  немного
влево.  В  строке  Name  в  окне  свойств  введи  IstName.
 Элементы  ListBox  и  ComboBox

Однако  теперь  это  имя  указано  и  в  поле  самого  элемента  ListBox.
Заменим  его  другим  именем  с  помощью  свойства  List  (Список).
 Щелкни  мышью  строку  этого  свойства,  а  затем  появившуюся  стрелку.
Введи  имена.
 После  ввода  каждого  имени  не  следует  нажимать  клавишу  Enter,
так  как  тогда  закроется  окно  ввода.  Нажимай  одновременно
клавиши  Ctrl  и  Enter.  Нам  достаточно  ввести  четыре-пять  имен.
 В  заключение  измени  размер  элемента  ListBox  таким  образом,  чтобы
все  имена  были  видны,  и  не  оставалось  пробелов.
 Окно  формы  примет  следующий  вид:
 Элемент  ListBox  с  именами
 Расширим  функциональные  возможности  нашей  программы.  Для
этого  напишем  несколько  строк  программного  кода.
 Дважды  щелкни  мышью  элемент  ListBox,  чтобы  на  экране  появилось
окно  программного  кода.  В  нем,  как  обычно,  находится  каркас
программы.

Private  Sub  lstName_Click()
 End  Sub
 Введи  в  него  следующий  программный  код:
 If  IstName.Listlndex  =  0  Then
 MsgBox  "Вы  выбрали  имя  Иван"
 End  If
 If  IstName.ListIndex  =  1  Then
 MsgBox  "Вы  выбрали  имя  Петр"
 End  If
 If  IstName.Listlndex  =  2  Then
 MsgBox  "Вы  выбрали  имя  Василий"
End  If
 If  IstName.Listlndex  =  3  Then
 MsgBox  "Вы  выбрали  имя  Алексей"
End  If
 If  IstName.Listlndex  =  4  Then
 MsgBox  "Вы  выбрали  имя  Сергей"
End  I  f
 Естественно,  ты  должен  заменить  приведенные  здесь  имена  теми
которые  сам  ввел  в  поле  ListBox.
 Листинг  программного  кода

С  инструкции  if  начинается  опрос  (существуют  более  разумные
решения,  но  о  них  мы  поговорим  позже).  Конструкция  if  -  then
означает  «если  -  то»,  или  подробнее:
 Если  нечто  имеет  место,  то  должно  произойти  то-то  и  то-то.
 В  нашем  примере  данная  конструкция  означает  следующее:
 Если  пользователь  выбрал  имя  Иван  (аналогично  и  для  остальных
имен  из  списка),  то  программа  должна  выдать  окно  MessageBox
с  соответствующим  сообщением.
 • 	Каждая  конструкция  i  f  заканчивается  инструкцией  End  i  f.
 • 	Программе  требуется  определить,  какое  имя  выбрал  пользователь.
Для  обращения  к  отдельным  элементам  списка  (в  нашем  случае
именам)  используется  инструкция  IstName.  List  Index.  Первый
элемент  списка  имеет  номер  0  (компьютер,  как  правило,  начинает
считать  с  нуля),  второй  —  1  и  т.  д.
 • 	Таким  образом,  инструкция  If  IstName.Listlndex  =  0  Then
означает:
 «Если  пользователь  выбрал  первое  имя  из  списка,  то  выдается
соответствующее  сообщение».
 Вполне  может  оказаться,  что  пользователю  не  понравится  ни  одно  из
приведенных  в  списке  имен.  Было  бы  лучше,  если  бы  он  мог  сам  ввести
дополнительные  имена,  чтобы  расширить  возможности  выбора.  Для
этого  воспользуемся  управляющим  элементом  ComboBox.
 Щелкни  мышью  соответствующий  значок  на  панели  инструментов.  В
форме  появится  элемент  ComboBox.  Сдвинь  его  немного  вправо  и
задай  в  окне  свойств  имя  cboName.  Как  и  прежде,  в  окне  свойств  в
поле  List  можно  ввести  какие-либо  имена,  например  те  же,  что  и  в
ListBox.  Удали  текст  Combol  в  поле  свойства  Text.

Если  ты  выполнишь  программу,  то  поле  элемента  ComboBox  (он
обычно  не  развернут)  будет  пустым.  После  нажатия  кнопки  со
стрелкой,  расположенной  на  правом  краю  данного  элемента,  он
раскроется,  и  ты  увидишь  его  содержимое.
 .  Выбор  имени
 Результат  выполнения  программы
 При  двойном  щелчке  мышью  строки  раскрывающегося  списка
соответствующий  элемент  переходит  в  верхнее  поле
управляющего  элемента  ComboBox  и  остается  в  нем.
 Введи  во  время  работы  программы  в  пустое  поле  какое-нибудь  имя.
Оно  должно  появиться  в  нашем  списке  имен,  но,  к  сожалению,  этого
не  происходит:  необходимы  специальные  ухищрения.  Мы  не  станем
говорить  о  них  —  достаточно  и  того,  что  ты  познакомился  с
управляющим  элементом  ComboBox,  и  понял,  чем  он  отличается  от
ListBox.

Несколько  небольших  заданий
 Измени  размер  и  тип  шрифта  управляющих  элементов  ListBox  и
ComboBox.  Для  этого  воспользуйся  свойством  Font.
 На  рисунке  приведен  результат  выполнения  программы.  Постарайся
создать  соответствующую  форму  и  написать  необходимый
программный  код.  Советую  для  создания  окна  сообщения
использовать  конструкцию  if,  которую  мы  только  что  обсуждали.
 Элементы  ScrollBars  (Полосы  прокрутки)  позволяют  просматривать
текст  и  вводить  значения.  Соответствующий  значок  обычно  находится
в  шестой  строке  панели  инструментов.  Бывают  два  вида  полос
прокрутки:  горизонтальная  и  вертикальная.  Они  не  различаются  по
сути,  поэтому  мы  рассмотрим  только  горизонтальную  полосу.
 Создай  новый  проект,  присвой  форме  имя  frmScroll  и  измени
исходный  заголовок  на  Программа  ScrollBar  (или  что-нибудь  в
этом  духе).  Размести  в  форме  горизонтальный  управляющий  элемент
ScrollBar  (присвой  ему  имя  hsbScroll),  а  под  ним  —  управляющий
элемент  Label  (с  именем  lblScroll).  Замечу,  кстати,  что  hsb  —  это
сокращение  от  английского  названия  Horizontal  ScrollBar.
 Результат  выполнения  готовой  программы
 Элементы  ScrollBars

Измени  свойства  элемента  Label.  Для  этого  в  поле  свойства
Alignment  (Выравнивание)  задай  значение  2  -  Center  (Выравнивание
по  центру),  чтобы  текст  расположился  в  центре  элемента.  Удали  текст
заголовка  (Caption).  Наконец,  задай  в  поле  свойства  BorderStyle  (Тип
границ)  значение  1  -  Fixed  single  (Фиксированная  одинарная  граница)
В  результате  все  поле  заметно  выделится  на  фоне  окна  формы.
 Мы  рассмотрели  лишь  несколько  примеров  того,  как  можно
улучшить  внешний  вид  программы,  написанной  на  языке  Visual
Basic.  Рекомендую  тебе  поиграться  с  различными  свойствами
управляющих  элементов,  чтобы  лучше  познакомиться  с  их
назначением.  Тебя  ждет  много  неожиданностей!
 Измени  также  элемент  ScrollBar.  Прежде  всего,  растяни  его  по
ширине.  Значение  свойства  Min  (Минимум)  задай  равным  1,  а  значение
Мах  (Максимум)  —  100.  Тем  самым  ты  определил  диапазон  значений,
которые  можно  просматривать  с  помощью  полосы  прокрутки.
 Окно  объекта  программы  ScrollBar
 Установленное  в  окне  полосы  прокрутки  значение  программа  должна
показывать  в  виде  числа  в  поле  управляющего  элемента  Label.  Для
этого  выполни  следующие  действия:

Дважды  щелкнув  мышью  полосу  прокрутки,  ты  окажешься  в  окне
программного  кода  с  каркасом  программы:
 Private  Sub  hsbScroll_Change()
 End  Sub
 Это  та  часть  программы,  которая  реагирует  на  то  или  иное  изменение
(по-английски  change)  полосы  прокрутки.
 Введи  следующую  строку  программного  кода:
 lblScroll.Caption  =  hsbScroll.Value
 Что  эта  инструкция  означает?  Как  ты  знаешь,  lblScroll  —  это
имя,  присвоенное  управляющему  элементу  Label.  Я  уже  говорил
тебе,  что  в  программе  можно  обратиться  к  управляющему
элементу  с  помощью  имени.  Приведу  пример  такого  обращения.
Тебе  известно,  что  Caption  —  это  текст  заголовка,  видимый  в
поле  элемента  Label.  Имя  данного  элемента  и  его  свойство
Caption  связаны  посредством  точки  (далее  я  это  объясню  тебе
подробнее).
 Свойству  Caption  элемента  Label  необходимо  присвоить  то
значение,  которое  было  задано  в  полосе  прокрутки.  Английское
слово  value  можно  перевести  как  «значение»,  поэтому  мы  пишем
hsbScroll.  Value.  На  сопоставление  этого  значения  элементу
Label  указывает  знак  равенства.
 Итак,  строка  программного  кода
 lblScroll.Caption  =  hsbScroll.Value
 означает:  «Поставить  заданное  в  полосе  прокрутки  значение  в
текстовое  поле  управляющего  элемента  Label».
 Попробуй  запустить  программу,  и  ты  увидишь,  что  эта  команда
выполнится.

Исправим  также  небольшое  упущение  с  точки  зрения  внешнего  вида
программы,  —  при  ее  запуске  поле  элемента  Label  пусто.  Было  бы
лучше,  если  бы  уже  при  запуске  в  нем  находилось  правильное
значение  (в  нашем  случае  1).
 ■  Дважды  щелкни  мышью  форму  в  том  месте,  где  нет  управляющих
элементов.  На  экране  появится  следующий  программный  код:
 Private  Sub  Form_Load()
 End  Sub
 Поскольку  в  нем  указываются  значения,  необходимые  при  запуске
программы,  ты  видишь  слово  Load  (Загрузка),  указывающее  на
загрузку  формы.
 ►  Введи  в  этом  месте  точно  такую  же  строку  программного  кода,  как  и
ранее,  а  именно:
 lblScroll.Caption  =  hsbScroll.Value
На  рисунке  для  сравнения  показан  весь  программный  код:
 Код  программы  ScrollBar
 Итак,  мы  рассмотрели  простой  пример,  иллюстрирующий  использова¬
ние  полосы  прокрутки.  С  помощью  таких  элементов  регулируется
громкость  в  мультимедиа-приложениях  (например,  в  проигрывателе
компакт-дисков)  или  скорость  космического  корабля  в  какой-нибудь
игре.

Несколько  небольших  заданий
 Начальное  значение  управляющего  элемента  Label  можно  задать  с
помощью  программного  кода  и  другим  способом.  Догадываешься,
каким?  Подсказываю:  текст  элемента  Label  также  является  свойством.
 Напиши  программу,  работающую  и  с  вертикальной  полосой
прокрутки.
 Таймер
 Итак,  мы  добрались  до  интереснейшей  вещи,  без  которой
разработчикам  игр  (а  многим  хочется  ими  быть)  никак  не  обойтись.
Это  таймер.
 Таймер  может  с  помощью  функции
 Private  Sub  tmrTimer_Timer()
 End  ЗиЬвызывать  через  определенные  промежутки  времени
некоторые  события,  например,  перемещать  по  экрану
космический  корабль  так,  чтобы  создавалась  иллюзия  его
полета.
 Однако  на  первый  раз  мы  умерим  притязания  и,  используя  простейшие
средства,  напишем  приложение  «Секундомер».
 Создай  новый  проект.  Назови  форму  frmStopWatch  (stopwatch  по-
английски  означает  «секундомер»),  и  в  поле  свойства  Caption  введи
Секундомер.  Щелкни  мышью  расположенный  на  панели  инструмен¬
тов  значок  Timer,  чтобы  в  форме  появился  таймер.
 Запустив  программу,  ты  не  увидишь  в  форме  таймера,  так  как  он  в
процессе  ее  выполнения  остается  невидимым.

В  окне  свойств  необходимо  изменить  два  свойства  таймера.  Задай  для
свойства  Enabled  (Доступ)  значение  False,  а  для  свойства  Interval
(Интервал)  —  1000.  В  качества  имени  таймера  мы  укажем  tmrTimer.
 Если  для  свойства  Enabled  задано  значение  False,  таймер  не
работает,  —  мы  станем  приводить  его  в  действие  кнопкой  с
названием  Старт.  Свойство  Interval  указывает  скорость  работы
таймера.  Если  для  этого  свойства  задано  значение  1,  то  каждую
тысячную  долю  секунды  таймер  генерирует  одно  событие.  Так
как  мы  задали  1000,  событие  будет  происходить  один  раз  в
секунду  (впрочем,  только  приблизительно,  так  как  абсолютно
точно  таймер,  к  сожалению,  не  работает).
 Кроме  того,  нам  понадобятся  две  командные  кнопки,  —  с  этим  типом
кнопок  ты  познакомился  во  вводном  примере.  Присвой  им  имена
cmdStart  и  cmdStop  и  задай  для  свойства  Caption  значения  &Старт
и  Сто&п.
 Символ  (&)  выполняет  следующую  функцию:  буква,  стоящая
непосредственно  после  него  («С»  в  слове  Старт  и  «п»  в  Стоп),
подчеркивается.  Если  во  время  работы  программы  пользователь
нажмет  одновременно  клавишу  Alt  и  соответствующую  букву  на
клавиатуре,  то  результат  будет  таким  же,  как  если  бы  он  нажал
командную  кнопку.  Попробуй  выполнить  эти  операции.
 И,  наконец,  необходимо  добавить  управляющий  элемент  Label,
с  помощью  которого  отсчитываемое  время  будет  выводиться  на
экран.
 Помести  элемент  Label  в  верхней  части  формы,  назови  его
lblTime  и  задай  для  свойства  Caption  значение  0  —  оно  станет
стартовым  значением  секундомера.  Размести  текст  в  поле  Label  так,
чтобы  выводимое  значение  времени  располагалось  в  центре  поля
данного  управляющего  элемента.  Ты  помнишь,  как  это  делается?
Используй  свойство  Alignment.

Форма  приобретет  следующий  вид:
 Форма  для  программы  «Секундомер»
 Напишем  несколько  строк  программного  кода.  Чего  мы  добиваемся?
Прежде  всего,  секундомер  (точнее  говоря,  таймер)  должен  начинать
работать  при  нажатии  кнопки  Старт.  Как  ты  уже  знаешь,  работа
таймера  регулируется  свойством  Enabled  управляющего  элемента
Timer.  Если  для  указанного  свойства  задано  значение  True,  часы  идут,
а  если  False,  то  они  стоят.
 Дважды  щелкни  мышью  кнопку  Старт.  На  экране  появится  хорошо
знакомый  каркас  программы:
 Private  Sub  cmdStart_Click()
 End  Sub
 В  нем  задай  для  свойства  Enabled  таймера  значение  True:
 tmrTimer.Enabled  =  True
 Мне  кажется,  этот  программный  код  вполне  понятен,  а  о  точке  между
tmrTimer  и  Enabled  я  подробно  расскажу  в  следующих  главах.
 Если  ты  надеешься,  что  после  запуска  программы  секундомер
начнет  работать,  то  ошибаешься:  он  останется  стоять  на  нуле.  Те
действия,  которые  должны  происходить  при  его  включении,  нам
еще  предстоит  запрограммировать.

Прежде  всего,  напишем  программный  код  для  кнопки  Стоп  (для  этого
нужно  дважды  щелкнуть  ее  мышью).  Он  выглядит  следующим
образом:
 Private  Sub  cmdStop_Click()
 TmrTimer.Enabled  =  False
End  Sub
 Нам  остается  только  организовать  вывод  значения  времени  в  поле
элемента  Label.  Иными  словами,  нам  нужно,  чтобы  всякий  раз  когда
таймер  активен  (в  нашем  случае  —  раз  в  секунду),  значение  поля
элемента  Label  увеличивалось  на  единицу.  Это  делается  следующим
образом:
 Private  Sub  tmrTimer_Timer()
 LblTime.Caption  =  lblTime.Caption  +  1
End  Sub
 Поясню  подробнее:  дважды  щелкни  мышью  управляющий
элемент  Timer.  На  экране  появляется  программа,  которая  в
соответствии  с  нашими  указаниями  выполняется  таймером  раз
в  секунду.  Таким  образом,  мы  вводим  программный  код,
увеличивающий  с  указанной  частотой  значение  свойства
Caption  элемента  Label  (то  есть  показание  времени)  на
единицу.
 Если  тебе  непонятен  этот  достаточно  своеобразный  метод
сложения  (в  левой  части  равенства  стоит  не  то  же,  что  в  правой,  —
разве  такое  может  быть?),  то  мы  подробнее  обсудим  возникший
вопрос,  когда  познакомимся  с  основными  правилами  языка  Visual
Basic.

На  рисунке  показано  окно  с  полным  программным  кодом:
 Полный  программный  код
 Несколько  небольших  заданий
 Наш  секундомер  можно  усовершенствовать.  Рассмотрим  два
предложения.
 В  нынешнем  варианте  программы  отсутствует  возможность  установить
секундомер  на  ноль.  Если  ты  нажмешь  кнопку  Стоп,  а  затем  снова
Старт,  то  секундомер  продолжит  отсчитывать  время  с  того  значения,  на
котором  остановился.  Введи  еще  одну  командную  кнопку  сброса  —
&Сброс.  Программный  код  для  нее  должен  быть  таким:
 lblTime.Caption  =  О
 Кроме  того,  секундомер  показывает  только  целые  секунды.  Это
слишком  неточно.  Измени  значение  свойства  Interval  управляющего
элемента  Timer  с  1000  на  100,  и  тогда  таймер  станет  генерировать
событие  каждую  десятую  долю  секунды.  Измени  соответственно  и
программный  код:
 lblTime.Caption  =  lblTime.Caption  +  0.1

Поскольку  система  Visual  Basic  является  американской  програм¬
мой,  она  работает  не  с  десятичной  запятой,  а  с  десятичной  точ¬
кой.  Учитывай  это  при  работе  с  десятичными  числами,  иначе  про¬
изойдет  ошибка.
 Элементы  PictureBox  и  Image
 Два  последних  управляющих  элемента,  которые  мы  обсудим  в  этой
главе,  служат  для  того,  чтобы  выводить  на  экран  изображения
(графики,  значки  и  т.д.).  В  связи  с  этим  они  являются  основой  всех
рисованных  компьютерных  игр.
 Если  ты  уже  имеешь  некоторый  опыт  программирования,  то
обязательно  познакомься  с  графикой  в  среде  Visual  Basic  —  это
в  высшей  степени  интересная  тема.
 Посмотрим,  что  можно  делать  с  помощью  этих  управляющих
элементов,  и  чем  они  отличаются  друг  от  друга.
 Создай  новый  проект,  назови  форму  frmGraphic  и  задай  для
свойства  Caption  значение  Программа  графики  (или  что-нибудь
в  этом  духе).

Расположи  в  форме  управляющий  элемент  PictureBox  (Окно  рисунков)
и  управляющий  элемент  Image  (Изображение).  Значок  PictureBox
находится  в  верхней  правой  части  панели,  а  значок  Image  —  в  нижней
левой  ее  части.
 Присвой  управляющему  элементу  PictureBox  имя  pi  с  Picture.
Сначала  щелкни  мышью  свойство  Picture  (Картинка),  затем  нажми
появившуюся  кнопку  с  многоточием.  В  открывшемся  диалоговом  окне
выбери  нужный  графический  файл.
 Если  ты  выполнил  полную  установку  программы  Visual  Basic,  то  у
тебя  имеется  возможность  выбирать  графический  файл  по
своему  усмотрению.  Я  указал  во  вложенной  папке
COMMON/GRAPHICS/BITMAPS/ASSORTED  папки  Microsoft
Visual  Studio,  созданной  при  установке  Visual  Basic,  файл
HEART.BMP  (разумеется,  ты  можешь  указать  другой  файл).  На
экране  появляется  изображение  —  сердечко.  Оно  расположено  в
левом  верхнем  углу  управляющего  элемента.  Если  задать  для
свойства  Autosize  значение  True,  то  величина  управляющего
элемента  станет  соответствовать  размеру  изображения.
 Менять  размер  сердечка  можно  было  бы  как  угодно,  если  бы
имелась  возможность  сначала  задавать  размер  управляющего
элемента,  а  затем  соответственно  изменять  величину
изображения.  Элемент  PictureBox  такой  возможности  не
предоставляет.  Для  таких  целей  используется  управляющий
элемент  Image.
 Выдели  управляющий  элемент  Image  (щелкни  его  мышью).  Присвой
ему  имя  imglmage,  а  в  свойстве  Picture  выбери  изображение
сердечка.

Изменять  размер  элемента  можно  как  угодно,  но  величина
изображения  будет  соответственно  меняться  только  в  том  случае,
если  для  свойства  Stretch  (Подгонка)  задано  значение  True.
 При  изменении  размеров  управляющего  элемента  следи  за  тем,  чтобы
не  нарушились  пропорции,  так  как  иначе  сердечко  примет  весьма
странный  вид.
 Элементы  формы  должны  выглядеть  примерно  так:
 Слева  —  элемент  PictureBox,  справа  —  Image
 Несколько  небольших  заданий
 В  конце  этой  главы  можно  немного  расслабиться.  Выбери  несколько
изображений  из  материалов,  прилагаемых  к  системе  Visual  Basic,  и
загрузи  их  в  управляющий  элемент  PictureBox  или  Image.
Поэкспериментируй  со  свойствами  Autosize  и  Stretch.
 Выводы
 Итак,  мы  рассмотрели  основные  управляющие  элементы.  С
некоторыми  другими  ты  познакомишься  далее.  Если  принять  во
внимание,  что  мы  до  сих  пор  программировали,  не  занимаясь
написанием  кода,  а  просто  используя  управляющие  элементы,  то  ты
поймешь,  какие  возможности  предоставляет  Visual  Basic.

4. 	Первые  шаги
 В  данной  главе  будут  сделаны  первые  попытки  овладеть  языком
программирования  Visual  Basic  с  использованием  тех  управляющих
элементов,  с  которыми  ты  познакомился  в  предыдущем  разделе.
 В  этой  главе  ты  узнаешь:
 • 	как  планировать  создание  программы;
 • 	что  такое  режимы  выполнения  программы;
 • 	как  научить  компьютер  считать;
 • 	что  означает  понятие  «постфиксный  оператор»,
и  почему  оно  так  важно;
 • 	что  такое  переменные,  и  как  компьютер  их  запоминает;
 • 	что  понимают  под  объявлением;
 • 	как  открывать  окно  отладки  для  тестирования  программы
и  отыскивать  ошибки.

Режикмл  выполнения  программы
 Режимы  выполнения  программы  определяют,  что  она  должна
делать  в  тех  или  иных  условиях.  Если  режимы  не  заданы,
программа  всегда  делает  одно  и  то  же,  а  этого  может  быть
недостаточно.  Допустим,  в  компьютерной  игре  ты  управляешь
космическим  кораблем.  Он  должен  иметь  возможность  стрелять
из  бортового  орудия  и  делать  это  только  тогда,  когда  ты
совершаешь  определенное  действие,  —  например,  нажимаешь
кнопку  джойстика.  Нажатие  является  условием,  при  котором
программа  имитирует  выстрел.
 Какими  возможностями  должна  обладать,  например,  программа
«Калькулятор»?  Она  должна  уметь  работать  с  двумя  введенными
числами,  производить  над  ними  указанные  арифметические  действия
и  выдавать  правильный  результат.
 Очень  велико  искушение  сразу  приняться  за  программирование.
Не  торопись!  Каждому  программному  проекту  должно
предшествовать  тщательное  планирование  с  помощью  простого
карандаша  и  бумаги  или,  скажем,  редактора  Word  2000,  но  в
любом  случае  без  использования  языка  программирования.  Не
слишком  увлекательное  занятие,  я  знаю,  но  без  этого  не
обойтись.  Составляя  план,  ты  должен  в  первую  очередь
определить,  какими  возможностями  будет  обладать  программа.
Дело  в  том,  что  порой  бывает  очень  сложно  ввести  забытую  при
планировании  функцию  в  более  или  менее  готовое  приложение.

Программа  «Калькулятор»  должна  выполнять  элементарные
арифметические  действия  (сложение,  вычитание,  умножение  и
деление).  Я  думаю,  этого  достаточно  для  начала.  Поскольку
пользователь  каждый  раз  выбирает  только  одно  из  этих
действий,  кажется  вполне  уместным  предложить  ему
соответствующие  варианты  в  виде  набора  управляющих
элементов  OptionButton  (из  нескольких  таких  элементов
выбирается  только  один).
 Кроме  того,  пользователю  понадобятся  два  поля  ввода  (по
одному  для  каждого  числа),  командная  кнопка,  после  нажатия
которой  будет  произведено  вычисление,  а  также  поле  для
вывода  результата.
 Мы  должны  программными  средствами  задать  выполнение
арифметического  действия  (указанного  при  выборе  элемента
OptionButton)  после  нажатия  командной  кнопки  ОК.  Кроме
того,  следует  также  принять  некоторые  меры  предосторожности,
например,  запретить  деление  на  ноль  и  т.п.  Как  конкретно  это
сделать,  ты  увидишь  в  дальнейшем.  Вначале  займемся  внешним
видом  программы,  то  есть  разместим  в  форме  необходимые
управляющие  элементы.
 Создай  новый  проект,  растяни  немного  основную  форму  в  ширину  и  в
высоту  (нам  понадобится  сравнительно  большая  площадь)  и  присвой
окну  имя  frmCalc.  Для  свойства  Caption  задай  значение
 Калькулятор.
 Далее  потребуются  два  окна  TextBox,  в  которые  пользователь  станет
вводить  числа.  Расположи  окна  в  форме,  назови  одно  txtNuml,
другое  —  txtNum2  (по-английски  number  означает  «число»)  и  введи
для  обоих  в  поле  свойства  Text  значение  0.

Последующие  описания  формата  (так  называют  задание  свойств
форм  и  управляющих  элементов)  одинаковы  для  обоих
элементов  TextBox.  Ты  помнишь  прием,  с  помощью  которого
одновременно  задаются  одинаковые  свойства  нескольких
элементов?  Об  этом  сказано  в  главе  3  (раздел  «Элементы
CheckBox  и  OptionButton»).  Выдели  первый  объект  (txtNuml),
щелкнув  его  мышью.  Нажми  клавишу  Shift  и,  удерживая  ее  в
таком  положении,  выдели  остальные  элементы,  щелкая  их
мышью.
 Все  выделенные  объекты  окружены  держателями,
позволяющими  работать  одновременно  со  всеми  элементами.
Выделение  останется  до  тех  пор,  пока  ты  не  щелкнешь  мышью
свободное  от  обьектов  место  формы.
 Итак,  слегка  улучшим  внешний  вид  элементов  TextBox.  Прежде  всего,
задай  значение  свойства  Height  (Высота)  равным  400,  a  Width
(Ширина)  —  1500.  Ты  заметил,  что  оба  управляющих  элемента
изменились  одновременно?  Такая  функция  выделения  действительно
очень  удобна.
 Изменим  размер  шрифта.  Ты,  конечно,  помнишь,  что  это  делается  с
помощью  свойства  Font.  Выбери  шрифт  MS  Sans  Serif,  Bold
(Полужирный)  размером  14  пунктов.  Теперь  в  поле  каждого  элемента
TextBox  поместятся  шесть  цифр.  Этого  достаточно  для
шестизначного  целого  числа  или  соответственно  меньшего  числа  с
плавающей  десятичной  точкой.
 То,  что  текст  в  каждом  элементе  TextBox  выровнен  по  левому  краю,
выглядит  не  очень  хорошо.  Воспользуемся  свойством  Alignment,
чтобы  выровнять  его  по  правому  краю.

Значение  для  этого  свойства  можно  задавать  только  в  случае,  ес¬
ли  для  свойства  MultiLine  (Несколько  строк)  элемента  TextBox
определено  значение  True.  Свойство  MultiLine  определяет,
можно  ли  вводить  в  поле  элемента  TextBox  текст,  состоящий  из
нескольких  строк.
 И,  наконец,  расположим  управляющие  элементы  TextBox  в  форме  та¬
ким  образом,  чтобы  они  находились  на  одинаковом  расстоянии  от  ее
краев.  Ты  помнишь,  как  это  делается?  Правильно,  с  помощью  последо¬
вательно  выполненных  команд  Center  in  Form  и  Horizontally  меню
Format.
 Теперь  наша  форма  выглядит  достаточно  красиво.  Сравни  на  всякий
случай  свой  результат  с  этим  рисунком:
 Форма  на  промежуточном  этапе  работы
 Между  элементами  TextBox  необходимо  расположить  четыре
элемента  OptionButton  для  выбора  арифметической  операции.  Если
будет  недостаточно  места,  отодвинь  элементы  TextBox  друг  от  друга.
Значение  Height  для  новых  элементов  выберем  равным  200.  В
качестве  значений  Name  и  Caption  укажи  следующие  (сверху  вниз):

OptAdd
 OptSub
 OptMult
 OptDiv
 Сложение
 Вычитание
 Умножение
 Деление
 Название  и  заголовок  элементов  OptionButton
 В  дальнейшем  изложении  свойства  управляющего  элемента
будут  представляться  в  виде  таблицы.
 Выдели  все  элементы  OptionButton  и  выровняй  их  в  окне  формы  по
горизонтали.
 Нам  требуется  кнопка  для  запуска  процесса  вычисления.  Кроме
того,  необходимо  поле  для  вывода  результата.
 В  качестве  такой  кнопки  подойдет  командная  кнопка
(CommandButton).  А  для  вывода  результата  воспользуйся
управляющим  элементом  Label.  Почему  не  TextBox?  Потому  что
Label  служит  только  для  выдачи  результата.
 В  поле  еще  одного  элемента  Label  напиши  Результат,  чтобы
было  ясно  его  назначение.
 Значения  свойств  упомянутых  элементов  указаны  в  следующей
таблице:
 Name
 Caption

Name  Caption  Font
 Control
 CommandButton 	cmdStart 	&Старт 	MS  Sans  Serif,  обычный, 	8
 Label 	IblResult 	Результат: 	MS  Sans  Serif,  п/ж,  14
 Label 	IblOutput 	0 	MS  Sans  Serif,  п/ж,  14
 Окно  формы  принимает  следующий  вид:
 Внешнее  оформление  программы  закончено.  Если  хочешь,  добавь
еще  одну  командную  кнопку  для  выхода  из  приложения  и  напиши  со¬
ответствующий  код.
 А  сейчас  мы  наконец-то  начнем  программировать!  Нам  требуется
написать  код,  чтобы  приложение  начинало  выполняться  при
нажатии  кнопки  Старт.
 Дважды  щелкни  эту  кнопку  мышью.  Ты  попадешь  в  окно  программно¬
го  кода,  в  котором  увидишь  следующий  текст:
 Каркас  программы

Хотя  мы  уже  не  раз  видели  этот  текст,  сейчас  мы  обсудим  подробнее
фрагмент  cmdStart_Click  ()  (о  том,  что  означает  Private  Sub,
мы  поговорим  позже).
 Ты  видишь,  что  это  двойное  слово  начинается  с  имени  кнопки  (мы
назвали  управляющий  элемент  cmdStart).  Затем  следует  под¬
черкивание  и  слово  Click.  В  данном  случае  Click  означает  со¬
бытие  (щелчок  мышью,  сделанный  пользователем),  на  которое
реагирует  эта  часть  программы.  Иными  словами,
cmdStart_Click  означает:  внимание,  в  данном  месте  начинает¬
ся  часть  программного  кода,  которая  выполняется  в  случае  нажа¬
тия  кнопки  Старт.  Скобки  после  слова  Click  необходимы.  Они
имеют  специальное  значение,  о  котором  будет  сказано  позже.
Для  того  чтобы  было  видно,  что  эта  часть  программного  кода
кончилась,  в  конце  стоит  текст  End  Sub.  После  него  начинается
другая  часть  кода.
 Кстати,  Click  —  далеко  не  единственное  событие,  на  которое
программа  может  реагировать.  Посмотри  на  верхнюю  часть  окна,
расположенную  непосредственно  под  строкой  заголовка,  в  кото¬
рой  написано  Project  1  -  frmCalc(Code).  В  нёй  видны  два  раскры¬
вающихся  списка.  Слева  стоит  имя  управляющего  элемента,  а
справа  —  возможные  события.  Так  выглядит  окно,  если  раскрыть
список  возможных  событий  для  кнопки  cmdStart:
 Вот  сколько  событий  может  произойти

Пусть  тебя  не  смущает  большое  количество  возможных  событий.  С
важнейшими  из  них  ты  постепенно  познакомишься.  В  нашем  случае
система  Visual  Basic  сама  выбрала  событие  Click.  Это  вполне
естественно,  ведь  нажатие  —  типичное  событие  для  командной
кнопки.
 Итак,  в  каркас  нужно  ввести  программный  код,  который  укажет
программе,  что  она  должна  делать  при  нажатии  кнопки  Старт.
 Начнем  со  сложения.  Оно  должно  выполняться  в  том  случае,  если
выделен  элемент  OptionButton  с  именем  optAdd.  Выяснить,
выделен  ли  он,  можно  с  помощью  свойства  Value  этого  элемента.
Оно  может  принимать  значения  True  или  False.  True  означает
«выделено»,  False  —  «не  выделено».
 Таким  образом,  у  нас  есть  условие,  выполнение  которого
необходимо  проверить.  Как  ты  знаешь  из  главы  3,  для  этого
используется  конструкция  if.  В  данном  случае  она  выглядит  так:
 If  optAdd.Value  =  True  Then
 End  If
 Иными  словами:
 «Если  значение  свойства  Value  элемента  optAdd  равно  True,  то...»
Введи  этот  код.
 Если  ты  внимательно  следил  за  изложением,  то  наверняка  заме¬
тил,  что  имя  управляющего  элемента  (optAdd)  и  его  свойство
(Value)  соединены  друг  с  другом  точкой.  На  языке  программис¬
тов  она  называется  постфиксным  оператором  (postfix  opera¬
tor).  Это  еще  одно  понятие,  которое  следует  запомнить.  Однако
важнее  принцип,  который  за  ним  стоит.
 Если  ты  хочешь  в  программном  коде  обратиться  к  свойству  управ¬
ляющего  элемента,  то  всегда  поступай  следующим  образом:  сна¬

чала  пиши  имя  управляющего  элемента,  затем  ставь  точку,  а  по¬
том  указывай  его  свойство.
 Этот  принцип  настолько  важен,  что  я  поясню  его  еще  на  одном
примере.
 При  выборе  внешнего  вида  формы  мы  задали  высоту  (свойство
Height)  элементов  TextBox  равной  400.  Допустим,  ты  по  каким-
то  причинам  хочешь  изменить  ее  во  время  выполнения
программы.  Тогда  соответствующий  программный  код
становится  таким:
 txtNuml.Height  =  600
 Все  понятно?  Вначале  ставится  имя  управляющего  элемента,  затем
точка,  после  которой  следует  свойство,  а  после  знака  равенства
указывается  значение.
 Теперь  нам  следует  указать  программе,  что  она  должна  делать,  если
условие  выполнено.  Мы  хотим,  чтобы  числа  из  обоих  элементов
TextBox  (txtNuml  и  txtNum2)  были  сложены  друг  с  другом,  и  в  поле
вывода  появился  результат.
 Содержимое  элемента  TextBox  определяется  его  свойством
Text.  В  поле  этого  свойства  ты  для  обоих  элементов  указал
нулевое  значение.  А  то,  что  стоит  в  поле  элемента  Label,
определяется  его  свойством  Caption.
 Попробуем  сложить  txtNuml.  Text  (снова  постфиксный  оператор  —
теперь  мы  будем  использовать  его  постоянно)  и  txtNum2  .  Text:
 txtNuml.Text  +  txtNum2.Text

Нам  требуется  записать  результат  сложения  в  заголовок  элемента
Label.  В  этой  ситуации  говорят  о  присваивании:  мы  присваиваем
значение  (а  именно  результат  сложения)  свойству  Caption
управляющего  элемента  Label  (которое  в  настоящий  момент  имеет
нулевое  значение).  В  языке  Visual  Basic  такая  операция  выполняется  с
помощью  знака  равенства.
 Знак  равенства  в  Visual  Basic  означает  не  только  то,  что  две
величины  равны,  но,  в  зависимости  от  контекста,  и  то,  что
стоящее  в  правой  части  равенства  значение  присваивается
величине,  стоящей  в  его  левой  части.
 Эта  операция  настолько  важна,  что  мы  скоро  к  ней  вернемся,  а  сейчас
напишем:
 LblOutput.Caption  =  txtNuml.Text  +  txtNum2.Text
Включи  эту  строку  в  конструкцию  if.
 Таким  образом,  весь  программный  код  выглядит  сейчас  следующим
образом  (на  слова  Opt  ion  Explicit  ты  пока  не  обращай  внимания):
 Попытка  произвести  сложение
 Пришло  время  протестировать  программу.
 Введи  в  поля  элементов  TextBox  любые  два  числа  (я  ввел  5  и  3),
щелкни  мышью  переключатель  Сложение  (по-английски  addition)  и
нажми  кнопку  Старт.

Ты  увидишь  следующее:
 Увы,  приложение  не  работает...
 Ничего  не  получилось.  В  поле  вывода  мы  видим  не  результат
сложения,  а  два  введенных  числа,  написанных  рядом  друг  с  другом.
 Почему  так  произошло?  Для  того  чтобы  понять  это,  мы  займемся
изучением  переменных.  Но  сначала  не  забудь  сохранить  проект.
 Понятие  переменной
 Создай  новый  проект.  Дважды  щелкни  форму  мышью,  чтобы  открыть
окно  программного  кода
 Private  Sub  Form_Load()
 End  Sub
 Этот  код  тебе  знаком  из  того  раздела  главы  3,  в  котором  мы  говорили
об  элементах  ScrollBar.
 Введи  в  данный  каркас  следующие  строки:
 Option  Explicit
Dim  X  As  Integer
Dim  Y  As  Integer
X  =  7
 Y 	=  5
 Debug.Print  X  +  Y

Сколько  нового!  Разберем  тщательно  этот  программный  код.  Он
отнюдь  не  настолько  сложен,  как  кажется.
 Начнем  с  последней  строки.  Слово  Debug  по-английски  значит
«устранение  ошибок»,  a  Print  указывает  на  то,  что  на  экран
(или  принтер)  необходимо  вывести  некоторые  данные.  Таким
образом,  можно  быстро  проверить  полученные  результаты,  не
вводя  в  форму  дополнительных  управляющих  элементов.  Это
весьма  эффективный  метод  поиска  ошибок  в  программе.
 Если,  например,  написать  в  тексте  программы  Debug.Print
"Петр"  (с  кавычками!),  то  откроется  окно  отладки  со  словом
 Петр.
 А  каков  будет  результат,  если  в  программе  написать  Debug.  Print  X  +  Y?
Попробуй,  и  ты  увидишь,  что  получится  12.
 Система  Visual  Basic,  очевидно,  сложила  7  и  5,  то  есть  заменила
буквы  X  и  Y  численными  значениями,  которые  были  присвоены  в
предыдущих  строках  (с  помощью  знака  равенства).
 Итак,  при  выполнении  программы  пользователь  вводит
некоторые  данные,  например  свое  имя  или  два  числа.  Система
Visual  Basic  должна  их  запомнить,  точнее,  сохранить  в
оперативной  памяти  компьютера.  Для  этого  используются  так
называемые  переменные  (в  нашем  случае  X  и  Y),  в  которые
записываются  введенные  данные.
 Ввод  информации  может  происходить  разными  путями:
непосредственно  в  программном  коде,  как  в  нашем  примере,  или
в  результате  действий  пользователя,  когда  он  вводит  данные  в
поле  элемента  TextBox.
 Итак,  повторим  еще  раз:
 В  программной  строке  X  = 	7 	переменной 	X  присваивается
 значение  7  (по-английски  переменная  называется  variable).  И

действительно,  наши  переменные  могут  изменяться  в  процессе
выполнения  программы.
 Что  это  значит?
 Введи  после  Debug  .Print  следующие  строки:
 X  =  100
Debug.Print  X
 Запусти  программу.  Ты  увидишь,  что  в  окне  отладки  появится  100.
 Для  большей  наглядности  я  привожу  на  рисунках  программный  код
и  результат,  выводимый  в  окне  отладки:
 Окно  программного  кода
 Результат  в  окне  отладки
 Как  правило,  переменные  вводятся  в  программный  код:
 X  =  7

Переменной  присваивается  некоторое  значение,  а  для  ее  обозначения
используется  какое-нибудь  имя  (в  нашем  примере  X).  Вычисления
выполняются,  например,  таким  образом:
 X  =  7
 Y 	=  12
Z  =  X  +  Y
Debug.Print  Z
 По  некоторым  причинам  мы  в  дальнейшем  не  будем  использовать
такие  имена  переменных.  Обрати  внимание  на  весьма  важное
обстоятельство.  Дело  в  том,  что  для  таких  коротких  программ,
как  в  данном  случае,  у  тебя  даже  по  прошествии  длительного
времени  не  возникнет  трудностей  с  пониманием  того,  что
означают  X,  Y  и  Z  ,  —  об  этом  легко  догадаться.
 Но  твои  приложения  будут  становиться  все  длиннее  и  сложнее,  и
в  один  прекрасный  момент  ты  перестанешь  понимать,  что
означает  та  или  иная  переменная.  Чтобы  избежать  этой
проблемы,  необходимо  давать  переменным  осмысленные  имена.
Например,  вместо  X  можно  было  бы  использовать
AdditionNuml,  вместо  Y  —  AdditionNum2,  а  вместо  Z  —
AdditionResult.  Таким  образом,  программный  код  станет
более  понятным,  несмотря  на  больший  объем  работы.  Если  тебе
через  несколько  месяцев  захочется  переделать  или  расширить
программу,  ты  будешь  благодарен  сам  себе  за
предусмотрительность.
 Однако  возникает  другая  проблема,  связанная  с  использованием
длинных  имен,  —  опасность  сделать  чреватую  ошибками  опечатку.
 Допустим,  в  программе  имеется  переменная,  которой  ты  присваиваешь
значение  10  следующим  образом:
 MyVariable  =  10

Чтобы  увеличить  значение  переменной  на  единицу,  ты  далее  в  тексте
программы  пишешь  строку
 MyVariabel  =  MyVariable  +  1
 Видишь  ошибку?  Она  приведет  к  тому,  что  появится  новая  переменная
MyVariabel  со  значением  11.  Значение  переменной  MyVariable,
напротив,  останется  равным  10.  Искать  подобные  ошибки  можно  до
бесконечности.
 Я  настоятельно  советую  тебе  настроить  свою  среду  программи¬
рования  таким  образом,  чтобы  переменные  обязательно  объяв¬
лялись  явно.  Тогда  в  случае  опечатки  компьютер  выдаст  сообще¬
ние  об  ошибке,  выглядящее  следующим  образом:
 «Я  не  знаю  переменную  Test!»
 А  как  настроить  Visual  Basic  таким  образом?  В  меню  Tools
(Сервис)  последовательно  укажи  команды  Options  (Параметры)
Editor  (Редактор)  и  установи  флажок  Require  Variable
Declaration  (Явное  описание  переменных).

Соответствующее  окно  выглядит  следующим  образом:
 Флажок  во  второй  строке  сверху
 С  этого  момента  в  твоих  будущих  приложениях  в  начале  программного
кода  будет  добавляться  та  самая  загадочная  строка  Option
Explicit,  которая  упоминалась  в  самом  начале  книги.  В  данном
случае  слово  Explicit  означает  «явно»,  то  есть  переменные  явно
объявляются  в  тексте  программы.
 Объявление  (или  описание)  происходит  с  помощью  оператора
Dim  (от  слова  dimension  —  размер).
 Так  постепенно  становится  более  ясным  программный  код,
написанный  в  начале  этого  раздела.  Напомню  его:
 Option  Explicit
Dim  X  As  Integer
Dim  Y  As  Integer
X  =  7
 Y 	=  5
 Debug.Print  X  +  Y

Открытым  остается  только  один  вопрос.  Что  означает  надпись  As
Integer  в  объявлении  переменной?
 Словами  As  Integer  ты  даешь  системе  Visual  Basic  понять,  что
данная  переменная  (в  нашем  примере  X  или  Y)  должна  иметь  тип
данных  Integer.  Что  такое  «тип  данных»?
 Переменные  занимают  в  оперативной  памяти  компьютера
некоторое  место,  которое  необходимо  программе  для  того,
чтобы  запомнить  их  значения.  Но  сколько  именно  места
необходимо  зарезервировать?  Понятно,  что  для  длинного  текста
в  памяти  требуется  больше  места,  чем  для  одного-единственного
числа.  Поэтому  существуют  различные  типы  данных,  важнейшие
из  которых  мы  далее  рассмотрим.  Заучивать  их  тебе  не  нужно:  по
мере  написания  программ  ты  их  постепенно  запомнишь.
 Byte 	Целые  числа  от  0  до  255
 Integer 	Целые  числа  от  —32768  до  32767
 Long 	Целые  числа  от  —2147483648  до  2147483647
 Single 	Числа  с  плавающей  запятой  (например,  4.67).
 (Не  забывай  вместо  запятой  ставить  точку!)
 String 	Текстовые  данные,  так  называемые  строки
 (например,  Visual  Basic)
 Это  лишь  небольшая  и  важнейшая  часть  типов  данных,  которые
предлагает  язык  Visual  Basic.
 Видно,  что  только  для  целых  чисел  имеются  три  различных  типа
данных.  В  подобных  случаях  действует  твердое  правило:  всегда
выбирать  наименьший  тип,  в  отношении  которого  можно  быть
уверенным,  что  при  выполнении  программы  он  никогда  (даже
 Тип  данных  Диапазон  значений

если  пользователь  введет  совершенно  абсурдные  данные)  не
окажется  недостаточным.  Если,  например,  ты  работаешь  в
диапазоне  чисел  от  1  до  12  (например,  в  программе,
оперирующей  месяцами),  можно  спокойно  использовать  для
переменной  тип  Byte.  Если  в  программе  встречаются  числа  с
плавающей  точкой,  то  разумно  использовать  тип  Single.
 И  еще  одно  замечание:  при  объявлении  переменной  можно
опускать  указание  типа  данных  и  просто  писать
 Dim  X
X  =  7
 В  этом  случае  система  Visual  Basic  выбирает  тип  данных
Variant,  годный  для  большинства  возможных  значений
переменных.  Но  именно  поэтому  приложения,  написанные  с
использованием  такого  типа  данных,  работают  значительно
медленнее,  чем  те,  в  которых  программисты  выбрали  наиболее
подходящие  типы.  Так  будем  поступать  и  мы.
 Вычисления  в  системе  Visual  Basic
 Вернемся  к  программе  «Калькулятор».  Открой  этот  проект  снова.
 Ты  помнишь,  на  чем  мы  остановились?  Нам  нужно  было  найти  ошибку,
которая  препятствовала  сложению  введенных  в  поля  элементов
 txtNuml  и  txtNum2  чисел.
 Теперь,  когда  мы  столько  знаем  про  переменные,  мы  быстро
найдем  эту  ошибку.  Запись  TxtNuml.Text  содержит  не  число,  а
текст,  то  есть  (см.  приведенную  выше  таблицу)  переменную  типа
String.

Переменная  этого  типа  не  обязательно  состоит  из  букв,  как
можно  сначала  подумать.  Конечно,  присвоения  типа
 Dim  MyString  As  String
MyString  =  "Меня  зовут  Сергей"
 встречаются  очень  часто,  и  практическая  важность  их  весьма
велика  (не  забывай  ставить  кавычки).
 Однако  в  качестве  текста  вводятся  и  цифры.  И  это  хорошо  —  кто
же  складывает  телефонные  номера?
 С  помощью  переменных  типа  String  нельзя  считать!  Если
соединить  несколько  переменных  этого  типа  знаками  «плюс»  или
(&),  то  строки  запишутся  друг  за  другом.
 Теперь  ты  понимаешь,  почему  наша  программа  при  сложении  5  и
 3 	получала  неверный  ответ  53,  —  она  записывала  друг  за  другом
две  переменные  типа  String.
 Что  делать?  Столько  проблем  с  простым  сложением...  Ясно  одно:  мы
должны  каким-то  образом  преобразовать  значения,  содержащиеся  в
полях  обоих  элементов  TextBox,  в  числа.  Если  это  сделать,  то
программа  заработает  правильно.
 Преобразование  переменной  типа  String  в  число  в  Visual  Basic
производится  с  помощью  одной  простой  команды.  Она
называется  Val,  причем  переменная,  которую  нужно
преобразовать,  записывается  за  словом  Val  в  скобках.
Собственно  говоря,  Val  является  функцией  (с  этим  понятием  мы
познакомимся  несколько  позже).
 Приведу  пример:
 Private  Sub  Form_Load()
 Dim  Number  As  Integer

Dim  MyString  As  String
MyString  =  "123"
 Number  =  Val(MyString)
 Debug.Print  Number
End  Sub
 Итак,  ты  открываешь  новый  проект  и  дважды  щелкаешь  мышью  любое
место  формы.  На  экране  появляется  каркас  программы.  Ты
объявляешь  в  нем  с  помощью  слова  Dim  переменные  типов  Integer
и  String.  После  этого  ты  присваиваешь  переменной  типа  String
некоторое  значение.  Поскольку  тип  переменной  String,  это
значение  заключается  в  кавычки.  С  помощью  Val  эта  переменная
преобразуется  в  число,  которое  ты  присваиваешь  переменной  типа
Integer.  Затем  с  помощью  команды  Debug.  Print  оно  выводится  в
окне  отладки.
 Поэкспериментируй  еще  немного  с  типом  данных  String,  числами  и
преобразованием.  Возьми  в  качестве  значения  для  переменной  типа
String  букву  и  посмотри,  что  произойдет.  Попробуй  использовать  в
эксперименте  смесь  букв  и  цифр  (например,  555ВВ).
 Теперь  ты  понимаешь,  как  должно  выглядеть  сложение?  Правильный
вариант  таков:
 LblResult.Caption  =  Val(txtNuml.Text)  +
 Val(txtNum2.Text)
 Таким  образом,  значение,  которое  пользователь  ввел  в  поле  первого
элемента  TextBox,  преобразуется  в  число.  То  же  самое  делается  со
значением,  введенным  в  поле  второго  элемента  TextBox.  В  результате
появляются  два  числа,  которые  следует  сложить.  Результат
записывается  в  элемент  Label,  предназначенный  для  вывода.
 Внеси  соответствующие  изменения  в  программу  «Калькулятор».  Она
должна  выглядеть  следующим  образом:
 Правильное
 сложение

Протестируем  приложение.  Запусти  его,  выбери  элемент  Сложение  и  на¬
жми  кнопку  Старт.  Ты  увидишь,  что  приложение  заработало  правильно.
 Теперь  обратимся  к  вычитанию.  Соответствующий  элемент
OptionButton  назовем  opt  Sub.  Вслед  за  первой  конструкцией  if
добавим  следующие  строки:
 If  optSub.Value  =  True  Then
 LblResult.Caption  =  Val(txtNuml.Text)  —
 Val(txtNum2.Text)
 End  If
 (Текст  в  каркасе  приложения  необходимо,  разумеется,  записывать  од¬
ной  строкой!  Просто  книга  недостаточно  широка.)
 Введи  текст  в  приложение.  Если  ты  затем  нажмешь  кнопку  F5,  выбе¬
решь  элемент  Вычитание  (по-английски  substraction)  и  введешь  два
числа,  то  после  нажатия  кнопки  Старт  ты  увидишь,  что  программа  ра¬
ботает  правильно.  Даже  отрицательные  значения,  возникающие  в  слу¬
чае  если  первое  число  меньше  второго,  выводятся  верно.
 Приложение  «Калькулятор»  при  выполнении  вычитания
 Займемся  умножением.  Учитывая,  что  соответствующий  знак  умноже¬
ния  обозначается  звездочкой  (*),  программный  код  примет  следую¬
щий  вид:
 If  optMult.Value  =  True  Then
 LblResult.Caption  =  Val(txtNuml.Text)  *
 Val(txtNum2.Text)
 End  If

(Не  забудь,  что  текст  необходимо  записывать  одной  строкой.)
 Сделай  управляющий  элемент  lblResult  достаточно  широким,
для  того  чтобы  в  нем  помещались  большие  числа.  Если  умножить
999999  на  999999  (самые  большие  шестизначные  числа),
получится  999998000001.
 С  операцией  деления  дело  обстоит  несколько  сложнее.
Собственно  говоря,  язык  Visual  Basic  знает  три  (!)  различных  типа
деления.  Мы  должны  разобраться  в  них,  так  как  все  они
используются  в  повседневной  практике.
 Обычный  случай  —  деление  чисел  с  плавающей  запятой.  При  этом
типе  деления  рассчитываются  десятичные  знаки,  стоящие  после
нее.  Так,  результат  деления  3  на  2  записывается  в  виде  1.5.
 Обозначением  для  этого  типа  деления  служит  символ  (/),  то  есть
обычная  косая  черта.
 Дважды  щелкни  мышью  пустую  форму  и  введи  в  качестве  кода  (между
строками  Private  Sub  Form_Load  () 	- 	End  Sub)  следующий
 текст:
 Debug.Print  3/2
 Посмотри  на  результат,  появившийся  в  окне  отладки.  Введи  другие
числа,  например,  с  плавающей  запятой:  4.2  и  1.8.  Не  забывай,  что
вместо  запятой  ставится  точка!
 Операция  деления

Второй  тип  деления  —  деление  нацело,  результат  которого  всегда
является  целым  числом,  а  знаки  после  запятой  отбрасываются
без  округления.
 Обозначением  для  этого  типа  деления  является  символ  (\)  —
обратная  косая  черта.
 В  языке  Visual  Basic  результатом  выполнения  операции  3  \  2
является  1,  и  остаток  отбрасывается.
 Поэкспериментируй  (с  помощью  команды  Debug.  Print)  с  этим
видом  деления.
 В  предыдущем  примере  остаток  от  деления  был  равен  1.  Полу¬
чить  этот  результат  можно  с  помощью  третьего  вида  деления,  ис¬
пользующегося  в  языке  Visual  Basic,  —  mod  так  называемого  де¬
ления  по  модулю.  Команда  для  выполнения  данного  типа  деле¬
ния  выглядит  следующим  образом:  mod.
 Например,  9  mod  4  дает  в  результате  1,  так  как  4  содержится  в  9
дважды,  и  остаток  равняется  1.
 Еще  один  пример:  11  mod  3.  Расчет  производится  так:  3  укладывается  в
числе  11  три  раза  (соответственно,  11  \  3  =  3),  и  остаток  равняется  2.
 Зачем  нужны  операции,  подобные  двум  последним?  Почему  не
использовать  только  деление  с  плавающей  запятой  (в  конце
концов,  оно  самое  точное)?
 Предположим,  что  при  работе  с  программой  необходимо
определить,  является  введенное  пользователем  число  четным
или  нечетным.  Наиболее  простой  способ  сделать  это  —
обратиться  к  операции  деления  по  модулю.

Небольшое  задание
 Напиши  приложение,  которое  выясняет,  является  ли  введенное  поль¬
зователем  число  четным  или  нечетным,  и  выдает  соответствующий  ре¬
зультат  в  окне  сообщения  MessageBox.
 Несколько  указаний:
 1. 	Пользователь  должен  вводить  число  в  поле  управляющего  элемента
TextBox.
 2. 	Этот  текст  с  помощью  команды  Val  необходимо  преобразовать
в  число.
 3. 	Применяя  деление  по  модулю,  программа  должна  установить,  явля¬
ется  это  число  четным  или  нечетным.  Допустим,  оно  сохранено  в  пере¬
менной  inputNumber.  Тогда  необходимо  действовать  следующим
образом:
 If  InputNumber  mod  2=0  Then...
и,  соответственно,
 If  InputNumber  mod  2=1  Then...
 Пусть  задано  число  10  (четное  число).  Тогда  результатом  операции  10
mod  2  является  0.  Для  числа  11  (нечетное  число)  результат  этой  опера¬
ции  равен  1.
 4. 	Вслед  за  конструкцией  if-then  должно  следовать  соответствую¬
щее  окно  MessageBox.
 Предложение  по  решению  этого  задания
 В  виде  исключения  я  покажу  тебе  решение  поставленной  задачи,
поскольку  попутно  необходимо  сделать  еще  и  кое-какие  пояснения.
Но  не  ленись!  Советую  прочесть  этот  раздел  после  того,  как  ты

самостоятельно  разработаешь  проект  программы.  Ты  можешь
сравнить  его  с  моим  или  заглянуть  в  решение,  если  тебе  не  удастся
справиться  с  поставленной  задачей.
 Форма  должна  выглядеть  так:
 Если  элемент  TextBox  называется  txtInput,  а  командная  кнопка  —
cmdOK,  то  соответствующий  программный  код  выглядит  следующим
образом:
 Как  видишь,  я  связал  весь  программный  код  с  командной  кнопкой  ОК.
Разумеется,  имелись  и  другие  возможности.  Подумай,  какие  именно.
 Приложение  можно  улучшить  с  точки  зрения  внешнего  вида.
Например,  выровнять  текст  в  поле  ввода  управляющего  элемента  по
правому  краю.
 Кроме  того,  следовало  бы  изменить  скучный  серый  цвет  нашей
формы.  Для  этого  щелкни  ее  мышью  в  свободном  от  управляющих

элементов  месте.  Форма  станет  активным  объектом,  который  можно
изменять  с  помощью  окна  свойств.  Щелкни  мышью  поле  свойства
BackColor  (Цвет  фона)  и  немного  поэкспериментируй  с  этим
свойством.  Ты  обязательно  найдешь  что-нибудь  подходящее.
 В  этой  книге  рассказано  не  обо  всех  свойствах  управляющих
элементов.  Но  ты  очень  многому  научишься,  если  самостоятель¬
но  будешь  работать  с  разными  свойствами,  изменять  их  и  срав¬
нивать  результаты.  Только  не  забывай  каждый  раз  перед  тем,  как
заняться  новым  проектом,  сохранять  старый.
 Запусти  приложение.  На  экране  появится  следующее  окно:
 Подсчет  продолжается
 Закончим  работу  над  программой  «Калькулятор».  Как  будет
выглядеть  код,  соответствующий  операции  деления?  Сейчас  нам
понятно,  как  он  пишется:

If  optDiv.Value  =  True  Then
 LblResult.Caption  =  Val(txtNuml.Text) 	/  J
 Val(txtNum2.Text)
 End  If
 Здесь  и  далее  символ  (J)  означает,  что  код  программы  по  техническим
причинам  разделен  в  книге  на  несколько  строк.  Ты  должен  вводить
его  одной  строкой!  (Вводить  символ  J  при  этом,  разумеется,  не
следует.)
 В  нашем  приложении  есть  еще  кое-что,  что  мне  совсем  не
нравится.  Запусти  его  и  раздели  2  на  3.  Как  ты  знаешь  из
школьного  курса  алгебры,  результатом  является  периодическая
дробь,  которая  при  всем  нашем  желании  не  уместится  ни  в  одно
поле  вывода.
 Кроме  того,  попробуй  разделить  какое-нибудь  число  на  0.  Visual
Basic  выдаст  сообщение  об  ошибке  Run-time  error  11:  division
by  zero  и  завершит  выполнение  программы.
 И  то,  и  другое  следует  исправить.  Прежде  всего,  ограничим  число
знаков  после  запятой  в  поле  ввода  двумя  (разумеется,  можно
оставить  три  или  более  знаков).
 Как  это  сделать?  Язык  Visual  Basic  предоставляет  в  наше  распоряже¬
ние  специальную  функцию,  а  именно  —  Format.  Вслед  за  этой  ко¬
мандой  необходимо  указать  величину,  представленную  определен¬
ным  образом.  Иными  словами,  ее  следует  отформатировать.  За  ней  в
кавычках  записывают  вид  форматирования.  В  нашем  случае  —
«0.00».  Это  означает,  что  так  или  иначе  станут  выводиться  только  два
знака  после  запятой,  причем  Visual  Basic  будет  правильно  произво¬
дить  округление  в  большую  или  меньшую  сторону.  При  этом  нули  в
указании  формата  заменяются  конкретными  числами.  Если  в  числе
до  десятичной  запятой  имеется  несколько  знаков,  то  все  они,  естест¬
венно,  сохраняются.

До  сих  пор  изложение  было  несколько  отвлеченным.  Посмотрим  на
конкретном  примере  нашего  приложения  «Калькулятор»,  как  выпол¬
няются  описанные  операции.
 Прежде  всего,  нам  понадобится  дополнительная  переменная,  в  кото¬
рую  будет  записываться  результат  деления.  Мы  объявим  ее  как  пере¬
менную  типа  Single,  так  как  при  делении  могут  появляться  числа  с
плавающей  запятой.  (Если  ты  забыл,  что  это  за  тип,  перечитай  раздел
«Понятие  переменной».)
 В  новом  программном  коде,  относящемся  к  делению,  запишем  следу¬
ющее:
 If  optDiv.Value  =  True  Then
Dim  Result  As  Single
End  If
 Присвоим  данной  переменной  значение  таким  образом:
 Result  =  Val(txtNuml.Text) 	/ 	Val(txtNum2.Text)
 В  принципе,  от  первоначального  текста  новый  отличается  незначитель¬
но,  и  я  надеюсь,  он  тебе  понятен.  На  всякий  случай  кратко  поясню  его
суть.
 В  величинах  txtNuml.  Text  и  txtNum2  .  Text  хранятся  в  виде
текста  (то  есть  в  виде  значений  типа  String)  введенные
пользователем  числа.  С  помощью  функции  Val  этот  текст
преобразуется  в  числа.  Полученные  числа  делятся  друг  на  друга.
Это  делается  с  помощью  знака  деления  (/).  Результат  деления
присваивается  переменной  Result.  С  ней  мы  и  будем  работать
далее.
 Теперь  в  игру  вступает  команда  Format,  о  которой  я  только  что  тебе
рассказал.  В  скобках  за  словом  Format  идет  подлежащее
форматированию  значение,  а  затем  указывается  вид  форматирования.
Записываем  команду  следующим  образом:
 Format(Result, 	"0.00")

Итак,  в  результате  калькуляции  число  знаков  после  запятой
ограничено  двумя.  Записываем  в  поле  вывода  следующий  текст:
 lblOutput.Caption  =  Format(Result, 	"0.00")
 Готово.  Мне  кажется,  я  объяснил  все  достаточно  подробно,  так  что
тебе  все  должно  быть  ясно.  В  противном  случае  прочти  этот  раздел
еще  раз.  При  повторном  чтении  многое  становится  понятнее.
 Возможно,  ты  спросишь,  зачем  было  вводить  дополнительную
переменную  Result.  Собственно,  необходимости  в  этом  нет.
Она  служит  исключительно  для  того,  чтобы  сделать  программ¬
ный  код  более  понятным.  Если  этого  не  делать,  результат  можно
было  бы  отформатировать  и  непосредственно.  Соответствую¬
щий  код  выглядел  бы  так:
 lblResult.Caption  =  Format(Val(txtNuml.Text) 	/ 	J
 Val(txtNum2.Text), 	"0.00")
 Этот  текст  весьма  труден  для  понимания.  Запомни:  программирование  —
это  вовсе  не  искусство  записывать  все  как  можно  более  сложно  (хотя
некоторые  программисты  думают  именно  так).
 Итак,  если  ты  уже  изменил  конструкцию  if  для  деления,  можно
выполнить  программу.
 Замечательная
 программа!

Попробуй  разделить  друг  на  друга  разные  числа.  Ты  увидишь,  что
приложение  работает  без  ошибок  до  тех  пор,  пока  ты  не  станешь
делить  на  ноль.  Все  правильно,  мы  еще  не  позаботились  о  запрете
такой  операции.
 Мы  решим  эту  задачу  с  помощью  одной  простой  конструкции  i  f,
которая  позволит  установить,  не  является  ли  значение
txtNum2  .  Text  нулем.  Если  да,  то  мы  проинформируем  пользо¬
вателя  о  том,  что  он  собирается  выполнить  недопустимую  опера¬
цию.  Кроме  того,  мы  позаботимся  о  том,  чтобы  такое  деление  не
выполнялось.
 Это  делается  таким  образом:
 If  txtNum2.Text  =  "О"  Then
 MessageBox  "Деление  на  ноль  недопустимо!"
 Exit  Sub
End  If
 Инструкция  Exit  Sub  отменяет  дальнейшее  выполнение  проце¬
дуры  Private  Sub  cmdStart_Click().
 Действительно,  было  бы  неразумно  вначале  указать  пользовате¬
лю  на  то,  что  он  ввел  неверное  число,  а  потом  позволить  програм¬
ме  выполняться.
 Для  того  чтобы  ты  мог  правильно  записать  весь  код,  относящийся  к
делению,  я  привожу  его  целиком:
 If  optDiv.Value  =  True  then
Dim  Result  As  Single
If  txtNum2.Text  =  "0"  Then
 MessageBox  "Деление  на  ноль  недопустимо!"
Exit  Sub
 End  If
 Result  =  Val(txtNuml.Text)  /  Val(txtNum2.Text)
LblOutput.Caption  =  Format(Result, 	"0.00")
 End  If

А  сейчас  я  покажу  тебе,  как  выглядит  наш  программный  код  целиком:
 ¥о1омшенная  конструкция  If
 Если  ты  думаешь,  что  мы  уже  закончили  работать  над  нашим
приложением,  то  ошибаешься.  Мы  попробуем  научиться  более
эффективно  использовать  конструкцию  if.
 Конструкция  if,  позволяющая  выяснить,  какой  из  элементов
OptionButton  был  выбран,  в  ее  настоящем  виде  мне  не  нра¬
вится.  Предположим,  что  пользователь  вводит  два  числа  и  нажи¬
мает  кнопку  Старт,  но  забывает  указать  арифметическое  дейст¬
вие.  В  таком  случае  вычисление  не  производится,  так  как  ни  од¬
но  из  условий  конструкции  if  в  нашей  программе  не  выполнено.
В  данной  ситуации  нам  следовало  бы  вывести  сообщение  об
ошибке.

Если  выполнено  условие,
то  делай  следующее...
 Если  оно  не  выполнено,
то  делай  следующее...
 В  переводе  на  язык  программирования:
 If  .  .  .
 Then  .  .  .
 Else  .  .  .
 End  If
 Слово  else  (в  переводе  с  английского  означающее  «в  противном
случае»)  для  нас  является  новым.  Приведу  небольшой  пример.
 ► 	Сохрани  программу  «Калькулятор»,  если  ты  еще  не  сделал  этого.
 ► 	Создай  новый  проект  с  управляющими  элементами  Label,  TextBox  и
одной  командной  кнопкой,  например  таким  образом:
 Управляющий  элемент  Name 	Caption/Text
 Label 	Ibllnput  Введите  число  от  1  до  100
 TextBox 	txtlnput 	(пусто)
 CommandButton 	cmdOK 	&ОК
 Я  еще  раз  покажу  тебе,  как  выглядит  при  этом  пользовательская
оболочка.  В  дальнейшем,  мне  кажется,  ты  уже  сможешь  обходиться
только  подобными  таблицами.
 Дважды  щелкни  мышью  командную  кнопку  и  введи  следующий
программный  код:
 If  txtlnput.Text  <  50  Then
 MsgBox  "Важе  число  меньше  50"
 Нам  снова  приходится  использовать  конструкцию  if  then-end
if,  которая  в  данном  случае  должна  иметь  следующий  вид:

Else
 MsgBox  "Ваше  число  больше  или  равно  50"
End  If
 Посмотри  внимательно,  как  выглядит  в  данном  случае  конструк¬
ция  if.  Вначале  идет  обычная  конструкция  if-then,  затем
команда  Else,  а  текст  заканчивается  словами  End  If.
 Остальное  должно  быть  тебе  ясно,  за  исключением  разве  что  символа
(<).  Он  означает  «меньше,  чем»  и  сравнивает  в  нашем  примере  число,
введенное  пользователем,  с  50.  Имеется  и  понятие  «больше,  чем».
Соответствующим  символом,  естественно,  является  (>).
 Вернемся  к  программе  «Калькулятор».  Нам  осталось  добавить
последний  штрих,  чтобы  закончить  работу  над  ней.
 До  сих  пор  мы  для  каждой  возможности  создавали  определенную
конструкцию.  Команда  else  на  этот  раз  не  подходит:  в  какой  из
четырех  разных  конструкций  можно  было  бы  ее  использовать?
 Вместо  нее  мы  используем  следующую  структуру:
 Если  выделен  элемент  Сложение,
то  складывай,
 если  вместо  этого  выделен  элемент  Вычитание,
то  вычитай,
 если  вместо  этого  выделен  элемент  Умножение,
то  умножай,
 если  вместо  этого  выделен  элемент  Деление,
то  дели,
 если  не  выделено  ничего,
то  выдай  сообщение  об  ошибке.
 Условие  «если  вместо  этого»  на  языке  Visual  Basic  звучит  как
Elself  (записывается  одним  словом!).  Эта  команда,  очевидно,
составляется  из  двух  английских  слов  Else  и  If.

Воспользуемся  данной  конструкцией.  При  этом  удалим  все  отдельные
строки  End  If.  Их  заменит  одна  команда  End  If,  стоящая  в  конце
всей  конструкции.  Такая  запись  имеет  еще  и  то  преимущество,  что
текст  программного  кода  становится  короче.
 На  всякий  случай  необходимо  заметить,  что  конструкция  I  f  в  разделе
программного  кода,  отвечающем  за  деление,  остается  нетронутой.
 На  рисунке  приведен  весь  программный  код:
 Программа  готова
 Подобные  конструкции  if  встречаются  в  программировании  очень
часто  и  являются  весьма  важными.  Ты  должен  хорошо  освоить  их!
 Несколько  небольших  заданий
 В  разделе,  в  котором  говорилось  о  делении  по  модулю,  мы  написали
небольшую  программу  для  определения  того,  является  ли  введенное
число  четным  или  нечетным.  Перепиши  ее  так,  чтобы  в  ней  была  новая
конструкция  Else.

^  В  главе  3  мы  говорили  об  элементе  ListBox  и  использовали
конструкцию  if  для  запроса  имени.  Замени  отдельные  конструкции
if  одной  конструкцией  Elself.
 Напиши  программу,  которая  бы  требовала  от  пользователя  ввести
число  с  несколькими  знаками  после  запятой.  Выведи  это  число  с  тремя
десятичными  знаками.

5. 	Дальнейшее  изучение
Visual  Basic
 А  сейчас  мы  немножко  поиграем.  Вначале  мы  познакомимся
с  циклами  —  постоянно  повторяемыми  наборами  действий.
 В  этой  главе  ты  узнаешь:
 • 	кое-что  еще  об  управляющих  элементах;
 • 	кое-что  еще  о  постфиксном  операторе;
 Ф  как  заставить  компьютер  выполнять  цикл;
 • 	какие  существуют  виды  циклов,  и  как  они  устроены;
 • 	зачем  нужны  комментарии  в  программном  коде;
 • 	что  еще  можно  делать  с  помощью  таймера.
 Кроме  того,  ты  познакомишься  с  основами  компьютерной  графики.

Создание  циклов
 Компьютеры  не  умеют  думать,  но  они  способны  к  выполнению
большого  объема  работы.  Поэтому  они  особенно  необходимы  в  тех
случаях,  когда  требуется  выполнять  достаточно  длительное  время
одни  и  те  же  действия.  Вспомни  пример  с  космическим  кораблем,
который  перемещается  по  экрану.  Допустим,  что  его  полету  ничто  не
препятствует  (препятствия  вроде  вражеского  нападения  —  это,  как  ты
знаешь  из  главы  4,  повод  для  перехода  в  другой  режим  работы
приложения).  Тогда  компьютер  должен  постоянно  рассчитывать  новое
положение  корабля.  Если  он  движется  слева  направо  вдоль
воображаемой  оси  X,  то  соответствующее  значение  координаты
непрерывно  увеличивается,  насколько  хватает  ширины  экрана.
 Для  того  чтобы  лучше  понять,  о  чем  идет  речь,  заметим,  что  ось  X
в  Visual  Basic  имеет  традиционное  направление,  то  есть  слева
направо.  Ось  Y  направлена  не  снизу  вверх,  как  обычно  принято,  а
сверху  вниз.  К  этому  ты  должен  привыкнуть.  Кстати,  аналогичная
система  координат  принята  не  только  в  Visual  Basic.  Точка  в  левом
верхнем  углу,  таким  образом,  имеет  координаты  (0;0).
 Система  координат  в  Visual  Basic

Urgpa
 Создай  новый  проект,  назови  форму  frmBall  и  придумай
подходящий  заголовок,  например  «Игра  в  мяч».
 Для  того  чтобы  нарисовать  мяч,  воспользуйся  значком  SHape,  находя¬
щимся  на  панели  инструментов  (как  правило,  в  третьей  строке  снизу
слева).  Это  очень  полезный  для  графического  программирования  уп¬
равляющий  элемент,  так  как  с  его  помощью  можно  рисовать  основные
геометрические  фигуры  (заметь,  что  программисту  необязательно
уметь  хорошо  рисовать).  Кстати,  shape  означает  по-английски  «фор¬
ма»  или  «образ».
 Дважды  щелкни  мышью  этот  значок,  и  соответствующий  управляю¬
щий  элемент  появится  в  форме.  Рассмотри  в  окне  свойств  в  поле
Shape  имеющиеся  геометрические  фигуры.  Выбери  вариант  под  но¬
мером  3,  то  есть  круг.  Присвой  ему  имя  shpBall.
 Как  правило,  мячи  непрозрачны.  Поэтому  измени  значение  свойства
BackStyle  (Тип  фона),  указав  не  0  -  Transparent  (Прозрачный),
а  1  -  Opaque  (Непрозрачный).
 В  поле  свойства  BackColor  выбирается  цвет  фона.  Для  этого  щелкни
мышью  слово  Palette  (Палитра),  а  затем  укажи  понравившийся  цвет.  Я
выбрал  красный.
 Если  ты  теперь  выберешь  в  форме  элемент  SHape,  то  увидишь,  что  его
рамка  заметно  шире,  чем  он  сам.  Чтобы  исправить  это,  задай  для  свой¬
ства  Width  то  же  значение,  что  и  для  Height.  В  моем  случае  значение
для  обоих  свойств  равно  372,  но  тебе  необязательно  задавать  те  же
величины.  В  любом  случае  четыре  средних  держателя  должны  нахо¬
диться  точно  на  границе  элемента  SHape.
 Задай  для  свойства  Left  (Левая  координата),  определяющего  положе¬
ние  левого  края  элемента  SHape,  значение  2000.
 Для  того  чтобы  мяч  получил  возможность  двигаться,  добавь  команд¬
ную  кнопку  (Name:  cmdStart,  Caption:  Старт).

Форма  выглядит  следующим  образом:
 Пока  мяч  остается  в  покое
 Попробуем  научиться  перемещать  мяч  по  экрану.  Скажу  тебе  сразу,
что  существуют  более  элегантные  методы  работы  с  графикой,  чем  те,
 о 	которых  я  сейчас  расскажу.  Однако  нам,  прежде  всего,  требуется
освоить  циклы,  а  качество  графического  представления  объекта  нам
не  столь  важно  (вполне  вероятно,  что  изображение  движущегося  мяча
будет  мигать).
 Для  начала  мы  постараемся  добиться  того,  чтобы  при  выполнении
приложения  мяч  сдвигался  вправо.  Для  этого  необходимо,  чтобы
значение  свойства  Left  элемента  shpBall  постоянно  увеличивалось.
 Напомню,  что  для  обращения  к  свойствам  управляющего  элемента  или
изменения  их  во  время  выполнения  программы  используется
постфиксный  оператор.  Это  весьма  важное  понятие,  которое  тебе
обязательно  нужно  усвоить.  По  мере  изучения  языка  ты  поймешь,  что
без  постфиксного  оператора  работать  совершенно  невозможно.  Если
ты  забыл,  что  он  собой  представляет,  перечитай  соответствующий
раздел  главы  4.  Кратко  напомню,  что  для  обращения  к  свойствам
управляющего  элемента  в  программном  коде  необходимо  написать
имя  (Name)  нужного  элемента,  поставить  за  ним  точку  и  затем  указать
название  свойства.
 Таким  образом,  обращение  к  свойству  Left  нашего  мяча  (с  именем
shpBall)  выглядит  следующим  образом:
 shpBall.Left

Для  подготовки  к  написанию  приложения  дважды  щелкни  мышью
кнопку  cmdStart  и  введи  в  окне  кода  такую  строку:
 shpBall.Left  =  3000
 Можно  указать  и  какое-нибудь  другое  число,  превышающее
начальное  значение  (равное  2000).
 При  выполнении  программы  ты  увидишь,  что  после  нажатия  кнопки
Старт  мяч  рывком  перемещается  в  другое  место  экрана.
 Так  работают  с  постфиксным  оператором.  А  теперь  удали  эту  строку  в
программном  коде,  так  как  мы  переходим  к  циклам.  Наша  очередная
задача  состоит  в  том,  чтобы  научиться  плавно  передвигать  мяч  слева
направо.
 Снова  дважды  щелкни  мышью  командную  кнопку  Старт  и  введи  в
открывшемся  окне  программного  кода  следующие  строки:
 Dim  i  As  Integer
For  i  =  1  To  1000
 ShpBall.Left  =  shpBall.Left  +  1
Next  i
 Привожу  для  сравнения  свой  код:
 Цикл  for
 Наш  первый  цикл  for

Разберемся  в  этом  коде.  В  первой  строке  объявляется  переменная,
используемая  в  приложении.
 Далее  следует  так  называемый  операторный  блок  (processing
block),  а  именно  цикл  forrnext.  Он  выполняется  столько  раз,
сколько  указано  в  команде  после  оператора  for  (в  нашем  случае
1000  раз).  При  каждом  прохождении  цикла  значение
shpBall.  Left  увеличивается  на  единицу.
 Если  начальное  значение  этой  величины  в  окне  свойств  было  зада¬
но  равным  2000,  то  в  конце  работы  программы  оно  станет  равным
3000.
 Запусти  приложение,  и  ты  увидишь,  что  мяч  станет  двигаться  слева
направо.  Таким  образом,  выбранный  метод  работает.
 Рассмотрим  еще  раз  конструкцию  такого  цикла.
 Вначале  всегда  стоит  оператор  For,  за  ним  идет  переменная  (в
нашем  случае  просто  i).  Далее  следуют  указания  по  выполнению
цикла.  Выражение  1  То  1000  (то  есть  от  1  до  1000)  означает,  что
переменная  i  проходит  все  значения  от  1  до  1000.  Иными  словами,
цикл  выполняется  1000  раз.
 В  конце  конструкции  стоит  оператор  Next  i,  который  означает,
что  необходимо  изменить  i  (увеличить  на  единицу)  и  вернуться  в
начало  цикла.
 Между  этими  операторами  стоят  многократно  выполняемые
команды  (в  нашем  случае  они  позволяют  увеличивать  значение
свойства  Left  мяча).
 Это  настолько  важно,  что  тебе  необходимо  тщательно  разобраться  в
данном  вопросе.
 Сохрани  свою  работу  и  создай  новый  проект.  Мы  снова  поработаем  с
окном  отладки  и  командой  Debug.  Print.

Дважды  щелкни  мышью  форму  для  открытия  окна  программного  кода
со  строками  Private  Sub  Form_Load  ()  и  End  Sub.
 Введи  следующий  программный  код:
 Dim  X  As  Integer
For  X  =  1  To  10
 Debug.Print  X
Debug.Print
 Next
 Этот  текст  выглядит  в  окне  программного  кода  следующим  образом:
 Запусти  программу  и  посмотри  на  окно  отладки.  Ты  должен  увидеть  в
нем  числа  от  1  до  10,  записанные  друг  под  другом  и  разделенные
пустыми  строками.
 Обрати  внимание  на  следующие  обстоятельства.
 Во-первых,  так  называемая  переменная  цикла  (loop  variable),  то  есть
величина,  стоящая  непосредственно  за  оператором  For  и  управляю¬
щая  повторениями  (в  нашем  случае  X),  может  быть  использована  и
внутри  цикла.  Тогда  в  окне  отладки  ты  увидишь  то  значение,  которое
эта  переменная  имеет  при  данном  прохождении  цикла.
 Во-вторых,  внутри  цикла  For  может  стоять  несколько  операто¬
ров.  Это  второй  оператор  Debug.  Print,  который  добавляет  пус¬
тую  строку.

И,  наконец,  в-третьих:  за  словом  Next  вовсе  не  обязательно
указывать  переменную  цикла.  Next  и  Next  X  имеют  одно  и  то  же
значение.  Однако  я  рекомендую  тебе  все-таки  указывать  ее,  —  это
поможет  быстрее  ориентироваться  в  программах,  когда  они
станут  сложнее.
 Измени  вторую  строку  следующим  образом:
 For  X  =  1  То  10  Step  2
 Строку  Debug.  Print  можно  удалить.  Запусти  программу.  В  окне
отладки  ты  увидишь  только  записанные  друг  под  другом  нечетные
числа  1,  3,  5,  7,9.  Оператор  Step  2  (step  по-английски  означает  «шаг»)
позволяет  каждый  раз  увеличивать  X  на  2.  Величину  «шаг»  можно
увеличить,  написав,  скажем,  Step  3.  Если  этот  оператор  отсутствует,  то
переменная  цикла  каждый  раз  увеличивается  на  единицу.
 Кстати,  можно  считать  и  в  обратном  порядке,  например  следующим
образом:
 For  X  =  10  То  1  Step  -1
 В  этом  случае  числа  от  10  до  1  будут  выдаваться  в  обратной
последовательности.
 Для  того  чтобы  ты  имел  базовое  представление  о  подобных
конструкциях,  я  приведу  тебе  схему  цикла  for:
 For  LoopVariable  =  Начальное  значение  То  J
Конечное  значение  Step  Длина  шага
(Тело  цикла)
 Next  LoopVariable
 Итак,  мы  обсудили  важнейшие  основы  цикла  for.  Можно  продолжить
работу  над  движущимся  мячом.  В  этой  программе  цикл  позволяет  мячу
передвигаться  на  заранее  заданные  расстояния.

Циклы  While
 Допустим,  мяч  переместился  на  некоторое  расстояние  со  своей
начальной  позиции  к  правому  краю  формы.  Тогда  использование
цикла  for  не  позволит  достичь  нашей  цели,  так  как  мы  не  знаем,
сколько  раз  нужно  его  выполнить,  прежде  чем  мяч  достигнет
правого  края.
 Нам  требуется  цикл,  который  выполняется  до  тех  пор,  пока
выполнено  некоторое  условие.
 В  языке  Visual  Basic  используются  два  цикла  такого  типа.  Вначале
рассмотрим  первый  из  них.
 Открой  приложение  «Игра  в  мяч»  и  удали  старый  программный  код,
расположенный  между  Private  Sub  cmdStart_Click()  и  End  Sub.
 Вставь  следующие  строки:
 Do  While  shpBall.Left  +shpBall.Width  <  ScaleWidth
shpBall.Left  =  shpBall.Left  +  1
 Loop
 Рассмотрим  все  указанные  команды  по  очереди.  В  переводе  на
обычный  язык  данный  программный  код  означает,  что  до  тех  пор,  пока
сумма  значений  левой  координаты  мяча  и  его  ширины  меньше  ширины
формы,  следует  увеличивать  левую  координату  мяча  на  единицу.
 Сумма  значений  левой  координаты  мяча  и  его  ширины  есть  не  что  иное
как  значение  его  правой  координаты  (приходится  так  длинно  излагать
эту  мысль,  потому  что  в  языке  Visual  Basic  отсутствует  отдельное
свойство  для  правой  координаты  объекта).
 Когда  правая  координата  мяча  станет  равной  правой  координате
формы,  движение  должно  прекратиться.  Значение  координаты
правого  края  формы  равно  ее  ширине  —  ScaleWidth.  Символ  (<)  ты
уже  знаешь,  —  он  означает  «меньше,  чем».Теперь  рассмотрим
собственно  цикл.  Он  вводится  словами  Do  While  и  заканчивается
словом  Loop,  которые  по  сути  означают  следующее:  «Выполняй  цикл,
пока...».

Запусти  программу.
 Ты  увидишь,  что  мяч  независимо  от  начального  положения  будет
двигаться  до  тех  пор,  пока  не  достигнет  правого  края  формы.
С  помощью  цикла  for  этого  не  удалось  бы  добиться.
 Мяч  достиг  правой  координаты  формы
 Небольшое  задание
 Измени  приложение  «Игра  в  мяч»  так,  чтобы  объект  двигался  к
левому  краю  формы.  Заметь,  это  задание  намного  проще,  чем
предыдущее.  При  его  выполнении  необходимо  проверять,  превышает
ли  значение  левой  координаты  мяча  нулевое.  Если  оно  стало  равным
нулю,  мяч  достиг  левого  края  формы.  До  этого  момента  данная
координата  должна  уменьшаться  в  цикле.
 Еще  один  цикл  While
 В  языке  Visual  Basic  используется  еще  одна  форма  цикла,  которая
кажется  очень  похожей  на  уже  знакомый  нам  первый  цикл  while.
В  случае  с  мячом  этот  цикл  выглядит  таким  образом:
 shpBall.Left  =  shpBall.Left  +  1
Loop  While  shpBall.Left  +  shpBall.Width  <  ScaleWidth

Ты  спросишь,  а  разве  циклы  не  одинаковы?  Почти  да,  но  только
«почти».  В  первом  из  них  условие  (достигнут  ли  правый  край
формы)  проверяется  в  начале,  а  во  втором  —  в  конце.  Ты  сразу
увидишь  это,  если  поинтересуешься,  в  каком  месте  цикла  стоит
данное  условие.
 Следовательно,  второй  цикл  в  любом  случае  будет  пройден,  по
меньшей  мере,  один  раз,  независимо  от  того,  выполнено  условие
или  нет,  так  как  его  соблюдение  проверяется  только  в  конце  цикла.
 В  первом  цикле  дело  обстоит  по-другому.  В  нем  условие  стоит  в
начале,  и  если  оно  не  выполнено  (то  есть  мяч  уже  достиг  правого
края  формы),  то  никаких  действий  не  происходит.
 Какой  цикл  следует  выбрать  для  нашего  приложения?  Подумай
над  этим  сам,  прежде  чем  читать  книгу  дальше.
 Нам  подходит,  разумеется,  первая  форма  цикла  Do  While  .  .  .
Loop,  в  котором  условие  проверяется  в  самом  начале  Сможет
оказаться,  что  уже  при  запуске  приложения  мяч  находится  на
правом  краю  формы,  и  ему  не  нужно  передвигаться).
 Таким  образом,  мы  обсудили  все  важнейшие  формы  цикла,
касающиеся  его  начала,  и  условные  конструкции  (собственно  говоря,
их  существует  больше).
 Тебе  необязательно  отлично  знать  и  помнить  все  рассмотренные
циклы.  Намного  важнее,  чтобы  ты  понимал  идеи,  которые  стоят
за  этими  конструкциями.  Ты  должен  ясно  понимать,  когда  и
какой  цикл  следует  использовать,  а  конкретную  его  структуру
можно  позаимствовать  из  книги.

Небольшое  задание...
 Вспомни  цикл  For,  с  помощью  которого  мы  выводили  числа  от  1  до
10.  Данные  действия  можно  запрограммировать  и  с  помощью  цикла
While.  Подумай,  как  это  сделать.  Какой  из  двух  известных  тебе
вариантов  цикла  While  следует  использовать  в  таком  случае?
 Если  ты  не  сможешь  выполнить  задание,  я  еще  раз  в  виде  исключения
приведу  его  решение.  Но  вначале  попробуй  справиться  сам.
 ...  и  его  решение
 Прежде  всего,  тебе  потребуется  дополнительная  переменная,  —
переменная  цикла.  Назовем  ее  X.  Ей  ты  вначале  присвоишь  нулевое
значение.  Кроме  того,  мы  воспользуемся  циклом,  в  котором  эта
переменная  будет  каждый  раз  увеличиваться  на  единицу.  Поскольку
ее  значение  возрастает  в  любом  случае,  задействуем  вторую  форму
цикла  While,  —  он  будет  исполняться  до  тех  пор,  пока  X  меньше  10.
Ниже  приводится  соответствующий  программный  код:
 Dim  X  As  Integer
X  =  0
Do
 X  =  X  +  1
Debug.Print  X
Loop  While  X  <  10
 Однако  в  таких  случаях,  как  правило,  используют  цикл  For.
 Новое  приложение  «Игра  в  мяч»
 Что  это  за  игра,  в  которой  мяч  передвигается  слева  направо  или  справа
налево,  а  потом  застывает  на  месте?  Расширим  функциональные
возможности  нашего  приложения.  Пусть  мяч  отскакивает  от  правого  края
формы  (причем  угол  его  падения  равен  углу  отражения),  двигается  к
противоположному  краю,  от  него  —  снова  к  правому  краю  формы  и  т.д.,

как  в  старых  играх  в  пинг-понг  времен  первых  компьютеров  и
видеотерминалов.  Для  имитации  подобного  движения  нам  понадобится
управляющий  элемент  Timer,  о  котором  говорилось  в  главе  3.
 Создай  новую  форму  и  размести  в  ней  управляющие  элементы  со
следующими  параметрами:
 Управляющий  элемент
 Name
 Caption
 Form
 frmBall
 Игра  в  h
 CommandButton
 cmdStart
 &Старт
 CommandButton
 cmdStop
 Сто&п
 Timer
 tmrTimer
 (-)
 Shape
 shpBall
 (-)
 Для  элемента  Shape  задай  те  же  значения,  что  и  в  предыдущей
программе.  Для  свойства  Enabled  элемента  Timer  задай  значение  False
(мы  хотим  включать  таймер  нажатием  соответствующей  командной
кнопки),  а  для  свойства  Interval  —  значение  1,  чтобы  таймер  включался
как  можно  чаще,  и  движение  мяча  было  относительно  быстрым.
 Внешний  вид  нашего  приложения  выглядит  примерно  таким  образом:
 Мы  будем  управлять  таймером  с  помощью  командных  кнопок  Старт
и  Стоп.
 С  управляющим  элементом  Timer  ты  познакомился  в  главе  3.  На
всякий  случай  перечитай  ее  соответствующий  раздел.  Ниже  я  еще
раз  тебе  все  подробно  объясню.

Итак,  для  свойства  таймера  Enabled  мы  задали  значение  False,
чтобы  иметь  возможность  управлять  таймером  непосредственно
из  программы.  Он  должен  начинать  работать  после  нажатия
кнопки  Старт  и  останавливаться  после  команды  Стоп.  Итак,  мы
начнем  писать  код  для  обеих  кнопок.  Замечу,  что  теми
функциями,  которые  должен  выполнять  таймер,  мы  займемся
позже.
 Вначале  попробуй  сам  написать  необходимый  программный  код.  Это
не  очень  сложно.
 Для  сравнения  приведу  решение.  Для  кнопки  Старт  код  выглядит
следующим  образом:
 Private  Sub  cmdStart_Click()
 TmrTimer.Enabled  =  True
End  Sub
 Для  кнопки  Стоп:
 Private  Sub  cmdStart_Click()
 TmrTimer.Enabled  =  True
End  Sub
 Если  тебе  что-то  непонятно  в  этом  коде,  перечитай  конец  главы  3.
 Запусти  программу  и  посмотри,  как  работают  кнопки.  Хотя  таймер  и
генерирует  события,  никаких  действий  не  происходит,  так  как  они  не
запрограммированы.
 Работа  с  таймером
 Как  ты  помнишь,  процедура,  в  которой  происходит  обработка
генерируемых  таймером  событий,  называется
 Private  Sub  tmrTimer_Timer()

Поскольку  мы  установили  для  таймера  интервал  равный  1,
соответствующий  код  будет  выполняться  с  частотой  один  раз  в
тысячную  долю  секунды.
 Если  тебе  что-то  непонятно,  перечитай  еще  раз  раздел,
посвященный  таймеру  в  главе  3.
 В  нашем  случае  это  означает,  что  расчет  нового  положения  мяча  на
экране  будет  проводиться  каждую  тысячную  долю  секунды.  В  результате
движение  на  глаз  получится  более  или  менее  плавным  (не  вполне
естественным,  но  для  наших  целей  подходящим).
 Мы  намерены  одновременно  двигать  мяч  не  только  по  горизонтали  (слева
направо),  но  и  по  вертикали  (снизу  вверх).  Нам  уже  не  будет  достаточно
изменять  значение  свойства  Left,  контролирующего  движение  только
вдоль  оси  X.  Нам  также  потребуется  изменять  и  координату  по  оси  Y  с
помощью  свойства  Тор  (Верхняя  координата)  элемента  Shape.  Это
свойство  управляет  перемещением  мяча  вдоль  оси  Y.
 Для  того  чтобы  хорошо  разобраться  в  рассматриваемом
вопросе,  сделай  небольшое  предварительное  упражнение.
 Перепиши  первоначальную  программу  «Игра  в  мяч»  так,  чтобы
мяч  двигался  от  начального  положения  не  к  правому,  а  к
верхнему  краю  формы.
 Поскольку  мяч  должен  двигаться  вдоль  оси  Y,  нам  придется
воспользоваться  свойством  Тор.
 Кроме  того,  не  забывай  о  том,  что  в  компьютерной  системе
координат  ось  У  направлена  сверху  вниз.
 ^  Обязательно  попробуй  сделать  это  задание  самостоятельно.

На  всякий  случай  я  приведу  решение:
 Option  Explicit
 Private  Sub  cmdStart_Click()
 Do  While  shpBall.Top  >  0
 shpBall.Top  =  shpBall.Top  -  1
 Loop
End  Sub
 Этот  цикл  означает,  что  до  тех  пор,  пока  значение  координаты  верхней
границы  мяча  больше  0  (то  есть  мяч  находится  ниже  верхнего  края
формы),  оно  должно  уменьшаться  на  единицу.
 Ясно,  что  для  того  чтобы  мяч  двигался  по  диагонали,  внутри  процеду¬
ры  таймера  (Private  Sub  tmrTimer_Timer  ())  необходимо  изме¬
нять  как  значение  свойства  Тор,  так  и  значение  Left.  Например,  таким
образом:
 shpBall.Left  =  shpBall.Left  +  90
shpBall.Top=  shpBall.Top  +  75
 В  результате  каждую  тысячную  долю  секунды  значения  обоих  этих
свойств  будут  увеличиваться  на  соответствующие  величины  (числа  90  и
75  указаны  для  примера).
 Однако  вскоре  ты  убедишься,  что  в  нашей  программе  было  бы  на¬
много  удобнее  использовать  вместо  абсолютных  чисел  переменные.
 Как  говорилось  в  начале  главы  4,  переменные  резервируют  мес¬
то  в  памяти  компьютера  (если  ты  забыл  это,  обязательно  перечи¬
тай  соответствующий  раздел).  Они  составляют  основу  програм¬
мирования:  если  бы  их  значения  не  менялись  (то  есть  переменные
не  существовали  бы),  то  программы  в  разных  ситуациях  всегда
выдавали  бы  одинаковые  результаты.  Программировать,  ничего
не  понимая  в  переменных,  невозможно.  Их  необходимо  хорошо
изучить.

Объяви  в  начале  программного  кода,  идущего  непосредственно  под
строкой  Option  Explicit,  две  переменные  с  понятными  названия¬
ми,  например:
 Dim  XValue  As  Integer
Dim  YValue  As  Integer
 Необходимо  присвоить  данным  переменным  значения.  Лучше  все¬
го  сделать  это  в  какой-нибудь  процедуре,  которая  выполняется
сразу  при  запуске  программы.
 Загляни  еще  раз  в  раздел  главы  3  «Элемент  ScrollBar».  В  нем  го¬
ворилось,  что  для  таких  целей  наиболее  подходит  процедура
 Private  Sub  Form_Load().
 Для  того  чтобы  попасть  в  данный  фрагмент  программного  кода,
дважды  щелкни  мышью  форму  в  свободном  от  управляющих
элементов  месте.
 Внутри  появившегося  каркаса  программы  присвой  обеим  новым  пере¬
менным  следующие  значения:
 Private  Sub  Form_Load()
 XValue  =  90  'Выбирается  в  зависимости  от
YValue  =  75  'быстродействия  компьютера
End  Sub
 Что  означает  апостроф  перед  текстом?  Это  очень  полезная  вещь:
то,  что  следует  за  апострофом,  является  комментарием.  Он  слу¬
жит  для  того,  чтобы  сделать  текст  программы  более  понятным  для
программиста.  Данный  текст  игнорируется  при  работе  программы
и  невидим  для  пользователя.  В  приложении  необходимо  делать
как  можно  больше  комментариев.  Обычно  через  некоторое  время
программист  уже  не  помнит,  почему  та  или  иная  часть  приложения
была  написана  определенным  образом,  и  что  указанный  код  дол¬
жен  выполнять.  В  таком  случае  комментарии  оказываются  очень
полезными.

Я  покажу  тебе  на  примере  нашего  кода  важность  комментария.
Допустим,  что  через  полгода  ты  решишь  еще  поработать  с
написанной  программой.  Ты  наверняка  спросишь  себя:  «Почему
я  тогда  работал  с  числами  90  и  75,  а  не  с  другими?».  Прочтя
собственный  комментарий,  ты  поймешь,  что  выбор  чисел  зависит
от  быстродействия  компьютера.  Чем  быстрее  работает
компьютер,  тем  меньше  становятся  числа.
 Но  вернемся  к  программе.  Я  приведу  на  всякий  случай  весь
программный  код  целиком,  чтобы  ты  мог  сравнить  его  с  написанным
тобою:
 Прежде  всего,  заметь,  что  мы  теперь  работаем  не  с  численными
значениями  (90  и  75),  а  с  переменными.

Если  ты  запустишь  программу,  то  мяч  начнет  двигаться  по  диагонали
направо  и  вниз,  а  потом  исчезнет  за  краем  формы.  Но  такое  поведение
мяча  нас  не  устраивает.
 Нам  потребуются  так  называемые  опросы  столкновений,  без
которых  не  обходится  практически  ни  одна  компьютерная  игра.
 Необходимо  определить,  когда  мяч  достигнет  края  формы,  чтобы
заставить  программу  как-то  отреагировать  на  это.
 Говорит  ли  тебе  о  чем-нибудь  следующая  строка:
 «Если  мяч  достиг  края  формы,  то  требуется  реакция  программы»?
 Совершенно  верно,  это  условный  оператор  if.  Его  мы  и  будем
использовать  для  определения  момента  столкновения  с  каждым  из
четырех  краев  формы.
 Однако  перед  этим  давай,  решим,  какой  должна  быть  реакция
программы  в  том  случае,  если  выполнится  одно  из  указанных  условий
(мяч  достигнет  одного  из  краев  формы).
 Не  забывай,  что  составление  плана  чрезвычайно  важно  при  про¬
граммировании.  Нельзя  приступать  к  созданию  программы,  не
имея  перед  собой  четкого  плана.
 Итак,  мы  хотим  добиться  того,  чтобы  мяч  отскакивал  от  краев  формы,
оставаясь  в  игровом  поле.
 Нам  требуется,  чтобы  обьект  вел  себя  примерно  так,  как  ведут
себя  настоящие  мячи.

Запустим  программу  и  посмотрим,  что  с  ним  будет  происходить.
Он  «полетит»  сверху  вниз,  перемещаясь  при  этом  слева  направо.
Двигаясь  таким  образом,  он  достигнет  нижнего  края  формы.
 -гс.и
 Мяч  достиг  нижнего  края  формы...
 Что  произошло  бы  с  мячом,  если  бы  он  был  настоящим?
Конечно,  он  отскочил  бы  вправо  вверх.
 Мяч  отскакивает  вправо  вверх...
 Иными  словами,  в  соответствии  с  законом  физики  мяч  отскакива¬
ет  от  поверхности  под  тем  же  углом,  под  каким  он  упал  на  нее.
 Подумаем,  как  можно  сымитировать  такое  движение  в  нашей
программе.

В  поведении  координаты  X  ничего  не  меняется.  Мяч  по-прежнему
продолжает  двигаться  вправо.
 Однако  метод  расчета  координаты  по  оси  Y,  то  есть  значения
свойства  Тор,  необходимо  подкорректировать:  с  некоторого
момента  она  начинает  изменяться  в  обратную  сторону.  Посмотри
на  рисунки.  До  удара  эта  величина  увеличивалась,  а  затем  мяч
начал  подниматься,  следовательно,  значение  свойства  Тор
должно  уменьшаться.
 Перед  тем  как  мы  напишем  программу,  сформулируем  задачу,  кото¬
рую  ей  предстоит  решить.  Итак,  программа  должна  прекратить  увели¬
чивать  значение  свойства  Тор  и  начать  его  уменьшать,  как  только  мяч
достигнет  нижнего  края  формы.
 На  языке  программирования  данная  задача  выглядит  таким  образом:
 If  (shpBall.Тор  +  shpBall.Height) 	>= 	ScaleHeight 	J
 Then  YValue  =  -YValue
 (Все  это,  разумеется,  необходимо  записать  одной  строкой.  Здесь  это¬
го  не  удалось  сделать  по  техническим  причинам.  Не  забывай  о  симво¬
ле  (J),  который  не  нужно  печатать.)
 Сейчас  я  подробно  объясню  тебе  смысл  этой  строки,  и  тогда  практиче¬
ски  все  будет  сделано:  для  остальных  трех  сторон  игрового  поля  (на¬
шей  формы)  программный  код  аналогичен.
 Выражение  shpBall  .Тор  +  shpBall  .Height  определяет  положе¬
ние  нижней  координаты  мяча  (это  сумма  значений  верхней  координа¬
ты  мяча  и  его  высоты).  Данное  выражение  аналогично  знакомому  тебе
shpBall  .Left  +  shpBall  .Width,  которое  определяет  правую  ко¬
ординату  мяча.  Оно  заключено  в  скобки  только  для  удобства  чтения
записи,  и  ты  можешь  их  не  писать.

В  языке  Visual  Basic  скобки  используются  с  той  же  целью,  что  и
в  алгебре.  Если,  например,  при  вычислении
 5 	+  3*7
 ты  подразумеваешь,  что  вначале  должно  быть  произведено
сложение,  тебе  следует  расставить  скобки  следующим  образом:
 (5  +  3)  *  7
 Далее  мы  проверяем,  достигла  ли  крайняя  нижняя  точка  мяча
нижнего  края  формы,  то  есть  выполнено  ли  условие,  при  котором
значение  координаты  крайней  нижней  точки  мяча  больше  или  равно
высоты  формы.  Для  понятия  «больше»  используется  символ  (>).
Для  того  чтобы  написать  «больше  или  равно»,  требуется  ввести
символы  (>=).
 Значение  высоты  формы  получают  с  помощью  свойства  ScaleHeight
точно  так  же,  как  ранее  для  получения  ее  ширины  мы  использовали
свойство  ScaleWidth.
 Далее  в  тексте  кода  производится  следующая  инверсия:
 YValue  =  -  YValue
 Это  означает,  что  если  значение  переменной  YValue  было  равно  75,
то  теперь  оно  становится  равным  -75,  и  наоборот.
 После  «столкновения»  с  нижним  краем  формы  мяч  должен  отскочить
вверх.  Следовательно,  значение  его  свойства  Тор  станет  не
увеличиваться,  а  уменьшаться,  и  поэтому  мы  изменили  знак
переменной  YValue.

Заметь,  что  в  коде  отсутствует  выражение  End  If.  Это
объясняется  следующим  обстоятельством:  в  том  случае,  когда
после  слова  Then  в  условном  операторе  if  стоит  только  один
оператор,  все  выражение  можно  поместить  в  одну  строку,  не
используя  при  этом  End  If.
 Введи  в  программу  приведенные  выше  строки  кода.
 Часть  программного  кода,  относящаяся  к  таймеру,  должна  выглядеть
следующим  образом:
 Private  Sub  tmeTimer_Timer()
 shpBall.Left  =  shpBall.Left  +  XValue
shpBall.Top  =  shpBall.Top  +  XValue
If  (shpBall.Top  +  shpBall.Height)  >=
 ScaleWidth  Then
 YValue  =  -  YValue  'запиши  это  одной  строкой!
End  Sub
 Запусти  программу.  Ты  увидишь,  что  она  работает  правильно.
 Что  делать,  если  она  все-таки  не  работает?
 В  таких  случаях  главное  правило  —  не  пасовать  перед  труднос¬
тями.  Обычно  всему  виной  оказывается  какая-нибудь  неболь¬
шая  ошибка.  Сравни  еще  раз  свой  программный  код  с  приведен¬
ным  в  книге  —  ты  можешь  быть  уверен  в  том,  что  он  работает
правильно.
 Иногда  перед  тем,  как  начать  искать  ошибки,  необходимо  сде¬
лать  небольшой  перерыв.  Если  заниматься  программой  слишком
долго,  то  перестаешь  замечать  допущенные  оплошности.

Кстати,  если  ты  всерьез  увлечешься  изучением  программирова¬
ния,  ты  познакомишься  с  полезными  методами  избавления  от
ошибок.  Имеющиеся  в  продаже  версии  Visual  Basic  предлагают,
помимо  всего  прочего,  подробную  справочную  систему,  в  кото¬
рой  можно  найти  информацию  обо  всех  понятиях  и  операторах,
имеющихся  в  этом  языке.
 Мяч  продолжает  скакать
 Итак,  с  самыми  сложными  вопросами  мы  разобрались.  Теперь
посмотрим,  что  еще  должен  делать  мяч,  чтобы  быть  похожим  на
настоящий.
 Мяч  достигает  правого  края  формы...
 и  отскакивает  влево  вверх.

В  дальнейшем  описании  движения  мяча  следует  по-прежнему  помнить,
что  угол  его  падения  равен  углу  отражения.
 Программный  код  в  данном  случае  тот  же  самый,  что  и  выше,  но:
 • 	мы  говорим  о  правом,  а  не  о  нижнем  крае  формы;
 • 	вдоль  оси  X  мяч  начинает  двигаться  в  обратную  сторону  (справа
налево).
 Попробуй  самостоятельно  написать  соответствующую  строку  и  ввести
ее  в  программный  код.
 На  всякий  случай  приведу  для  сравнения  свое  решение:
 If  shpBall.Left  +  shpBall.Width)  >=  ScaleWidth  J
Then  XValue  =  -  XValue
 Таким  образом,  мы  сравниваем  значение  координаты  крайней  правой
точки  мяча  (суммы  значений  крайней  левой  координаты  и  ширины
мяча)  со  значением  координаты  правого  края  формы  и  изменяем
направление  движения  вдоль  оси  X  в  том  случае,  если  мяч  достигает
правого  края  формы.
 Наш  мяч  достигает  верхнего  края  формы,  отскакивает  и  меняет
направление  движения  вдоль  оси  Y,  то  есть  начинает  двигаться  вниз.  В
этой  строке  сравнивается  значение  его  свойства  Тор  с  нулевым
значением:
 If  shpBall.Top  <=  0  Then  YValue  =
 -  YValue

Ты  видишь  теперь  преимущества  работы  не  с  определенными
числами  (например,  90  или  75),  а  с  переменными?  Нам  не  важно,
какими  являются  текущие  значения  —  положительными  или  от¬
рицательными,  поскольку  мы  просто  меняем  их  знак  на  противо¬
положный.  Положительные  значения  становятся  отрицательны¬
ми,  и  наоборот.
 Кроме  того,  в  программном  коде  очень  часто  используются  зна¬
чения  скоростей  движения  мяча  по  горизонтали  и  вертикали.  Ес¬
ли  ты  решишь  использовать  для  них  другие  числа,  чтобы  уско¬
рить  или  замедлить  движение,  то  тебе  придется  внести  измене¬
ния  только  в  одном  месте,  а  не  во  всем  коде.
 И  в  завершение  проверяем,  достиг  ли  мяч  левого  края  формы:
 If  shpBall.Left  <=  0  Then  XValue  =  -  XValue
 Это  означает,  что  если  мяч  достигает  левого  края  формы  (нулевой
позиции),  то  он  отскакивает  (в  первый  раз  —  вниз)  и  начинает  двигаться
в  обратном  направлении  вдоль  оси  X.
 Введи  обе  эти  строки  в  программный  код.
 На  всякий  случай  приведу  целиком  весь  программный  код,
относящийся  к  таймеру:
 Private  Sub  tmrTimer_Timer()
 shpBall.Left  =  shpBall.Left  +  XValue
shpBall.Top  =  shpBall.Top  +  YValue
If  shpBall.Top  <=  0  Then  YValue  =  -  YValue
If  shpBall.Left  <=  0  Then  XValue  =  -  XValue
If  (shpBall.Top  +  shpBall.Height)  >=
ScaleHeight  Then  J
 YValue  =  -  YValue  'одной  строкой

If  (shpBall.Left  +  shpBall.Width)  >=
 ScaleWidth  Then  J
 XValue  =  -  XValue  'одной  строкой
 End  Sub
 Запусти  свою  программу  и  посмотри,  что  происходит.  Мяч  скачет
вдоль  и  поперек  по  экрану,  отражается  от  краев,  и  ведет  себя  так,  как
всамделишный.
 Несколько  небольших  заданий
 Предлагаю  тебе  два  задания,  которые  ты  должен  постараться  сделать
без  моей  помощи.
 В  начале  работы  приложения  мяч  движется  вниз  и  направо.  Попробуй
добиться  того,  чтобы  он  начинал  двигаться  налево  и  вверх.  При
решении  задания  советую  обратить  внимание  на  начальные  значения
переменных.
 Мне  кажется  несколько  неправильным  решением  то,  что  мяч  движется
через  командные  кнопки.  На  панели  инструментов  ты  найдешь  значок
Line  (Линия),  с  помощью  которого  можно  рисовать  прямые.  Проведи
в  форме  прямую  (воспользовавшись  значениями  свойств  X1/Y1  и
X2/Y2).  В  итоге  форма  принимает  следующий  вид:
 Теперь  постарайся  добиться  того,  чтобы  мяч  отскакивал  от
нарисованной  линии  (Line.YI).  Сделать  это  не  очень  просто,  но  ты  все-
таки  попробуй.

6. 	Объединение  переменных
 Прежде  всего,  поясню,  зачем  нужно  объединять  переменные.
 Допустим,  ты  хочешь  написать  приложение,  которое  работает  с  базой
данных,  содержащей  фамилии  твоих  друзей.  Фамилии  в  ней  можно
расположить  по  алфавиту  или  по  дням  рождения,  чтобы  не  забыть
поздравить  друзей.
 Создание  баз  данных  относится  к  числу  важнейших  задач,  с  которыми
сегодня  имеют  дело  профессиональные  программисты:  ни  одно
предприятие  не  обходится  без  каталога  клиентов  и  тому  подобных
вещей.
 В  этой  главе  ты  узнаешь:
 • 	что  такое  переменные  с  полями  или  массивы;
 • 	как  добавить  в  проект  вторую  форму;
 • 	в  чем  заключаются  основы  программирования  баз  данных;
 • 	чем  хорош  постфиксный  оператор;
 • 	еще  кое-что  о  переменных  и  их  области  определения;
 • 	зачем  нужны  модули;
 • 	что  такое  процедура.
 Кроме  того,  ты  познакомишься  с  основами  компьютерной  графики.

Допустим,  у  тебя  100  друзей,  фамилии  которых  ты  хочешь  внести  в
базу  данных.  Для  этого  требуется,  как  ты  уже  знаешь,  объявить
переменные.  Например,  таким  образом:
 Dim  Surnamel  As  String
Dim  Surname2  As  String
Dim  Surname3  As  String
 (Слово  surname  в  переводе  с  английского  означает  «фамилия».)
Вводить  все  фамилии  —  сумасшедшая  работа.  Подумай  только  о
предприятиях  с  тысячами  клиентов!  Помимо  того,  что  решение  данной
задачи  потребует  гигантских  затрат  труда,  все  введенные  таким
образом  фамилии  расположатся  без  связи  друг  с  другом.  Если  их
потребуется  отсортировать,  сделать  это  будет  очень  непросто.
 Что  такое  массив?
 Для  достижения  нашей  цели  должно  существовать  что-то  более
подходящее.  Необходимо  объединить  переменные  так,  чтобы
система  Visual  Basic  распознала  их  связь  друг  с  другом.
 Для  этого  существуют  так  называемые  массивы  (arrays)  или
переменные  с  полями.  В  массивах  несколько  переменных
объединяются  под  одним  именем,  а  для  того  чтобы  отличать  их
друг  от  друга,  используется  специально  добавленное  число.
 Объявление  массивов  выглядит  следующим  образом:
 Dim  Surname(99)  As  String
 Отличие  от  обычного  объявления  переменной  заключается  в  числе,
стоящем  в  скобках  за  ее  именем.  С  его  помощью  указывается,  что
Surname  является  массивом  и  может  содержать  100  элементов  типа
String.  Почему  100,  ведь  в  скобках  стоит  99?  Верно,  но  не  забывай,
что  компьютер  начинает  считать  с  нуля.  Первым  элементом  массива
является  Surname  (0),  вторым  —  Surname  (1)  и  т.д.

Если  тебе  хочется  начинать  счет  с  единицы,  объяви  переменную
таким  образом:
 Dim  Surname  (1  То  100)  As  String
 В  таком  случае  номер  в  скобках  будет  совпадать  с  реальным
номером  переменной.
 Обрати  внимание  на  то,  как  следует  обращаться  к  отдельному
элементу  массива:  вначале  пишется  имя  массива,  за  ним  в  скоб¬
ках  —  конкретный  номер  (так  называемый  индекс)  элемента  (то
есть  отдельной  переменной).
 Я  приведу  тебе  небольшой  пример.  Допустим,  ты  в  программе  работы
с  базой  данных,  состоящей  из  фамилий,  объявил  переменную  следую¬
щим  образом:
 Dim  Surname  (1  То  100)  As  String
 Тебе  необходимо  присвоить  первому  элементу  массива  некоторое  зна¬
чение  —  фамилию  друга.  Это  делается  так:
 Surname(1)  =  "Петров"
 Для  второго  элемента  строка  выглядела  бы  следующим  образом:
Surname(2)  =  "Петров"
 И  так  до  последнего  элемента  включительно.

Использование  массивов  облегчает  объявление  переменных.
Один-единственный  оператор  Dim  заменяет  множество  таких
операторов.  Его  использование  имеет  немало  и  других
преимуществ.  Допустим,  ты  ввел  100  фамилий  и  хотел  бы
вывести  их  все  на  экран  с  помощью  команды  Debug.Print.
Вместо  того  чтобы  100  раз  писать  Debug.Print,  достаточно
написать  короткий  цикл:
 For  I  =  1  То  100
 Debug.Print  Surname(I)
 Next  I
 Как  видишь,  такой  подход  очень  упрощает  жизнь.  Перейдем  к
примерам.
 Создай  новый  проект,  назови  форму  frmSurname  и  придумай
подходящий  заголовок,  например  Фамилии  или  что-то  в  этом  духе.
Растяни  форму  немного  в  ширину  и  в  высоту.
 Мы  могли  бы  сравнительно  легко  создать  программу  с  помощью
управляющего  элемента  ComboBox  (см.  соответствующий  раздел
главы  3).  Используя  свойство  Sorted  (Сортировка),  можно  было  бы
даже  расположить  фамилии  по  алфавиту.  Но  поскольку  мы  расширим
впоследствии  программу,  нам  будет  недостаточно  функциональных
возможностей  этого  элемента.  Необходимо  придумать  что-то  другое.
 Введи  в  форму  следующие  управляющие  элементы:
 Управляющий  элемент  Name
 Label
 TextBox
 CommandButton
 CommandButton
 CommandButton
 CommandButton
 Ibllnput
 txtlnput
 cmdApply
 cmdCancel
 cmdShow
 cmdEnd
 Caption/Text
 Фамилия
 (Пусто)
 &Применить
 &Отмена
 По&казать  список
&Выход

Увеличь  размер  шрифта  в  элементах  Label  и  TextBox.  Для  этого
выдели  поле  свойства  Font  и  укажи  размер  шрифта  10.
 Форма  должна  выглядеть  так:
 Теперь  подумаем  над  программным  кодом.  Мне  бы  хотелось,  чтобы
введенная  пользователем  фамилия  появлялась  в  списке  после  нажатия
кнопки  Применить.  Список  можно  просмотреть  с  помощью  кнопки
Показать  список.  Если  пользователь  нажмет  кнопку  Отмена,  то  поле
ввода  станет  пустым,  и  фамилия  не  будет  добавлена  в  список.  Нажатие
кнопки  Выход  приводит  к  завершению  работы  программы.
 Вторая  форма
 Мне  кажется,  что  для  того  чтобы  показывать  список  фамилий,  следует
открыть  отдельное  окно  (иначе  говоря,  еще  одну  форму),  в  которой,
нажимая  соответствующие  кнопки,  можно  будет  перемещаться  по
списку.

Во  вводном  примере  главы  2  уже  говорилось,  что  программа
может  состоять  из  нескольких  форм.  Для  того  чтобы  добавить  в
приложение  вторую  форму,  необходимо  выбрать  в  меню
Project  (Проект)  среды  Visual  Basic  команду  Add  Form
(Добавить  форму).  В  закладке  New  (Создать)  следует
подтвердить  значение  по  умолчанию  —  Form  (Форма).  После
этого  в  проект  добавится  форма.
 ^  Привожу  ниже  еще  одну  таблицу,  согласно  которой  тебе  следует
добавить  в  форму  управляющие  элементы:
 Упр.  элемент  Name
 Form
 Label
 CommandButton
 CommandButton
 CommandButton
 frmChoice
 IblOutput
 cmdForward
 cmdBack
 cmdTolnput
 Caption/Text  Прочее
 Список  фамилий
(Пусто)
 Borderstyle:
 1 	—  Fixed  Single
 Применить
 &Отмена
 По&казать  список
 Новая  форма

Для  того  чтобы  поместить  на  кнопки  стрелки,  как  в  форме  на  ри¬
сунке,  нужно  проделать  следующее.
 Щелкни  мышью  командную  кнопку  cmdForward,  чтобы  отобра¬
жаемые  в  окне  свойства  стали  относиться  к  этому  управляющему
элементу.  Вначале  необходимо  изменить  значение  свойства
Style  (Тип),  задав  его  равным  1  -  Graphical  (Графический).  Ина¬
че  поместить  на  кнопку  какое-нибудь  графическое  изображение
невозможно.  Затем  щелкни  мышью  поле  свойства  Picture.
 В  нем  появится  хорошо  знакомая  тебе  кнопка  с  многоточием.
Щелкни  ее  мышью,  чтобы  появилось  окно  для  выбора  файла.
 Войди  в  папку  GRAPHICS  /ICONS  /ARROWS,  чтобы  в  ней  выбрать
значок.  Для  кнопки  Вперед  я  указал  стрелку  из  файла  с  именем
ARW08RT.  ICO.  Ты,  разумеется,  можешь  выбрать  какое-нибудь
другое  изображение.
 То  же  самое  следует  проделать  и  для  кнопки  cmdBack.  Для  нее
я  выбрал  стрелку  из  файла  ARW08LT.  ICO.
 Мы  хотим,  чтобы  при  работе  приложения  в  поле  элемента  Label
появлялась  фамилия,  и  с  помощью  кнопок  Вперед/Назад  можно
было  бы  передвигаться  по  списку.  Сделаем  так,  чтобы  при  введении
пользователем  новой  фамилии  он  смог  возвратиться  в  главную  форму,
нажав  нижнюю  кнопку.
 Первый  вопрос:  как  сделать,  чтобы  при  нажатии  кнопки
Показать  список  на  экране  появилась  новая  форма?  Для
подобных  случаев  в  языке  Visual  Basic  существует  весьма
простой  оператор.  Он  называется  Show  («показать»).

Дважды  щелкни  мышью  кнопку  Показать  список,  чтобы  попасть  в
окно  программного  кода.
 Как  и  следовало  ожидать,  ты  увидишь  на  экране  хорошо  знакомый
каркас  программы:
 Private  Sub  cmdShow_Click()
 End  Sub
 Поскольку  требуется  вывести  форму  frmChoice,  наш  код  должен
выглядеть  так:
 f  rmCho  i  с  е.Show  vbModa1
 Постфиксный  оператор  ты  уже  хорошо  знаешь.  Но  что  означает
vbModal?  Строго  говоря,  в  данном  случае  писать  это  слово
необязательно.  Оно  указывает  на  то,  что  вызываемая  форма
модальная,  то  есть  необходимо  закрыть  ее,  прежде  чем  приступить  к
работе  с  другими  формами  (в  нашем  случае  —  формами  для  ввода).
Посмотри,  как  будет  выполняться  приложение  с  этим  словом  и  без
него,  и  выбери  понравившийся  вариант.
 Сразу  напишем  еще  одну  часть  программного  кода:
 Private  Sub  cmdEnd_Click()
 End
End  Sub
 Перейдем  к  ядру  программы.  Как  уже  было  сказано,  нам  пред¬
стоит  работать  с  массивами.  Следовательно,  если  пользователь
во  время  работы  приложения  вводит  фамилию  и  нажимает
кнопку  Применить,  то  эта  фамилия  сохраняется  в  переменной,
точнее  говоря,  в  элементе  массива.  Но  вначале  необходимо
объявить  данный  массив.  Пусть  он  может  включать  до  100  фа¬
милий.
 Введи  непосредственно  за  словами  Option  Explicit  следующую
строку:

Dim  Surname  (1  To  100)  As  String
 Позже  ты  увидишь,  что  с  использованием  такого  объявления  у  нас
возникнут  проблемы,  и  его  придется  изменить.  Однако  на  настоящий
момент  оно  нас  вполне  устраивает.
 На  рисунке  приведен  весь  программный  код  в  его  теперешнем
состоянии:
 Новая  форма
 Что  делать  дальше?  Допустим,  пользователь  запускает  наше
приложение  и  вводит  первую  фамилию.  Если  он  затем  нажмет
кнопку  Применить,  то  эта  фамилия  должна  записаться  в  первый
элемент  массива:
 Surname(1)  =  txtInput.Text
 Все  понятно?  Поле  для  ввода  фамилий  называется  txt  Input,  а
вводимый  пользователем  текст  является  значением  свойства
Text  и  записывается  в  первый  элемент  массива.
 Посмотрим,  что  произойдет,  если  пользователь  введет  вторую
фамилию  и  захочет  сохранить  ее.  Она  должна  сохраниться  во  втором
элементе  Surname  (2).  Но  мы  не  станем  каждый  раз  вводить  номер
элемента  массива  вручную,  поскольку  тогда  совершенно  пропадет  вся
выгода  от  использования  массива.  Следовательно,  необходимо  ввести
переменную-счетчик,  которая  будет  стоять  в  скобках  и  при  каждом

нажатии  кнопки  Применить  станет  увеличиваться  на  единицу.  При
этом  в  скобках  всегда  будет  указываться  правильный  номер  элемента
массива.
 Итак,  введи  в  разделе  объявлений  формы  непосредственно  за
объявлением  массива  следующую  строку:
 Dim  Number  As  Integer
 Соответствующая  процедура  должна  выглядеть  таким  образом:
 Private  Sub  cmdApply_Click()
 Number  =  Number  +  1
Surname(Number) 	= 	txtlnput.Text
 End  Sub
 Обрати  внимание  на  то,  что  увеличение  значения  переменной
Number  должно  происходить  перед  обращением  к  массиву.
Мы  начали  нумерацию  элементов  массива  с  1  (при  объявлении
его  было  указано:  1  То  100),  а  при  запуске  программы  пере¬
менной  Number  автоматически  присваивается  значение  0.  Для
того  чтобы  попасть  в  область  номеров  элементов  массива,  пе¬
ременная  уже  в  начале  процедуры  записи  фамилии  (и  каждый
раз  при  такой  процедуре)  должна  быть  увеличена.
 На  всякий  случай  повторю,  так  как  это  очень  важно:  при  запус¬
ке  программы  значение  переменной  Number  равно  нулю  —  так
полагается  в  языке  Visual  Basic.  Когда  пользователь  вводит  фа¬
милию  и  нажимает  кнопку  Применить,  вызывается  процедура
 Private  Sub  cmdApply_Click  ().  В  ней  мы  увеличиваем
значение  переменной  Number,  чтобы  оно  стало  равным  1.
 В  строке  кода
 Surname(Number)  =  txtlnput.Text
 мы  записываем  в  первый  элемент  массива  ту  фамилию,  кото¬
рую  ввел  пользователь.  Если  он  вводит  следующую  фамилию  и
нажимает  кнопку  Применить,  то  значение  переменной  Number

автоматически  увеличивается  и  становится  равным  2.  Следова¬
тельно,  новая  фамилия  записывается  во  второй  элемент  масси¬
ва  и  т.  д.
 Таким  образом  мы  постепенно  заполняем  весь  массив.  Нам  остается
только  добавить  в  процедуру  записи  фамилии  некоторые
дополнительные  штрихи.
 Прежде  всего,  запись  фамилии  в  массив  должна  производиться  только
в  том  случае,  если  пользователь  перед  нажатием  соответствующей
кнопки  действительно  ввел  какой-то  текст.  Иначе  массив  может
оказаться  пустым.  Факт  введения  фамилии  мы  будем  проверять  с
помощью  условного  оператора  if:
 Private  Sub  cmdApply_Click()
 If  txtlnput.Text  <>  ""  Then
Number  =  Number  +  1
Surname(Number)  =  txtlnput.Text
End  If
End  Sub
 Мы  уже  неоднократно  работали  с  символами  (<)  и  (>).  Комбина¬
ция  (<>)  означает  «больше  или  меньше»  —  иными  словами,  «не
равно».  Это  сравнение  используется  преимущественно  в  услов¬
ных  операторах,  как  в  нашем  случае.  Я  покажу  тебе  все  вариан¬
ты  сравнений  и  их  значение  в  следующей  таблице:
 < 	меньше
 <= 	меньше  или 	равно
 > 	больше
 >= 	больше  или 	равно
 = 	равно
 < 	> 	больше  или 	меньше
 Эти  символы  также  называют  операторами.

Допустим,  программа  должна  проверять,  имеет  ли  переменная  X  боль¬
шее  значение,  чем  Y.  Тогда  пишут  так:
 If  X  >  Y  Then  ...
 Таким  образом,  в  строке  программного  кода
 If  txtlnput.Text  о  ""  Then
 выясняется,  соблюдается  ли  условие  «не  равно»  для  строки  "  "  при
введении  пользователем  значения  в  txtlnput.  Символы  ("")  означа¬
ют,  что  замыкаемая  ими  строка  пуста.
 А  условие  «не  равно  пустой  строке»  означает,  что  пользователь  ввел  в
соответствующую  строку  фамилию  (или  другой  текст).
 Готов  признать,  что  сказанное  выше  сформулировано  довольно  слож¬
но,  однако  таковы  правила  языка  программирования  Visual  Basic,  и  им
необходимо  следовать.
 Есть  еще  одно  небольшое  обстоятельство,  которое  мне  не  нравится.
При  запуске  приложения  курсор  стоит  в  поле  ввода,  чтобы  можно  бы¬
ло  сразу  указать  фамилию.  Однако  после  нажатия  кнопки  Применить
курсора  в  этом  поле  уже  нет.  Кроме  того,  было  бы  лучше,  чтобы  после
нажатия  этой  кнопки  поле  ввода  становилось  пустым.  На  данный  мо¬
мент  в  нем  остается  введенная  фамилия.
 Так  выглядит  окно  нашего  приложения  после  нажатия  кнопки  Приме¬
нить:
 Запускаем
 приложение...

Видно,  что  фамилия  остается,  а  курсора  уже  нет.  И  то,  и  другое
необходимо  изменить.
 Для  того  чтобы  удалить  фамилию,  в  конце  условного  оператора  if
введи  следующую  строку:
 txtlnput.Text  =  "”
 С  помощью  этой  строки  мы  задаем  для  свойства  Text  нашего  поля
ввода  «пустое»  значение.
 Теперь  попробуем  вернуть  курсор  в  поле  ввода.
 Если  курсор  находится  в  каком-то  поле,  то  говорят,  что  оно  име¬
ет  фокус  (по-английски  focus).  Для  того  чтобы  установить  (по-
английски  to  set)  средствами  языка  Visual  Basic  фокус  в  опреде¬
ленное  место,  необходимо  использовать  следующую  команду  с
весьма  логичным  названием:
 SetFocus
 Эта  команда  соединяется  с  именем  элемента,  которому  назнача¬
ется  фокус,  с  помощью  хорошо  знакомого  тебе  постфиксного
оператора.  В  данном  случае  это  выглядит  так:
 txtlnput.SetFocus
 5-4111

Для  сравнения  приведу  полный  текст  программного  кода:
 У  тебя  он  тоже  выглядит  так?
 Запусти  программу  и  введи  несколько  фамилий.  Не  забывай  каждый
раз  нажимать  кнопку  Применить.  Кнопка  Выход  тоже  работает
правильно,  а  при  нажатии  кнопки  Показать  список  ты  попадаешь  во
вторую  форму.
 Если  же  ты  воспользуешься  кнопкой  Отмена,  то  никаких  действий  не
произойдет.  Это  естественно,  так  как  мы  еще  не  написали  для  нее  код.
Займемся  этим.
 Очистим  поле  ввода  и  вернем  ему  фокус.  Это  делается  так  же,
как  и  для  кнопки  Применить,  только  в  данном  случае  фамилия
не  записывается  в  элемент  массива,  и  не  увеличивается  значение
переменной  Number.  Такой  подход  вполне  логичен,  так  как
нажатием  кнопки  Отмена  пользователь  дает  понять,  что  он  не
хочет  принимать  введенную  фамилию.  Итак:
 Private  Sub  cmdCancel_Click()

txtlnput.Text  =  ""
txtlnput.SetFocus
End  Sub
 Таким  образом,  программирование  этой  формы  завершено.  Но
не  забудь,  что  я  тебе  сказал  ранее:  у  нас  еще  возникнут
трудности  с  объявлением  массива.
 При  нажатии  кнопки  Показать  список  на  экране  появится  окно
вывода,  но  в  нем  ты  не  увидишь  никакой  фамилии.  Исправим  такое
положение.
 При  открытии  этого  окна  должна  показаться  первая  фамилия  списка.
Поскольку  строка  вывода  второй  формы  (frmChoice)  имеет  имя
lblOutput,  а  текст  для  этой  строки  указывается  в  свойстве  Caption
элемента  Label,  то  было  бы  естественно  присвоить  данному  свойству
значение  первого  элемента  массива:
 lblOutput.Caption  =  Surname(1)
 Или  это  не  так?
 Введи  эту  строку  в  процедуру
 Private  Sub  cmdShow_Click()
 Тогда  эта  процедура  приобретет  следующий  вид:
 Private  Sub  cmdShow_Click()
 lblOutput.Capt  ion  =  Surname(1)
frmChoice.Show  vbModal
End  Sub
 Запусти  программу  и  нажми  кнопку  Показать  список.
 Система  Visual  Basic  не  согласна  с  нами.  Ты  увидишь  следующее
сообщение:

У  Visual  Basic  есть  повод  для  недовольства
Что  это  значит?  Ведь  мы  определили  все  переменные!
 Мы  добрались  до  очень  важной  вещи.  Ошибка  заключается  в
том,  что  Visual  Basic  ничего  не  может  сделать  с
lblOutput.  Caption,  —  элемент  lblOutput  находится  во
второй  форме  (frmChoice),  а  только  что  введенный  текст  про¬
граммного  кода  относится  к  первой  из  них  (f  rmSurname).
 Отсюда  мы  узнаём,  что  отдельные  формы  в  языке  Visual  Basic  не
связаны  друг  с  другом.  Они,  если  можно  так  выразиться,  не  зна¬
ют  друг  о  друге.
 Для  того  чтобы  обратиться  к  управляющим  элементам  и  их  свой¬
ствам,  принадлежащим  другой  форме,  используют  постфиксный
оператор.
 Перед  именем  управляющего  элемента  ты  должен  поставить  имя
формы,  в  которой  тот  находится.  Это  выглядит  так:
 frmChoice.lblOutput.Capt  ion.
 В  данном  выражении  постфиксный  оператор  встречается  целых  два  раза!
 Выводимый  на  экран  текст  должен  стоять  в  свойстве  Caption
элемента  lblOutput.  В  этом  месте  постфиксный  оператор  ис¬
пользуется  в  первый  раз.  Теперь  мы  должны  связать  выражение
 Microsoft  Visual  Basic

lblOutput  .Caption  с  формой,  к  которой  оно  относится,  то
есть  с  f  rmChoice.  Это  делается  также  с  помощью  постфиксно¬
го  оператора.  В  результате  возникает  двойной  постфиксный  опе¬
ратор.  Несколько  упрощая,  можно  было  бы  сказать  так:
Caption  —  это  составная  часть  lblOutput,  a  lblOutput  —
составная  часть  формы  frmChoice.  Данная  принадлежность
задается  с  помощью  постфиксного  оператора.
 Вся  процедура  в  целом  выглядит  так:
 Private  Sub  cmdShow_Click()
 frmChoice.lblOutput.Caption  =  Surname(1)
frmChoice.Show  vbModal
End  Sub
 Запусти  приложение,  введи  какую-нибудь  фамилию,  нажми  кнопку
Применить,  а  затем  —  кнопку  Показать  список.  Оно  работает!
 Поскольку  мы  занялись  формой  для  вывода,  измени  свойство  Font
элемента  lblOutput.  Я  предлагаю  задать  размер  шрифта  равным  10,
тогда  размер  фамилии  при  выводе  будет  таким  же,  как  и  при  вводе.
 Ты  вернешься  обратно  в  окно  ввода,  если  нажмешь  кнопку  с
изображением  крестика  в  правом  верхнем  углу  окна  вывода.
 Введи  вторую  фамилию,  нажми  кнопку  Применить,  а  затем  —  кнопку
Показать  список.
 Ты  увидишь,  что  по-прежнему  показывается  первая  фамилия.  Это
естественно,  так  как  ничего  другого  мы  и  не  запрограммировали.
 Во  второй  форме  имеются  две  кнопки  —  Вперед  и  Назад.  Для
них  мы  и  напишем  дальнейший  программный  код.
 Вернись  в  форму  frmChoice.

Если  у  тебя  оно  выглядит  иначе,  щелкни  мышью  знак  плюса,
находящийся  перед  словом  Forms.  Откроется  список  отдельных  форм.
 Теперь  в  окне  проекта  ты  видишь  обе  созданные  в  нашем
приложении  формы.  Дважды  щелкнув  мышью  название  формы,
ты  перейдешь  в  ее  окно.
 Теперь  в  окне  проекта  ты  видишь  обе  созданные  в  нашем  приложении
формы.  Дважды  щелкнув  мышью  название  формы,  ты  перейдешь  в  ее
окно.
 Но  вернемся  к  приложению.  Нам  требуется  написать  программный  код
для  кнопок  Вперед  и  Назад.
 Как  проще  всего  перейти  из  окна  одной  формы  проекта  в  окно
другой  формы?
 В  главе  2  ты  уже  видел  окно  проекта,  расположенное  в  правой
верхней  части  пользовательской  оболочки  Visual  Basic.  С
помощью  его  можно  переходить  из  окна  объекта  в  окно
программного  кода  и  обратно.  Посмотри,  как  данное  окно
выглядит  сейчас:

Дважды  щелкни  мышью  кнопку  Вперед.  Ей  мы  присвоили  имя
cmdForward.  Появившийся  каркас  программы  имеет  следующий
вид:
 Private  Sub  cmdForward_Click()
 End  Sub
 При  выполнении  программы  ты  ввел  первую  фамилию,  и  она  была  со¬
хранена  в  первом  элементе  массива  Surname  (1).
 Предположим,  что  мы  ввели  в  первой  форме  10  фамилий,  и  каждый
раз  нажимали  кнопку  Применить.  Тогда  все  10  фамилий  находятся  в
элементах  массива  Surname  (1)  .  .  .  Surname  (10).  Нам  требуется
метод,  который  позволил  бы  при  каждом  нажатии  кнопки  Вперед
представлять  эти  элементы  в  окне  вывода  один  за  другим.  Если,  напри¬
мер,  в  первом  элементе  массива  записано  «Ларин»,  то  данная  фамилия
появится  в  форме  для  вывода  в  окне  lblOutput.  Ранее  это  достига¬
лось  с  помощью  строки
 frmChoice.lblOutput.Caption  =  Surname(1)
 Если  теперь  пользователь  нажмет  кнопку  Вперед,  то  свойству
lblOutput.Caption  должно  быть  присвоено  значение  элемента
массива  Surname  (2).  Это  можно  сделать  так:
 lblOutput.Caption  =  Surname(2)
 Ты,  конечно,  обратил  внимание,  что  теперь  мы  не  пишем
 frmChoice.lblOutput.Caption  =  Surname(2)
 Так  происходит  потому,  что  мы  вводим  программный  код  уже  в
форме  fdmChoice.  В  ней  элемент  lblOutput,  естественно,
известен  (он  находится  в  ней).
 Но  такой  подход  не  годится,  так  как  нам  придется  при  следующем
нажатии  кнопки  Вперед  писать  Surname  (3)  и  т.д.  Подобную
операцию  практически  невозможно  реализовать.

Следовательно,  необходимо  ввести  переменную,  которая  при
нажатии  кнопки  Вперед  увеличивалась  бы  на  единицу,  а  при
нажатии  кнопки  Назад  —  уменьшалась  на  единицу.  Тогда
значение  переменной  всегда  будет  правильным.
 Объявим  эту  переменную,  как  всегда,  в  начале  кода  под  строкой
Option  Explicit.  Назовем  ее  просто  X  и  присвоим  начальное  зна¬
чение,  равное  1,  —  нумерация  элементов  массива  Surname  начинает¬
ся  с  1  и  продолжается  до  100.  Значения,  которые  должны  присваи¬
ваться  при  запуске  программы  или  при  открытии  формы,  задаются  в
процедуре  Form_Load.  В  ней  и  должна  быть  объявлена  новая  пере¬
менная.
 Объясню  тебе  сказанное  еще  раз.
 Дважды  щелкни  мышью  форму  frmChoice  в  свободном  от
управляющих  элементов  месте.  В  появившийся  каркас
программы  введи  следующую  строку:
 X  =  1
 Давай,  теперь  сравним  программный  код  для  формы  вывода.  У  меня
он  выглядит  следующим  образом:
 Это  только  начало..

Напишем  код  для  процедуры  cmdForward_Click.  Каждый  раз,
когда  пользователь  нажмет  эту  кнопку,  программа  должна  увеличить
на  1  значение  переменной  X  и  представить  в  поле  вывода  фамилию  из
соответствующего  элемента  массива.
 Введи  в  текст  данной  процедуры  следующие  строки:
 X  =  X  +  1
 lblOutput.Caption  =  Surname(X)
 Запусти  программу,  введи  две  фамилии  (каждый  раз  нажимая  кнопку
Применить),  перейди  в  форму  для  вывода  и  просмотри  имена  с
помощью  кнопки  Вперед.
 На  экране  снова  появится  сообщение  об  ошибке,  на  этот  раз  очень
странное:
 Microsoft  Visual  Basic
 Это  начинает  действовать  на  нервы
 Не  думай  о  своеобразной  формулировке,  используемой  системой
Visual  Basic.  Главное,  что  программа  хочет  этим  сказать  следующее:
«Visual  Basic  не  опознаёт  массив  Surname».
 А  ведь  я  предсказывал  тебе,  что  у  нас  возникнут  проблемы  с
объявлением  этого  массива...

Переменные  и  их  область  определения
 Почему  появилось  это  сообщение  и  что  можно  сделать  для
преодоления  препятствия?
 Для  того  чтобы  разобраться  в  данном  вопросе,  ты  должен  знать,
что  существуют  переменные  с  разными  областями  определе¬
ния.
 Если  ты  объявляешь  переменную  так,  как  мы  это  делали  до  сих
пор  (с  помощью  оператора  Dim),  то  ее  область  определения
ограничена.  Такую  переменную  называют  индивидуальной  (pri¬
vate  variable).
 Правило  гласит:  если  оператор  Dim  для  индивидуальной
переменной  стоит  в  декларативной  части  формы  (практически
это  означает,  что  он  находится  за  знакомым  нам  выражением
Option  Explicit),  то  эта  переменная  определена  в  пределах
всего  программного  кода,  относящегося  к  данной  форме.
 Если  же  оператор  Dim  стоит  внутри  процедуры  (начинающейся
словами  Private  Sub),  то  она  определена  только  внутри
указанной  процедуры.
 Для  того  чтобы  ты  действительно  разобрался  в  системе  областей  опре¬
деления,  рассмотрим  пример.  Как  ты,  наверное,  догадываешься,  мы
снова  будем  работать  с  оператором  Debug.  Print.  Для  тестирования
программы  он  незаменим.
 Сохрани  приложение  Фамилии  и  создай  новый  проект.  Помести  в
форму  командную  кнопку.
 Введи  следующий  код:
 Option  Explicit
 Dim  X  As  Integer  'Оператор  Dim  в
декларативной  части

Private  Sub  Form_Load()
 Dim  Y  As  Integer 	'Оператор  Dim  внутри
 процедуры
End  Sub
 Private  Sub  Commandl_Click()
 X  =  10
 Debug.Print  X 	'Выполняется
 End  Sub
 Тебе  все  понятно?  На  всякий  случай  поясню.
 В  процедуру  Private  Sub  Form_Load  ты  попадешь,  дважды
щелкнув  мышью  форму.  В  процедуру  Private  Sub
Commandl_Click  можно  попасть,  дважды  щелкнув  мышью  ко¬
мандную  кнопку.  Надеюсь,  ты  помнишь,  что  значок  апострофа
перед  текстом  означает,  что  этот  текст  —  комментарий  для  луч¬
шего  понимания  программы.  Его  можно  не  писать  или  заменить
своим.
 После  запуска  приложения  ты  увидишь  в  окне  отладки  число  10.  Таким
образом,  программа  работает,  потому  что  переменная  X  была  введена
в  декларативную  часть.
 Добавь  в  процедуру  Commandl_Click  следующее  выражение:
 Y  =  20
 Запусти  программу  и  нажми  кнопку.  Появится  сообщение  об  ошибке,
указывающее  на  то,  что  переменная  не  определена.
 Надеюсь,  теперь  ты  понимаешь,  почему  так  получилось.  Пере¬
менная  Y  была  введена  в  одну  процедуру,  и  поэтому  она  не  опре¬
делена  в  другой  процедуре.

Возможно,  тебе  непонятно,  почему  нельзя  объявить  все
переменные  в  декларативной  части  формы  и  решить  тем  самым
возникшие  проблемы?
 В  небольшом  разобранном  нами  примере  действительно
безразлично,  где  вводить  переменные  —  внутри  процедуры  или  в
декларативной  части  формы.  Но  представь  себе  программу  с
большим  числом  управляющих  элементов  и  процедур.  Тебе
понадобится  очень  много  переменных.  Кроме  того,  велика
опасность,  что  будет  потеряна  наглядность,  и  ты  забудешь
назначение  некоторой  переменной  в  декларативной  части  и  то,
где  она  используется.  Поэтому  действует  общее  правило:
объявлять  переменные  по  возможности  локально,  то  есть  внутри
процедуры.  И  только  в  том  случае,  если  переменная
используется  в  разных  частях  программы,  ее  следует  объявлять
вне  процедур,  в  самом  начале  программы.  Однако  ты  еще
увидишь,  что  и  в  таких  случаях  существуют  более  элегантные
решения.
 Однако  проблема  с  областями  определения  еще  не  разрешена.  Что
если  переменная  должна  определяться  и  использоваться  сразу  в
нескольких  формах,  как  в  нашем  приложении  Фамилии?
 Строго  говоря,  это  был  исходный  пункт  наших  размышлений.  То,  что
массив  Surname  не  был  принят  системой  Visual  Basic  во  второй  форме
(frmChoice),  по-видимому,  связано  с  тем,  что  мы  объявили  его  в
первой  форме  (frmSurname).
 Проверим  это  с  помощью  программы-примера.
 Добавь  в  проект  вторую  форму.  Ты  помнишь,  как  это  делается?
Правильно,  необходимо  выбрать  в  меню  Project  команду  Add  Form,
а  затем  в  появившемся  диалоговом  окне  подтвердить  значение  по
умолчанию  Form,  нажав  клавишу  Enter.

Вызови  с  помощью  командной  кнопки  первой  формы  вторую  форму  и
посмотри,  определена  ли  в  ней  переменная  X.
 Я  предлагаю  использовать  для  первой  формы  следующий  код:
 Ты  видишь,  что  в  него  внесены  только  два  изменения.  Прежде  всего,  я
закомментировал  строку  Y  =  20.
 Подобное  комментирование  очень  важно  при  разработке
программ.  Тебе  уже  знаком  символ  комментария  (').  Однако  его
можно  использовать  не  только  для  написания  пояснений  к
программе,  но  и  для  того,  чтобы  исключить  из  нее  отдельные
строки,  не  удаляя  их  окончательно  из  текста  программного  кода.
Когда  есть  сомнения  в  том,  что  некоторая  часть  приложения
работает  правильно,  этот  метод  очень  полезен.
 Кроме  того,  я  с  помощью  команды
 Form2.Show
вызвал  вторую  форму:

Мы  присвоили  переменной  X  только  одно  значение.  Надо  заметить,  что
эта  программа  служит  только  для  проверки.  Полученные  результаты
мы  сможем  успешно  применить  в  приложении  Фамилии.
 Итак,  запусти  программу.  Нажми  командную  кнопку.  Появится  вторая
форма,  и  снова  будет  выдано  знакомое  нам  сообщение  об  ошибке.
Вторая  форма  не  опознает  переменную  X,  так  как  она  была  объявлена
в  первой  форме.  С  данной  проблемой  мы  столкнулись  в  приложении
«Фамилии»,  но  теперь  мы  точно  знаем,  в  чем  она  заключается.
 Потребность  в  модуле
 Итак,  мы  должны  найти  метод,  который  бы  позволил  объявить
переменную  так,  чтобы  она  было  определена  в  нескольких  фор¬
мах,  то  есть  во  всем  проекте.
 То,  о  чем  сейчас  пойдет  речь,  будет  хотя  и  новым  для  тебя,  но  не  слиш¬
ком  сложным.  Выполни  следующие  действия:
 В  первой  форме  закомментируй  строку  объявления
 Dim  X  As  Integer
 Ты  помнишь,  что  для  этого  нужно  всего  лишь  поставить  перед  ней  сим¬
вол  комментария,  —  результат  будет  таким,  как  если  бы  этой  строки  во¬
обще  не  было.

Выбери  в  меню  Project  команду  Add  Module  (Добавить  модуль)  и
подтверди  значение  по  умолчанию  Module  (Модуль).  На  экране
появится  следующий  код:
 Так  выглядит  модуль
 Но  что  такое  модуль?  Это  часть  программы,  которая  содержит
только  код.  Она  совершенно  не  видна  для  пользователя  во  время
выполнения  приложения.  Данный  код  может  состоять  из
переменных  или  из  других  частей  программы  —  пример  тому  ты
еще  увидишь  в  программе  «Фамилии».
 Модуль  —  это  место,  в  котором  следует  объявить  переменную  X.
Обрати  внимание  на  то,  что  в  нем  не  используется  обычный
оператор  Dim,  вместо  которого  пишут:
 Public  X  As  Integer
 Слово  Public  (в  переводе  с  английского  оно  означает  «общедоступ¬
ный»)  означает,  что  указанная  переменная  должна  быть  определена  во
всей  программе.
 Введи  эту  строку  в  модуль.
 Запусти  программу.  Ты  увидишь,  что  при  нажатии  командной  кнопки
вызывается  вторая  форма,  и  сообщения  об  ошибке  не  появляется.
Сработало!

Давай,  еще  раз  вернемся  к  сказанному,  так  как  оно  очень  важно
при  написании  крупных  приложений.
 Используемые  во  всей  программе  переменные  должны  быть
объявлены  в  особом  модуле,  причем  не  с  помощью  оператора
 Dim,  a  Public.
 Мне  кажется,  что  бессмысленно  долго  думать  о  том,  почему  это
так,  а  не  иначе.  Необходимо  принять  данное  правило  как
особенность  языка  Visual  Basic  и  соблюдать  его.
 Мы  совершили  длительную  экскурсию  в  мир  областей  определения.
Мы  многое  узнали  и  теперь  можем  устранить  ошибку  в  приложении
«Фамилии».  Ты  понял,  в  чем  она  заключается?  А  как  от  нее
избавиться?
 Для  того  чтобы  исправить  ошибку,  убери  из  первой  формы
(f  rmSurname)  объявление
 Dim  Surname  (1  То  100)  As  String
 Эту  строку  можно  либо  удалить,  либо  просто  закомментировать.
 Вместо  нее  нам  понадобится  модуль.  Выбери  в  меню  Project  команду
Add  Module  и  подтверди  значение  по  умолчанию  (Module),  нажав
клавишу  Enter.
 В  окне  свойств  модуля  укажи  имя.  Я  выбрал  SurnameModule.
 Посмотри  на  окно  проекта.
 Ты  увидишь  следующее:

Помимо  обеих  форм,  имеющихся  в  программе,  в  нем  теперь  присутст¬
вует  и  модуль.
 Объяви  в  модуле  массив.  Не  забывай,  что  при  этом  следует  использо¬
вать  слово  Public.  Итак:
 Public  Surname  (1  То  100)  As  String
 Как  ты  вскоре  увидишь,  переменные  X  и  Number  также  будут  задейст¬
вованы  во  всех  частях  проекта.  Поэтому  убери  соответствующее  объ¬
явление  из  frmSurname  и  объяви  их  как  Public  в  модуле:
 Public  Number  As  Integer
Public  X  As  Integer
 Модуль  должен  выглядеть  следующим  образом:
 Запусти  приложение  «Фамилии»  и  введи  пару  фамилий  (не  забывай
нажимать  кнопку  Применить),  а  затем  перейди  в  окно  вывода.
 Ты  видишь,  что  с  помощью  кнопки  Вперед  можно  просматривать  все
введенные  фамилии  по  очереди.  Программа  работает!
 Поскольку  компьютерная  программа  никогда  не  бывает  доделанной
(именно  поэтому  производители  игр  постоянно  выпускают  скорректи¬
рованные  версии  и  «заплаты»),  на  горизонте  появляется  следующая
проблема.
 Пользователь  может  нажимать  кнопку  Вперед  сколько  угодно  и
даже  после  того,  как  будут  просмотрены  все  имеющиеся
фамилии.  В  результате  в  программе  может  возникнуть  сбой.

Следовательно,  нам  нужно  постараться  придумать,  как  сделать  :■*
так,  чтобы  дальнейший  просмотр  списка  фамилий  был  возможен
только  в  случае,  если  в  нем  еще  имеются  не  просмотренные
фамилии.
 Номер  того  элемента  массива,  который  выведен  на  экран  в
настоящий  момент,  записан  в  переменной  X  (ты  помнишь:
Surname  (X)),  которая  постоянно  обновляется  при  нажатии
кнопки  Вперед.  Общее  число  введенных  фамилий  хранится  в
переменной  Number  и  обновляется  при  нажатии  кнопки
Применить.
 Если  у  тебя  остались  вопросы,  посмотри  еще  раз  на  текст  обеих
процедур.  При  каждом  нажатии  кнопки  Применить  число  вве¬
денных  фамилий  увеличивается  на  1  и  запоминается  в  перемен¬
ной  Number.  В  переменной  X,  напротив,  запоминается,  какая  фа¬
милия  в  настоящий  момент  показана  в  форме  для  вывода.
 Итак,  значения  переменных  X  и  Number  должны  сравниваться  между
собой,  и  дальнейший  просмотр  с  помощью  кнопки  Вперед  допускается
только  до  тех  пор,  пока  X  меньше,  чем  Number.  Когда  значение  X  совпа¬
дет  со  значением  Number,  будет  достигнут  последний  элемент  массива,
и  дальнейшее  нажатие  кнопки  Вперед  станет  бессмысленным.
 Следовательно,  необходимо  воспользоваться  хорошо  знакомым  тебе
условным  оператором  if.
 После  внесения  изменений  процедура  выглядит  следующим  образом:
 Private  Sub  cmdForward_Click()
 If  X  <  Number  Then
X  =  X  +  1
 lblOutput.Caption  =  Surname(X)
 End  If
End  Sub

Теперь  я  приведу  текст  всего  программного  кода  для  обеих  форм
модуля  в  исправленном  виде:
 Программный  код  для  формы  frmSurname
 Программный  код  для  формы  frmOutput

Программный  код  для  формы  frmOutput
 Итак,  все  готово.  Остальное  уже  несложно.  Нам  следует  только
написать  код  для  просмотра  списка  фамилий  в  обратном  направлении.
Он  выглядит  так:
 Private  Sub  cmdBack_Click()
 If  X  >  1  Then
X  =  X  -  1
 lblOutput.Caption  =  Surname(X)
 End  If
End  Sub
 Мне  кажется,  что  нет  необходимости  подробно  пояснять  этот  код.  С
помощью  переменной  X  мы  обозначаем  показываемый  в  настоящий
момент  элемент  массива.  До  тех  пор  пока  эта  величина  больше  1,
имеется  еще,  по  крайней  мере,  один  элемент  списка,  расположенный
перед  текущим  элементом.  Поэтому  просмотр  списка  в  обратном
направлении  возможен.  Но  по  достижению  значения  1  мы  доходим  до
первого  элемента  массива,  и  дальше  просматривать  нечего.
 Остается  еще  написать  программный  код  для  кнопки  В  окно  ввода.
При  ее  нажатии  форма  для  вывода  должна  исчезать,  а  фокус  —
переходить  на  поле  ввода  первой  формы.
 В  готовом  виде  код  выглядит  следующим  образом:
 Private  Sub  cmdToInput_Click()
frmChoice.Hide
 frmSurname.txtlnput.SetFocus
End  Sub

Назначение  оператора  Hide  (это  слово  по-английски  означает
«скрыть»)  заключается  в  том,  чтобы  форма  исчезла  с  экрана.
При  этом  ее  имя  и  оператор  Hide  соединены  друг  с  другом
постфиксным  оператором.
 Оператор  SetFocus  тебе  уже  известен.  Мне  кажется,
использование  двойного  постфиксного  оператора  тоже  не
должно  вызывать  у  тебя  вопросов:  перед  нами  форма  для
выбора,  тогда  как  нам  требуется  обратиться  к  другой  форме
(frmSurname).  Поэтому  впереди  постфиксного  оператора  мы
ставим  ее  имя.
 И  в  завершение  еще  небольшое  дополнение.  Оно  необязательно  для
нашего  приложения,  но  с  ним  оно  станет  намного  красивее  и
профессиональнее.  А,  кроме  того,  мы  узнаем  еще  кое-что  очень
важное.
 Работа  с  процедурами
 Прежде  всего,  я  хотел  бы  объяснить  тебе,  чего  на  мой  взгляд  не
хватает  в  нашем  приложении.  Ведь,  как  уже  было  сказано,
окончательно  проработанной  компьютерной  программы  не  бывает
никогда.  Всегда  найдется  что-то,  что  можно  было  бы  улучшить.
 Допустим,  пользователь,  нажимая  кнопку  Назад,  добрался  до  первого
элемента  массива.  Мы  составили  приложение  так,  что  дальнейшее
продвижение  невозможно  (ты  помнишь,  что  теперь  значение
переменной  X  равно  1).  И  если  пользователь  все-таки  нажмет  еще  раз
кнопку  Назад,  то  никаких  действий  не  произойдет.  Однако  его  никто
не  проинформирует  о  том,  почему  программа  перестала  реагировать
на  нажатие  кнопки.  То  же  самое  произойдет  и  в  том  случае,  если  будет
достигнута  последняя  запись  в  массиве,  а  пользователь  продолжит
нажимать  кнопку  Назад.  Программа  должна  выдать  ему  сообщение  о
том,  что  происходит.  Для  этого  можно  было  бы  использовать  окно

сообщений.  Но  приложение  будет  выглядеть  лучше,  если  кнопка
Вперед  или  Назад  перестанет  быть  активной.  Тогда  опытный
пользователь  поймет,  что  дальнейшие  нажатия  ни  к  чему  не  приведут.
 Для  того  чтобы  ты  смог  представить  себе,  как  выглядит  форма  для
выбора  с  неактивной  кнопкой  Назад,  взгляни  на  следующий  рисунок:
 Кнопка  Назад  больше  не  работает
 Щелкни  мышью  в  окне  объекта  (это  окно,  в  котором  мы,  в  отличие  от
окна  программного  кода,  видим  форму  со  всеми  ее  управляющими
элементами)  кнопку  Вперед  или  Назад  и  посмотри  на  окно  свойств.
Ты  найдешь  свойство  Enabled,  значение  которого  равно  True.  В
зависимости  от  того,  какое  значение  имеет  это  свойство  —  True  или
False,  соответствующий  управляющий  элемент  активен  либо
неактивен.  Но  мы  будем  управлять  этим  свойством  не  с  помощью  окна
свойств,  а  используя  код,  так  как  обе  наши  кнопки  (в  зависимости  от
ситуации)  могут  быть  активными  или  неактивными.
 Как  работать  в  программном  коде  со  свойствами  управляющего
элемента?  Повторю  еще  и  еще  раз:  с  помощью  постфиксного
оператора.
 Итак,  чтобы  в  форме  frmChoice  управляющий  элемент
cmdBack  стал  неактивным,  мы  должны  написать  следующее:
 frmChoice.cmdBack.Enabled  =  False

А  когда  в  нашей  программе  эта  кнопка  должна  стать  неактивной?  В
тот  момент,  когда  пользователь  достигает  первого  элемента  массива,
поскольку  тогда  движение  прекращается.  А  первый  элемент  массива
достигается  тогда,  когда  переменная  X  в  процедуре  cmdBack
становится  равной  1.  На  всякий  случай  мы  предположим,  что  X  может
иметь  нулевое  значение,  то  есть  быть  меньше  1.  Итак,
 If  X  <=  1  Then
 frmChoice.  cmdBack.  Enabled  =  False
End  If
 Однако  данный  вариант  программы  не  годится,  так  как  в  нем  значение
Enabled  всегда  остается  равным  False,  даже  если  пользователь
нажмет  кнопку  Вперед  и  X  увеличится.  Следовательно,  необходим
альтернативный  вариант,  вводимый  словом  Else:
 If  X  <=  1  Then
 frmChoice.cmdBack.Enabled  =  False
 Else
 frmChoice.cmdBack.Enabled  =  True
End  If
 Прежде  чем  мы  займемся  кнопкой  Вперед,  подумаем,  в  какое  место
кода  лучше  всего  поместить  эту  конструкцию.
 Проблема  заключается  в  том,  что  данный  фрагмент  кода  будет
использоваться  в  разных  частях  программы.  Во-первых,  уже
тогда,  когда  мы  вызовем  форму  для  выбора  с  помощью  кнопки
Показать  список,  мы  должны  решить,  должна  ли  кнопка
cmdBack  быть  активной  или  нет.  То  же  должно  происходить  при
каждом  нажатии  кнопок  Вперед  и  Назад.
 Таким  образом,  данный  фрагмент  кода  должен  быть  доступен  во
всем  проекте.  Напоминает  это  требование  тебе  что-нибудь?
Правильно,  такая  же  ситуация  была  с  переменными,  которые
должны  были  определяться  во  всей  программе  (прежде  всего,
массив  фамилий).
 Эти  переменные  мы  объявили  в  особом  модуле.  И  именно  в  него
мы  вставим  команды  для  определения  значения  свойства
Enabled.

Войди  в  текст  программного  модуля  (для  этого  нужно  в  окне  проекта,
расположенном  на  экране  справа  вверху,  дважды  щелкнуть  мышью
модуль).
 В  нем  мы  напишем  процедуру.  Это  слово  я  уже  часто  использовал  в
книге,  не  объясняя  точно,  что  оно  означает.  Настало  время  дать
разъяснение.  Выбери  в  меню  Tools  (Сервис)  команду  Add  Procedure
(Добавить  процедуру).  Ты  увидишь  следующее  окно:
 Введи  имя  процедуры,  а  остальное  оставь  как  есть
 Прежде  чем  заполнять  эту  форму,  мы  выясним,  что  же  такое
процедура.
 Процедура  —  это  отдельная  замкнутая  часть  программы,  выпол¬
няющая  определенную  задачу.
 Слишком  абстрактно?  Тогда  подумай  над  следующим  фрагментом
кода:
 Private  Sub  cmdEnd_Click()
 End
End  Sub
 Правильно,  это  процедура.  Ее  также  называют  подпрограммой.  А  так
как  приставка  sub  по-английски  означает  «под»,  становится  понятным,
почему  в  заголовке  стоит  слово  Sub.

И  вообще,  все  разделы  кода,  которые  открывались  после
двойного  щелчка  мышью  по  управляющего  элемента,  являются
процедурами.  Так  что  тебе  это  понятие  знакомо.  Новым  является
только  то  обстоятельство,  что  бывают  также  процедуры  без
относящегося  к  ним  управляющего  элемента.  Как  раз  сейчас
мы  начнем  писать  такую  процедуру.
 Но  довольно  теории,  вернемся  к  нашей  программе.  В  поле  Name  фор¬
мы  Add  Procedure  введи  какое-нибудь  конкретное  имя,  например
 ButtonActive.
 Посмотрим  на  остальную  часть  данной  формы.  В  ней  указана  ячейка
Sub  —  как  ты  знаешь,  это  слово  означает  «процедура»,  следовательно,
выделенная  ячейка  нам  и  нужна  (на  остальные  возможности  пока  не  об¬
ращай  внимания).  Кроме  того,  эта  форма  предоставляет  возможность
задать  область  определения.  Мы  можем  выбирать  между  типами
Private  и  Public.  Так  как  процедура  должна  быть  доступной  во  всей
программе,  мы  оставляем  выбор  по  умолчанию  (то  есть  Public).  Заме¬
чу,  что  все  написанные  до  сих  пор  процедуры,  которые  были  связаны  с
управляющими  элементами,  ограничивались  размерами  формы  и  имели
тип  Private.  Поэтому  в  их  заголовке  и  стояло  это  слово.  Будем  счи¬
тать,  что  заголовок  процедуры  тебе  стал  окончательно  понятен.
 Итак,  оставь  форму  такой  как  она  есть,  введя  только  имя  процедуры.
Нажми  кнопку  ОК,  и  ты  увидишь,  как  изменится  модуль:
 Введи  имя  процедуры,  а  остальное  оставь  как  есть

В  нем  появилась  рамка  для  процедуры,  в  которую  можно  ввести
текст  кода.  Введи  в  него  условный  оператор  if  -  else,
который  мы  написали  ранее.  Если  он  будет  стоять  в  этом  месте,
все  части  программы  смогут  к  нему  обратиться,  что  и  требуется.
 Введи  программный  код.
 Далее  мы  запишем  в  ту  же  процедуру  код,  который  делает  неактивной
кнопку  Вперед  в  том  случае,  если  достигнута  последняя  фамилия.
 Ты  знаешь,  что  количество  запомненных  фамилий  (то  есть
сохраненных  пользователем  в  массиве  с  помощью  кнопки
Применить)  записано  в  переменной  Number.  Поэтому  необходимо
сравнить  значение  переменной  X  со  значением  Number.  Если  они
будут  одинаковы,  или  X  станет  больше,  дальнейшее  продвижение
станет  невозможно:  конец  массива  уже  достигнут.  С  этого  момента
кнопка  Вперед  становится  неактивной.  Итак:
 If  X  >=  Number  Then
 frmChoiсe.cmdForward.Enabled  =  False
 Else
 frmChoice.cmdForward.Enabled  =  True
End  If
 Для  сравнения  я  приведу  тебе  еще  раз  весь  текст  модуля  целиком:

Запусти  программу,  и  ты  увидишь,  что  ничего  не  изменилось.  Де¬
ло  в  том,  что  обычные  процедуры  выполняются,  когда  пользова¬
тель  щелкает  мышью  соответствующий  управляющий  элемент.  В
данном  случае  такого  элемента  нет.
 Дело  в  том  (внимание:  очень  важный  момент!),  что  процедура
должна  вызываться  непосредственно  из  программного  кода,  для
чего  в  нужном  его  месте  следует  написать  ее  имя  (без  скобок).
 Следовательно,  вызов  процедуры  осуществляется  таким  образом:
 ButtonActive
 Вспомни,  что  мы  собирались  вызывать  данную  процедуру  всякий
раз  при  вызове  формы  для  выбора  и  при  каждом  нажатии  кнспок
Вперед  и  Назад.
 Принято  говорить,  что  всякий  раз  при  вызове  формы  она  становится
активной.  При  этом  происходит  событие  Activate.  В  процедуре  с
именем  Form_Activate  можно  написать  команды,  которые  станут
всегда  выполняться  при  вызове  данной  формы:  такая-то  переменная
должна  принять  такое-то  значение,  такая-то  процедура  должна  быть
выполнена  и  т.д.
 Для  того  чтобы  попасть  в  эту  процедуру,  войди  в  окно  кода,
относящегося  к  форме  frmChoice.  В  строке  под  заголовком  нажми
расположенную  слева  кнопку  со  стрелкой  и  выбери  в  открывшемся
списке  Form.  Нажми  расположенную  справа  кнопку  со  стрелкой  и
выбери  Activate  (Активировать).
 Строка  заголовка  должна  выглядеть  таким  образом:
 Заголовок  формы  для  выбора

В  окне  кода  появится  каркас  соответствующей  процедуры.
 Из  него  мы  вызовем  процедуру  ButtonActive.  Кроме  того,  давай,
зададим  для  переменной  X  значение  1,  чтобы  в  начале  просмотра
всегда  показывалось  первое  имя,  и  система  Visual  Basic  не  сбилась  со
счета.
 Код  этой  процедуры  выглядит  следующим  образом:
 Private  Sub  Form_Activate()
 X  =  1
 ButtonActive
End  Sub
 Далее,  организуем  вызов  процедуры  ButtonActive  из  процедур
Forward  и  Back.  Они  выглядят  так:
 Private  Sub  cmdForward_Click()
 If  X  <  Number  Then
X  =  X  +  1
 lblOutput.Caption  =  Surname(X)
 End  If
 ButtonActive 	'  Новая  строка
 End  Sub
 Private  Sub  cmdBack_Click()
 If  X  >  1  Then
X  =  X  -  1
 lblOutput.Caption  =  Surname(X)
 End  If
 ButtonActive 	'  Новая  строка
 End  Sub
 Вот  теперь  в  программе,  кажется,  уже  нечего  улучшать.
 Часто  начинающего  программиста  ошеломляет  огромное  мно¬
жество  возможностей,  которые  предлагает  такая  система  разра¬
ботки  программ,  как  Visual  Basic.  Он  не  ощущает  уверенности  в
своих  силах  и  не  решается  взяться  за  создание  собственных  про¬
ектов.

Существует  весьма  действенный  метод  преодоления  этого
барьера:  необходимо  писать,  писать  и  писать  программы.  На
первых  порах  вовсе  необязательно  создавать  такие  широко
задуманные  проекты,  как  наше  приложение  для  работы  с
фамилиями,  —  достаточно  и  небольших  учебных  программ.
Постепенно  у  тебя  появится  навык,  и  ты  осмелишься  взяться  за
более  сложные  вещи.  Даже  если  что-то  не  будет  получаться,  не
отчаивайся  и  помни  добрую  старую  пословицу  «Не  боги  горшки
обжигают».
 Несколько  небольших  заданий
 Измени  наше  приложение  так,  чтобы  оно  работало  не  с  фамилиями
(переменными  типа  String),  а  с  числами.
 Следующее  задание  посложнее.  Напиши  программу,  которая
определяет,  делятся  ли  введенные  пользователем  пять  чисел  на  3  и
затем  выводит  результаты  в  полях  пяти  элементов  Label  во  второй
форме.
 Небольшой  совет:  тебе  понадобится  массив  из  пяти  элементов.
Определить,  делится  ли  число  на  3,  ты  сможешь  с  помощью  команды
mod:
 For  X  =  1  То  5
 If  Number(X)  mod  3=0  Then  ...
 Next  X

7. 	Создание  собственных
типов  данных
 Ты  уже  знаешь,  что  такое  тип  данных.  Начиная  с  главы  4,  мы  много  раз
пользовались  такими  типами,  как  Integer,  String.  Помимо  проче¬
го,  они  требуются  при  объявлении  переменных,  например:
 Dim  X  As  Integer
 Ты  спросишь:  зачем  снова  возвращаться  к  прежней  теме?  Разве  недо¬
статочно  тех  типов  данных,  которые  предоставляет  нам  Visual  Basic?
Сейчас  ты  увидишь,  что  большие  программы  не  могут  обойтись  без  са¬
мостоятельно  созданных  типов  переменных.
 В  этой  главе  ты  узнаешь:
 • 	почему  обычных  типов  данных  не  всегда  достаточно;
 • 	что  такое  определенный  пользователем  тип  данных,  и  чем  он
полезен  в  работе;
 • 	кое-что  еще  о  программировании  баз  данных.

База  данных  увеличивается
 Вспомни  о  приложении  «Фамилии».  Думаю,  ты  понял  на  его  примере
полезность  использования  массивов.  Без  них  мы  практически  не  были
бы  в  состоянии  написать  подобную  программу,  поскольку  потребова¬
лись  бы  непомерные  затраты  труда.
 И,  тем  не  менее,  я  все-таки  недоволен  этим  приложением.  Что  это  за
программа,  которая  работает  только  с  фамилиями?  К  личным  данным
о  человеке  относятся  еще  и  другие  сведения:  имя,  дата  рождения,  ад¬
рес  и  т.  д.
 Напишем  такое  приложение,  которое  работало  бы  и  с  фамилиями,  и  с
именами.  Если  ты  захочешь  добавить  еще  какие-нибудь  сведения,  —
пожалуйста,  добавляй.  После  прочтения  главы  это  не  составит  для
тебя  труда.
 Добавить  имена  к  фамилиям  несложно.  Объявим  в  нашем  модуле  еще
один  массив,  например,  таким  образом:
 Public  Firstname(l  То  100)  As  String
 (First  name  по-английски  означает  «имя»).
 Но  при  этом  мы  столкнемся  с  трудностями.  Если  ты  введешь  имя  и  фа¬
милию,  то  они  не  свяжутся  друг  с  другом,  и  после  сортировки  програм¬
мой  фамилий  имена  останутся  нетронутыми.  В  итоге  у  внесенных  в  спи¬
сок  людей  окажутся  другие  имена  ...
 Объединение  переменных
 Объединим  имя  и  фамилию  в  единое  целое.  Для  этого  придется
создать  собственный  тип  данных.  На  языке  программистов  его
называют  определенным  пользователем  типом  данных  (user-
defined  data  type),  так  как  он  не  существует  в  таком  виде  в  языке,
и  его  конструируют,  ориентируясь  на  определенные  нужды  поль¬
зователя.

Как  создать  собственный  тип  данных?  Я  приведу  тебе  пример,
подходящий  для  нашего  случая:
 Type  Name
 Firstname  As  String
Surname  As  String
End  Type
 С  помощью  ключевого  слова  Туре  мы  создаем  собственный  тип
данных,  равноценный  имеющимся  в  языке  Visual  Basic  типам
данных  (integer,  String  и  т.д.).
 В  нашем  случае  этот  тип  состоит  из  двух  частей  (Firstname  —
имя  и  Surname  —  фамилия).  Обе  имеют  тип  String.  Никаких
ограничений  не  накладывается:  в  него  вводится  сколько  угодно
составных  частей,  и  они  могут  иметь  различные  типы.  В  этой
связи  ты  должен  запомнить  два  обстоятельства.
 Во-первых,  оператор  Туре  должен  обязательно  находиться  в
модуле.  Если  мы  станем  расширять  приложение  «Фамилии»,  то
сможем  воспользоваться  ранее  созданным  модулем.
 Во-вторых  (и  это  гораздо  важнее),  Name  является  типом  данных
(как  Integer  или  String).  Это  не  переменная.  Ее  еще  следует
объявить.  Например,  так:
 Dim  MyName  As  Name
 Она  объявляется  так  же,  как  переменная  типа  Integer:
 Dim  MyValue  As  Integer
 А  как  обратиться  к  составным  частям  такого  типа  данных  (в  нашем
случае  к  Firstname  и  к  Surname)?  Думаю,  что  ты  уже  догадался.
Правильно,  с  помощью  постфиксного  оператора.  Например,  таким
образом:
 MyName.Firstname  =  "Сергей"
 6-4111

Объясню  еще  раз:  с  помощью  оператора  Туре  создается  новый
тип  данных.  Затем  ты  объявляешь  переменную  этого  типа  и
используешь  конструкцию  «Имя  переменной  —  постфиксный
оператор  —  элемент  типа  данных»  для  обращения  к  составной
части  данной  переменной.
 Создай  новый  проект  и  помести  в  форму  командную  кнопку.
 ^  Непосредственно  под  строкой  Option  Explicit  введи  оператор
Туре  с  Firstname  и  Surname  в  качестве  составных  частей,  как  я
только  что  показал  тебе.  В  такой  небольшой  программе  это  в  виде
исключения  можно  сделать  не  в  отдельном  модуле.
 ^  Объяви  переменную  MyName  типа  Name:
 ^  Внутри  процедуры:
 Private  Sub  Commandl_Click()
 End  Sub
 введи  следующие  строки:
 MyName.Firstname  =  "Сергей"
 MsgBox  "Имя:"  +  MyName.FirstName
 Введенный
код  должен
выглядеть
так:

Запусти  программу,  нажав  кнопку  F5.  Ты  увидишь,  что  она
исполняется:
 Расширение  программы
 После  знакомства  с  основами  мы  можем  заняться  расширением  не¬
большой  базы  данных.
 Ты,  конечно,  помнишь  из  предыдущей  главы,  что  мы  использовали
массив.  Он  состоял  из  элементов  типа  String,  в  которые  записыва¬
лись  фамилии.  Сейчас  нам  потребуется  массив  из  переменных  опреде¬
ленного  пользователем  типа.  А  именно:
 Public  MyName  (1  То  100)  As  Name
 Name  —  определенный  пользователем  тип,  и  мы  объявляем  массив  из
переменных  данного  типа.  Делается  это  точно  так  же,  как  в  предыду¬
щей  главе,  —  в  модуле  с  помощью  ключевого  слова  Public.  Кстати,
тебе  необязательно  начинать  с  самого  начала.  Достаточно,  если  ты
внесешь  соответствующие  изменения  в  приложение  «Фамилии».  На
всякий  случай  сохрани  новую  программу  под  другим  именем  (лучше
всего  в  отдельной  вложенной  папке  на  жестком  диске).
 Ты  помнишь,  как  сохраняется  программа?  Если  нет,  перечитай
раздел  «Первая  программа»  в  главе  2.

Прежде  всего,  мы  изменим  обе  формы.  Они  должны  выглядеть
следующим  образом:
 Я  назвал  первую  форму  frmlnput  и  задал  в  качестве  заголовка
(Caption)  Фамилии.  Теперь  требуется  уже  не  один,  а  два  управляю¬
щих  элемента  TextBox,  один  для  фамилий  (txtSurname),  другой  —
для  имен  (txtFirstname).  Кроме  того,  нам  понадобится  элемент
Label  с  заголовком  Имя.  Все  прочее  остается,  как  прежде.

В  форме  для  выбора  также  изменяется  не  очень  много.  В  нее
необходимо  поместить  два  элемента  Label  —  lblFirstname  и
lbl  Surname.
 Обрати  внимание,  что  имена  некоторых  управляющих  элементов
изменились  по  сравнению  с  прежним  вариантом  программы.  Те¬
бе  тоже  лучше  было  бы  использовал  новые  имена,  —  это  помог¬
ло  бы  избежать  путаницы.
 Изменения  в  программном  коде
 Обратимся  к  новому  программному  коду.  Прежде  всего,  займемся
модулем.  Единственное,  но  весьма  существенное  изменение  в  нем
заключается  в  том,  что  теперь  мы  станем  работать  с  пользовательским
типом  данных,  и  потому  введем  соответствующий  массив.
 Внеси  в  модуль  необходимые  изменения.  Он  будет  выглядеть  так
(отличия  от  старой  версии  помечены  в  тексте  во  избежание  ошибок):
 Option  Explicit
 '  Public  Surname  (1  To  100)  As  String  -
закомментировано!
 Type  Name 	1 	Это  новая  строка
 Firstname  As  String
Surname  As  String
End  Type
 Public  MyName  (1  To  100)  As  Name  'Это  новая  строка
Public  Number  As  Integer 	'Далее 	все
 'остается  без  изменений
 Public  X  As  Integer

Public  Sub  ButtonActive()
 If  X  <=  1  Then
 frmChoice.cmdBack.Enabled  =  False
 Else
 frmChoice.cmdBack.Enabled  =  True
End  If
 If  X  >=  Number  Then
 frmChoice.  cmdForward.  Enabled  =  False
 Else
 frmChoice.cmdForward.Enabled  =  True
End  If
End  Sub
 Как  скажутся  сделанные  изменения  на  остальной  программе?
 В  форме  для  ввода  имен  придется  вместо  одного  элемента  txtlnput
делать  различие  между  двумя  элементами  txtFirstname  и
txt  Surname.  Этот  момент  я  объясню  на  примере  кнопки  Отмена.
 Дважды  щелкни  мышью  эту  кнопку,  чтобы  войти  в  текст  программного
кода,  и  измени  его  следующим  образом:
 Private  Sub  cmdCancel_Click()
txtFirstname.Text  =  ""
txtSurname.Text  =  ""
txtFirstname.SetFocus
End  Sub
 Поясню  данный  фрагмент  кода.  При  прерывании  пользователем  ввода
имени  соответствующие  поля  обоих  элементов  TextBox  должны  очис¬
титься,  поэтому  в  них  записывается  пустая  строка.  Фокус  помещается
на  элемент  txtFirstname,  так  как  он  является  первым  полем  ввода
программы.
 Код  для  командной  кнопки  Выход,  естественно,  остается  без  измене¬
ний.  Некоторые  коррективы  требуется  внести  в  процедуру  записи  име¬
ни  в  базу  данных.  Для  большей  наглядности  я  приведу  и  старый,  и  но¬
вый  варианты  процедуры.  Вначале  старый  вариант:

Private  Sub  cmdApply_Click()
 If  txtlnput.Text  <>  ""  Then
Number  =  Number  +  1
Surname(Number)  =  txtlnput.Text
txtlnput.Text  =  ""
txtlnput.SetFocus
 End  If
End  Sub
 Напомню,  что  означает  старый  вариант.  Вначале  проверяется,
была  ли  в  соответствующее  поле  введена  фамилия.  Если  да,  то
количество  введенных  фамилий  (переменная  Number)
увеличивается  на  единицу,  и  в  следующий  элемент  массива
записывается  содержимое  строки  ввода.  Затем  поле
очищается  для  введения  новой  фамилии,  и  на  него  помещается
фокус.
 Привожу  новый,  измененный  вариант  той  же  процедуры:
 Private  Sub  cmdApply_Click()
 If  txtFirstname.Text  <>  ""  And  txtSurname.  J
Text  <>  ""  Then 	' 	одной  строкой!
 Number  =  Number  +  1
MyName(Number).Firstname  =  J
txtFirstname.Text
 MyName(Number).Surname  =  txtSurname.Text
txtFirstname.Text  =  ""
txtSurname.Text  =  ""
txtFirstname.SetFocus
End  If
End  Sub
 На  всякий  случай  я  подробно  объясню,  что  означает  новый  вариант.

Условный  оператор  if  позволяет  вносить  новую  запись  в  базу
данных,  только  если  введены  и  имя,  и  фамилия.
 Кроме  того,  вместо  элемента  массива  Surname  (Number)  в  базу
данных  записываются  два  элемента,  составляющих  переменную
 MyName(Number).
 Затем  фокус  возвращается  в  первое  поле  ввода.
 И  небольшое  замечание.  Всегда  можно  как-то  улучшить  внешний
вид  программы.  Обрати  внимание,  что  размер  шрифта  в  поле
ввода  имен  еще  не  был  должным  образом  изменен.  Сделай  это
самостоятельно!
 В  форме  для  ввода  отсутствует  только  фрагмент  кода,  относящийся  к
кнопке  Показать  список.  В  нем  должен  записываться  первый  элемент
массива  в  поле  вывода  второй  формы,  а  затем  осуществляться  ее
вызов.  Ранее  этот  код  выглядел  таким  образом:
 Private  Sub  cmdShow_Click()
 frmChoice.lblOutput.Caption  =  Surname(1)
frmChoice.Show  vbModal
End  Sub
 Его  необходимо  изменить.  С  учетом  того,  что  lblFirstname  и
lblSurname  —  имена  элементов  Label,  в  которых  выводятся
соответственно  имя  и  фамилия,  новый  код  получится  таким:
 Private  Sub  cmdShow_Click()
 frmChoice.lblFirstname.Caption  =  J
MyName(1).Firstname
 frmChoice.lblSurname.Caption  =  J
MyName(1).Surname
 frmChoice.Show  vbModal
End  Sub

Прежний  код  для  кнопки  Вперед  выглядел  так:
 Private  Sub  cmdForward_Click()
 If  X  <  Number  Then
X  =  X  +  1
 lblOutput.Caption  =  Surname(X)
End  If
 Bu11  onAc  t  ive
End  Sub
 Это  означает  следующее:  до  тех  пор  пока  не  достигнут
последний  элемент  массива,  при  нажатии  данной  кнопки
переменная-счетчик  увеличивается  на  1,  и  выводится  следующая
фамилия.  Затем  вызывается  процедура  ButtonActive,
которая  определяет,  какой  должна  быть  кнопка,  —  активной  или
неактивной.
 При  изменении  данного  фрагмента  кода  необходимо  учитывать  только
то,  что  теперь  мы  работаем  с  двумя  составными  частями  имени.
Поэтому  новый  код  выглядит  таким  образом:
 Private  Sub  cmdForward_Click()
 If  X  <  Number  Then
X  =  X  +  1
 lblFirstname.Caption  =  MyName(X).Firstname
lblSurname.Caption  =  MyName(X).Surname
End  If
 ButtonActive
End  Sub
 Мне  кажется,  что  пояснений  не  требуется.  Поэтому  привожу  процедуру
для  кнопки  Назад  (и  на  этом  работа  с  программой  заканчивается):

Private  Sub  cmdBack_Click()
 If  X  >  1  Then
X  =  X  -  1
 lblFirstname.Caption  =  J
MyName(X).Firstname
 1ЫSurname.Caption  =  MyName(X)  .Surname
End  If
 ButtonActive
End  Sub
 При  нажатии  кнопки  В  окно  ввода  форма  для  вывода  должна  исчез¬
нуть  с  экрана  (для  этого  используется  команда  Hide),  и  фокус  поме¬
щается  в  поле  элемента  txtFirstname  формы  ввода.  Соответствую¬
щий  код  выглядит  так:
 Private  Sub  cmdToInput_Click()
frmChoice.Hide
 frmlnput.txtFirstname.SetFocus
End  Sub
 Процедура  Form_Activate  остается  без  изменений:
 Private  Sub  Form_Activate()
 X  =  1
 ButtonActive
End  Sub
 И  в  заключение,  задай  в  окне  свойств  формы  ввода  для  свойства
Tablndex  (Переход  по  клавише  табуляции)  элемента  txtFirstname
значение  0,  а  для  элемента  txtSurname  —  значение  1.  Тогда  при  за¬
пуске  программы  фокус  автоматически  установится  в  поле  элемента
txtFirstname,  а  при  нажатии  клавиши  табуляции  курсор  перейдет  в
поле  ввода  фамилий,  как  и  происходит  в  профессионально  написан¬
ных  программах.
 Обрати  внимание,  сколько  преимуществ  дало  нам  то,  что  мы  работали
на  основе  ранее  созданной  программы,  а  не  начинали  с  самого  начала.
Существует  общая  рекомендация  для  создания  крупных  программ.

При  написании  большой  программы  со  многими  функциями  все¬
гда  начинай  с  основных  функций  и  добивайся  того,  чтобы  они  ра¬
ботали  правильно.  Дополнительные  функции  достраивай  уже  с
помощью  основных,  используя  для  этого  копию  базовой  про¬
граммы.  Тогда,  если  что-то  не  будет  получаться,  ты  всегда  смо¬
жешь  вернуться  к  исходному  варианту.
 Несколько  небольших  заданий
 Если  пользователь  не  ввел  либо  имя,  либо  фамилию  (либо  и  то,  и  дру¬
гое),  то  при  нажатии  кнопки  Применить  никаких  действий  не  произой¬
дет.  Так  составлена  программа,  потому  что  нет  смысла  сохранять  в
массиве  пустые  записи.  Однако  пользователь  не  будет  проинформиро¬
ван  о  том,  почему  так  случилось.  Такое  поведение  программы,  которая
всегда  должна  быть  дружественной  к  пользователю,  не  считается  нор¬
мой.  Создай  окно  сообщения  (MessageBox),  в  котором  пользователю
бы  объяснялось,  что  он  сделал  неправильно.
 Кроме  того,  фокус  не  возвращается  в  поле  ввода  имени,  если  пользо¬
ватель,  не  введя  либо  имени,  либо  фамилии,  нажимает  кнопку  Приме¬
нить.  Исправь  этот  недостаток.

8. 	Меню
 Сейчас  мы  уже  можем  писать  настоящие  программы  под  Windows.  Од¬
нако  для  типичного  для  этой  операционной  системы  интерфейса  в  них
все  еще  кое-чего  не  хватает,  а  именно  —  меню,  которые  располагают¬
ся  у  верхнего  края  окна.  В  пользовательской  оболочке  Visual  Basic
имеется  подобная  строка  меню  с  наборами  команд:
 File  Edit  View  Project  Format  Debug  Run  Query  Diagram  Tool$  Add-Ins  Window?
 С  этой  строкой  меню  мы  работаем  уже  давно
 Посмотрим,  как  создавать  меню.  Мы  напишем  по-настоящему  полез¬
ное  приложение,  а  именно  —  небольшой  текстовый  редактор.  Он,  ко¬
нечно,  не  будет  таким  мощным,  как  редактор  Microsoft  Word,  но  уж  на¬
верняка  более  простым  в  использовании.
 В  этой  главе  ты  узнаешь:
 • 	как  написать  приложение  —  небольшой  текстовый  редактор;
 • 	кое-что  еще  о  свойствах  и  их  изменении  в  программном  коде;
 • 	что  программисты  понимают  под  меню;
 • 	как  работать  с  принтером;
 • 	что  такое  функции,  и  чем  они  отличаются  от  процедур;
 • 	как  использовать  функцию  InputBox.

На  начальном  этапе  разработки  любого  программного  продукта,
как  ты  знаешь,  необходимо  определить  его  возможности.  Итак,
чего  мы  хотим  от  текстового  редактора?
 Прежде  всего,  он  должен  позволять  вводить  текст,  сохранять  и
распечатывать  его,  а  также  загружать  уже  имеющиеся  тексты  и
работать  с  ними.
 Он  должен  предоставлять  возможность  пользователю  выбирать
различные  размеры  шрифтов,  а  также  задавать  подчеркивание  и
тип  начертания  шрифта:  обычный,  полужирный,,  курсив.  Этими
возможностями  сегодня  располагает  любой  текстовый  редактор.
 Кроме  того,  подобное  приложение  обладает  массой  возможнос¬
тей  для  внесения  дальнейших  изменений.  Если  в  конце  этой  гла¬
вы  у  тебя  будут  другие  идеи  по  ее  расширению,  реализуй  их  —
лучшее  упражнение  трудно  представить.
 Как  всегда,  мы  начнем  с  задания  внешнего  вида  программы.
 Создай  новый  проект  и  назови  форму  frmTextEditor  (Text  Editor
по-английски  означает  «текстовый  редактор»).  Значение  свойства
Caption  должно,  прежде  всего,  содержать  название  редактора.  Назо¬
вем  его  Мой  редактор.
 Как  правило,  в  строке  заголовка  текстового  редактора  пишут  также  на¬
звание  текста,  обрабатываемого  в  текущий  момент.  Поскольку  никако¬
го  текста  нет,  используем  следующий  заголовок:  Мой  Редактор  -
БезымянныйОО.
 Обычно  окно  текстового  редактора  занимает  весь  экран,  в  то  время
как  наши  прежние  приложения  работали  в  окнах  меньшего  размера.
 В  окне  свойств  имеется  и  такое,  которое  позволяет  определить  размер
окна  программы.  Оно  называется  WindowState  (Состояние  окна)  и

может  принимать  значения  Normal  (Нормальное),  Minimized
(Свернутое)  и  Maximized  (Развернутое).  Выбери  вариант  Maximized.
После  того  как  ты  задашь  это  значение,  на  экране  не  произойдет
никаких  изменений.  Однако  после  запуска  программы  ты  увидишь,  что
форма  заполнит  весь  экран.
 Обработка  текста  происходит  не  в  форме,  а  в  поле  управляющего
элемента  TextBox.  Для  его  свойств  задай  следующие  значения:
 Свойство
 Name
 MultiLine
 Text
 ScrollBars
 Значение
 txtTextWindow
 True
 (Пусто)
 3-Both
 Свойство  MultiLine  позволяет  вводить  текст,  состоящий  более  чем  из
одной  строки.  Значение  З-Both  (Обе  линейки)  свойства  ScrollBars
указывает,  что  в  элементе  TextBox  могут  быть  две  полосы  прокрутки:
горизонтальная  и  вертикальная.  Это  значение  также  необходимо  для
работы  с  текстом.
 Не  забывай  время  от  времени  сохранять  программу.  Лучше
всего,  если  ты  создашь  для  нее  отдельную  папку,  в  которой
будешь  хранить  и  проект,  и  форму.
 На  данном  этапе  работы  возникает  первая  проблема.  Поле  элемента
TextBox  должно  занимать  всю  свободную  поверхность  формы
независимо  от  того,  как  пользователь  станет  изменять  ее  размер
(значение  Maximized  свойства  WindowState  является  только
предварительной  настройкой).
 С  помощью  окна  свойств  это  не  удастся:  мы  не  знаем,  какой  размер
следует  задать.  Поэтому  придется  написать  программный  код.

Проще  всего  разобраться  с  левым  верхним  углом  поля  элемента
TextBox.  Задать  положение  этого  угла  можно  с  помощью
свойств  Тор  и  Left.  Если  выбрать  в  качестве  значения  обоих
свойств  нулевое,  то  данный  угол  совпадет  с  левым  верхним  углом,
формы.  Поскольку  так  должно  быть  всегда,  мы  зададим  эти  зна¬
чения  при  запуске  программы.  Какую  процедуру  следует  исполь¬
зовать?  Правильно,  Form_Load.  Войти  в  нее  можно,  дважды
щелкнув  мышью  форму  (frmTextEditor)  в  свободном  от  уп¬
равляющих  элементов  месте.
 Итак:
 Private  Sub  Form_Load()
 txtTextWindow.Top  =  О
txtTextWindow.Left  =  0
End  Sub
 Несколько  сложнее  задать  высоту  и  ширину  поля  элемента  TextBox.
Они  должны  согласоваться  с  размерами  формы.  А  ее  высоту  и  ширину
задают  свойства  ScaleHeight  и  ScaleWidth  соответственно  (ты
знаешь  их  из  примера  программы  «Игра  в  мяч»).
 Если  ты  все  же  забыл  их,  посмотри  главу  5.  В  ней  мы  с  помощью
цикла  организовывали  движение  мяча  до  краев  формы.  При  этом
его  текущее  положение  сравнивалось  со  значениями  свойств
ScaleWidth  и  ScaleHeight  формы.
 В  данном  случае  нам  не  нужен  цикл  —  мы  зададим  ширину  поля  эле¬
мента  TextBox  равной  значению  свойства  ScaleWidth  (то  есть  шири¬
не  формы  frmTextEditor),  а  высоту  —  значению  свойства
ScaleHeight.  Итак:
 txtTextWindow.Width  =  ScaleWidth
txtTextWindow.Height  =  ScaleHeight
 Почему,  записывая,  например  frmTextEditor  .ScaleWidth  для
свойства  ScaleWidth,  не  требуется  указывать,  к  какому  объекту  оно
относится?  Дело  в  том,  что  если  в  системе  Visual  Basic  в  программном

коде  не  указан  объект,  к  которому  относятся  свойства,  они  считаются
свойствами  текущей  формы,  а  не  какого-либо  управляющего  элемен¬
та.  Конечно,  можно  написать  frmTextEditor  .ScaleWidth,  но  это
не  обязательно.
 Позаботимся  о  том,  чтобы  каждый  раз,  когда  пользователь  менял
размер  формы,  размер  элемента  TextBox  изменялся  соответственно.
При  таком  условии  эти  команды  нельзя  поместить  в  процедуру
Form_Load,  так  как  она  выполняется  лишь  однажды  —  при  запуске
программы,  и  не  реагирует  на  последующие  события.
 Что  делать,  если  тебе  нужна  какая-то  процедура,  но  ты  не  зна¬
ешь,  как  она  называется?  Войди  в  окно  программного  кода  и  вы¬
бери  в  левом  раскрывающемся  меню  элемент  Form.  В  правом
раскрывающемся  меню  перечислены  все  доступные  процедуры.
Исходя  из  их  названий,  можно  выбрать  ту,  которая  требуется.
 Это  меню  выглядит  так:
 Любая  процедура  на  выбор.
 7-4111

Что  выбрать?  Процедура  должна  реагировать  на  изменение  размера
формы.  В  списке  имеется  процедура  Resize  (Изменение  размера).  Она
нам  и  требуется.
 Щелкни  мышью  название  этой  процедуры  в  списке,  и  в  окне  кода
появится  соответствующий  каркас  программы.
 Введи  в  данной  процедуре  приведенные  выше  строки  кода.
 Программный  код  должен  выглядеть  следующим  образом:
 Запусти  программу  и  попробуй  изменить  размер  формы.  Ты  увидишь,
что  размер  поля  элемента  TextBox  всегда  изменяется  соответственно.
 Создание  меню
 После  того  как  приготовления  завершены,  мы  можем  заняться  меню.
Для  его  создания  среда  Visual  Basic  предоставляет  прекрасное
вспомогательное  средство,  а  именно  —  Menu  Editor  (Редактор  меню).
Познакомимся  с  ним  поближе.
 Перейди  в  окно  объекта  и  выбери  в  пункте  меню  Tools  команду  Menu
Editor.  На  экране  появится  следующее  окно:

Окно  редактора  меню
 Введи  в  поле  Caption  окна  редактора  меню  &Файл.  Это  слово  (с
подчеркнутой  первой  буквой)  ты  позже  увидишь  в  программе.
 Задай  имя  для  обращения  к  данному  пункту  меню,  например  mnuFile
(mnu  означает,  что  указываемое  имя  относится  к  пункту  меню).
 Этот  пункт  меню  сразу  же  отобразится  в  нижней  части  окна  редактора
меню.  Таким  образом,  ты  можешь  следить  за  тем,  как  оно  строится.
 Окно  редактора  меню  на  этом  этапе  выглядит  так:
 Первый  пункт  меню

Нажми  в  редакторе  кнопку  ОК.  Его  окно  исчезнет,  а  в  окне  объекта
появится  строка  меню  с  пунктом  Файл.
 Но  меню  необходимо  расширить.  Вызови  еще  раз  редактора.  Мы
создадим  подменю  для  меню  Файл.
 Какие  пункты  должны  быть  в  этом  подменю?  Открой  для  сравнения  в
каком-нибудь  текстовом  редакторе  меню  Файл.  Нам  обязательно
понадобятся  пункты  Создать,  Открыть,  Сохранить,  Печать  и  Выход.
Можешь  придумать  и  другие  команды,  но  затем  не  забудь  для  них
написать  программный  код.
 Нажми  в  редакторе  меню  кнопку  Next  (Далее)  и  введи  в  поле  Caption
строку  &Создать,  а  в  поле  Name  —  mnuNew.
 Если  оставить  все  как  есть,  то  Создать  будет  отдельным  пунктом,
расположенным  в  строке  меню  правее  пункта  Файл.  Для  того  чтобы
сделать  его  пунктом  подменю,  нажми  кнопку  с  направленной  вправо
стрелкой,  расположенную  в  средней  части  окна  редактора.  В
результате  этот  пункт  подменю  в  окне  редактора  сдвинется  вправо.
 Введи  следующие  пункты  меню  (после  ввода  каждого  из  них  нажимай
кнопку  Next):
 &Открыть 	mnuOpen
 Со&хранить 	mnuSave
 &Печать 	mnuPrint
 mnuSeparate
&Выход 	mnuExit
 Думаю,  в  таблице  тебе  непонятен  лишь  выбор  имени  mnuSeparate.
Для  него  в  качестве  заголовка  Caption  введи  знак  тире.  В  результате
команда  меню  Выход  расположится  отдельно  от  остальных  (слово
separate  означает  «отделять»).

Окно  редактора  меню  должно  при  этом  выглядеть  так:
 Готовое  меню  Файл
 Для  сравнения  на  следующем  рисунке  изображено  данное  меню  в
раскрытом  виде:

В  середине  формы  находится  элемент  TextBox.  Он  выглядит  не
так,  как  требуется,  но  это  не  важно:  его  действительные  размеры
и  положение  задаются  в  программном  коде.
 Вторым  пунктом  главного  меню,  расположенным  рядом  с  пунктом
Файл,  должен  быть  Формат  (имя  —  mnuFormat).  При  его  вводе  в  ок¬
не  редактора  меню  нажми  кнопку  с  направленной  влево  стрелкой,  что¬
бы  отнести  его  к  главному  меню.  Команды  подменю  снова  сдвинь  впра¬
во  относительно  названия  меню.
 Подменю  должно  содержать  следующие  пункты:
 &Размер  шрифта
Полу&жирный
&Курсив
Под&черкивание
 mnuFontSize
 mnuBold
 mnultalic
 mnullnderline
 Окно  редактора  меню  выглядит  таким  образом:

Для  сравнения  посмотри,  как  выглядит  меню  Формат  в  раскрытом
виде  в  окне  объекта:
 Запусти  программу.  Ты  увидишь,  что  при  выборе  того  или  иного  пунк¬
та  главного  меню  раскрываются  подменю.  Но  при  указании  команд
подменю  никаких  действий  не  происходит,  —  так  и  должно  быть,  пото¬
му  что  мы  пока  их  не  запрограммировали.
 Напишем  код.  Начнем  с  самого  простого  пункта,  то  есть  с  выхода  из
приложения.
 В  окне  объекта  укажи  команду  подменю  Выход.  Откроется  окно  про¬
граммного  кода,  в  котором  ты  увидишь  следующее:
 Private  Sub  mnuEnd_Click()
 End  Sub
 Как  ты  знаешь,  в  данном  коде  необходимо  написать  команду  End.  За¬
пусти  программу,  и  ты  увидишь,  что  при  выборе  команды  Выход  про¬
грамма  действительно  завершит  работу.
 Итак,  ты  разобрался  в  принципах  работы  редактора  меню.  Остается
лишь  написать  по  данному  образцу  код  для  всех  остальных  пунктов  ме¬
ню  нашего  текстового  редактора.

Новые  конкуренты  корпорации
Майкрософт
 Займемся  написанием  программного  кода  для  отдельных  пунктов  ме¬
ню  текстового  редактора.
 При  выборе  команды  Создать  должно  открыться  новое  окно  (то  есть
еще  один  элемент  TextBox),  причем  пользователю  следует  предоста¬
вить  возможность  переходить  из  одного  окна  в  другое.  Поскольку  на
данном  этапе  эта  задача  для  нас  слишком  сложная,  ограничимся  очи¬
сткой  поля  элемента  TextBox,  чтобы  пользователь  смог  заново  ввести
текст.
 Такой  подход  чреват  неприятностями:  случайный  выбор  ко¬
манды  Создать  приведет  к  тому,  что  весь  ранее  введенный
текст  уничтожится.  Позднее  ты  увидишь,  как  можно  решить  эту
проблему,  выдав  пользователю  соответствующее  предупреж¬
дение.
 Как  очистить  поле  элемента  TextBox,  ты  уже  знаешь  из  предыдущей  гла¬
вы.  Напомню,  что  для  этого  нужно  задать  в  качестве  значения  для  свой¬
ства  Text  управляющего  элемента  txtTextWindow  пустую  строку.
 Выбери  команду  Создать.  В  появившийся  каркас  программы  введи
следующую  строку:
 txtTextWindow.Text  =
 Запусти  программу  и  введи  какой-нибудь  текст  (можно  и  бессмыслен¬
ный,  он  все  равно  будет  уничтожен),  а  затем  укажи  команду  Создать.
Окно  элемента  TextBox  очистится,  и  введенный  тобой  текст  безвоз¬
вратно  исчезнет.

Займемся  пунктом  меню  Печать.  Вначале  я  приведу  текст  кода,  а
потом  мы  обсудим  его:
 Printer.Print  txtTextWindow.Text
Printer  EndDoc
 Разберемся  в  том,  что  эти  строки  означают.
 Printer  по-английски  означает  «принтер».  С  помощью  команды
Print  принтеру  дается  задание  напечатать  что-либо.  Обрати
внимание  на  постфиксный  оператор.  По  достижении  конца
документа  (EndDoc)  должна  начаться  его  распечатка.
 Однако  желательно  принять  некоторую  предосторожность.  Распечатка
должна  производиться  только  в  том  случае,  если  окно  текста  не  пусто,
что  обеспечивается  с  помощью  условного  оператора  if.  Весь
программный  код  выглядит  так:
 Private  Sub  mnuPrint_Click()
 If  txtTextWindow.Text  =  ""  Then
 MsgBox  "Нет  текста  для  печати"
 Exit  Sub
End  If
 Printer.Print  txtTextWindow.Text
Printer.EndDoc
End  Sub
 Этот  код  должен  быть  тебе  понятен.  О  команде  Exit  Sub
говорилось  в  главе  4  в  разделе  «Подсчет  продолжается».
Действие  команды  заключается  в  прерывании  выполнения
процедуры.  Поэтому  остальные  операции,  указанные  в  ней  (в
нашем  случае  —  распечатка  текста),  не  выполняются.
 Пункты  меню  Открыть  и  Сохранить  мы  рассмотрим  позже.  Для  них
тебе  потребуются  сведения,  о  которых  речь  пойдет  только  в
следующей  главе.  А  сейчас  мы  займемся  меню  Формат.

Полужирное  начертание  шрифта
 Открой  в  окне  объекта  меню  Формат  и  щелкни  мышью  пункт  Полу¬
жирный.  Как  и  следовало  ожидать,  в  окне  программного  кода  ты  уви¬
дишь  следующее:
 Private  Sub  mnuBold_Click()
 End  Sub
 Между  этими  двумя  строками  необходимо  поместить  команды,  кото¬
рые  обеспечат  полужирное  начертание  шрифта  в  поле  элемента
TextBox.  Соответствующее  свойство  называется  FontBold  (Полужир¬
ный).  Для  того  чтобы  начертание  шрифта  стало  полужирным,  этому
свойству  следует  задать  значение  True:
 txtTextWindow.FontBold  =  True
 Поскольку  четкое  понимание  подобных  конструкций  чрезвы¬
чайно  важно  для  освоения  языка  Visual  Basic,  я  подробно  пояс¬
ню  эту  строку.
 txtTextWindow  —  имя  элемента  TextBox.  Он,  как  и  любой  уп¬
равляющий  элемент,  обладает  определенными  свойствами,  зна¬
чения  которых  задаются  либо  в  окне  свойств,  либо  в  программ¬
ном  коде.  Задание  их  в  коде  осуществляется  с  помощью  пост¬
фиксного  оператора  по  схеме  «Имя  управляющего  элемента  —
постфиксный  оператор  —  свойство  —  знак  присвоения  (=)  —  зна¬
чение».  В  данном  случае  свойству  FontBold  элемента  с  именем
txtTextWindow  присваивается  значение  True.  Следователь¬
но,  текст  в  поле  этого  элемента  приобретет  полужирное  начер¬
тание.
 Чем  дольше  ты  будешь  работать  с  постфиксным  оператором  и
операторами  присваивания,  тем  быстрее  и  лучше  ты  их  освоишь.
 Однако,  введя  эти  строки,  мы  столкнемся  со  следующей  проблемой:
пользователь  не  имеет  возможности  вернуться  к  обычному  (не  полу-

жирному)  начертанию  шрифта.  Это  положение  необходимо  исправить.
 Наиболее  профессиональным  вариантом  решения  данной  проблемы
было  бы  создание  так  называемого  переключателя:  когда  пользова¬
тель  выбирает  команду  Полужирный  в  первый  раз,  устанавливается
полужирное  начертание.  Когда  же  он  указывает  ее  повторно,  програм¬
ма  возвращается  к  обычному  начертанию  и  т.д.
 Напишем  соответствующий  код.  Часто  при  составлении  програм¬
мы  для  решения  возникшей  проблемы  бывает  полезно  четко
сформулировать  ее  на  обычном,  повседневном  языке,  —  и  реше¬
ние  рождается  само  собой.
 Попробуем  так  и  поступить.  Сформулируем  нашу  задачу  следую¬
щим  образом:  если  полужирное  начертание  еще  не  задано,  и  поль¬
зователь  выбирает  соответствующую  команду,  то  оно  устанавли¬
вается;  если  оно  уже  указано,  то  при  повторном  выборе  этой  ко¬
манды  происходит  возвращение  к  обычному  начертанию.
 Ясно,  что  следует  воспользоваться  условным  оператором  if,  который
как  раз  и  описывает  конструкции  «если  —  то».
 Итак,  введем  в  процедуре
 Private  Sub  mnuBold_Click()
 End  Sub
следующий  код:
 If  txtTextWindow.FontBold  =  False  Then
 1  если  текущее  начертание  не  полужирное

txtTextWindow.FontBold  =  True
 'то  установить  полужирное  начертание
 Else
 txtTextWindow.FontBold  =  False
 в  противном  случае  вернуться  в  обычному
начертанию
 End  If
 Для  большей  наглядности  я  вставил  в  код  комментарии.  Ты,
естественно,  можешь  их  не  переписывать.
 Однако  предполагаемый  пользователь  может  поинтересоваться,  что
указывает  на  то,  какое  начертание  —  обычное  или  полужирное  —
установлено  в  окне  редактора  до  ввода  текста?  Этот  недостаток
приложения  необходимо  устранить.
 Решая  данную  задачу  в  профессиональных  приложениях,  перед
пунктом  меню  ставят  галочку  (✓),  если  установлено  полужирное
начертание,  и  убирают  ее,  если  оно  обычное.
 Такой  прием  легко  реализуется  с  помощью  свойства  Checked,
имеющегося  у  пунктов  меню.  Присваивая  ему  значение  True,  ты
отмечаешь  текущую  команду  галочкой.  Следовательно,  мы  можем
написать  в  программном  коде  следующее:
 mnuBold.Checked  =  True
 Включи  эту  строку  в  текст  условного  оператора:
 Private  Sub  mnuBold_Click()
 If  txtTextWindow.FontBold  =  False  Then
txtTextWindow.FontBold  =  True
mnuBold.Checked  =  True
 Else
 txtTextWindow.FontBold  =  False
mnuBold.Checked  =  False
End  If
End  Sub

Запусти  программу  и  посмотри,  как  используется  галочка.
 Нам  предстоит  решить  последнюю  задачу.  До  сих  пор  мы  только  выво¬
дили  текст  на  экран  и  устанавливали  для  него  полужирное  или  обыч¬
ное  начертание.  Для  того  чтобы  сообщить  также  и  принтеру  о  том,  в  ка¬
ком  начертании  следует  распечатать  текст,  воспользуемся  свойством
FontBold  принтера.
 Составим  процедуру  для  установки  начертания  при  выводе  текста  на
экран  и  на  принтер.  Она  выглядит  так:
 Private  Sub  mnuBold_Click()
 If  txtTextWindow.FontBold  =  False  Then
txtTextWindow.FontBold  =  True
mnuBold.Checked  =  True
Printer.FontBold  =  True
 Else
 txtTextWindow.FontBold  =  False
mnuBold.Checked  =.  False
Printer.FontBold  =  False
End  If
End  Sub
 Запусти  программу,  и  ты  увидишь,  что  она  работает  не  так,  как
хотелось  бы.  Не  удается,  как  в  обычных  текстовых  редакторах,
устанавливать  полужирное  начертание  только  для  отдельных  ча¬
стей  текста,  сохраняя  обычным  начертание  остальных  фрагмен¬
тов.  Один  и  тот  же  тип  устанавливается  сразу  для  всего  текста.  К
сожалению,  при  использовании  управляющего  элемента
TextBox  ничего  другого  добиться  нельзя.

Тем  не  менее,  существуют  две  возможности  справиться  с  этой
проблемой.  Одна  заключается  в  том,  чтобы  использовать  вместо
TeztBox  элемент  PictureBox,  а  другая  —  задействовать  управ¬
ляющий  элемент  RichTextBox  (Форматируемое  окно),  который
подключается  особым  образом.  Однако  обсуждение  этих  спосо¬
бов  выходит  далеко  за  пределы  настоящего  элементарного  кур¬
са.  Поэтому  мы  продолжим  работать  с  обычным  элементом
TextBox.
 Последним  рывок
 Программный  код  для  пунктов  меню  Курсив  и  Подчеркивание  пишет¬
ся  подобным  образом.  Свойство  элементов  txtTextWindow  и
Printer,  отвечающее  за  курсивное  начертание,  называется
Fontltalic  (Курсив),  а  свойство,  позволяющее  осуществлять  подчерки¬
вание  FontUnderline  (Подчеркнутый).  Напиши  код  самостоятельно,  -
это  будет  хорошим  упражнением.
 Но  прежде  я  дам  тебе  небольшой  совет.
 Если  при  выполнении  приложения  необходимо  изменять  значе¬
ния  каких-либо  свойств  (например,  FontBold,  Fontltalic  или
FontUnderline),  то  целесообразно  в  самом  его  начале  присвоить
им  некоторые  исходные  значения.  Это  поможет  предотвратить
сбои  в  работе  системы  Visual  Basic  и  принтера.  В  нашем  случае
для  всех  указанных  свойств  следует  задать  начальное  значение
False  (обычный  шрифт).  Данную  операцию  необходимо  выпол¬
нить  при  загрузке  формы  (то  есть  в  процедуре  Form_Load).

Попробуй  написать  соответствующий  программный  код.
 На  всякий  случай  я  приведу  его  целиком.  Это  довольно  длинный  текст,
но  я  подробно  объяснил  все  его  составляющие  части.  Новые
фрагменты  кода  я  выделил  курсивом.  Сконцентрируй  внимание  на  них,
а  остальное  перечитай  только  в  том  случае,  если  что-либо  будет
непонятно.
 Option  Explicit
Private  Sub  Form_Load()
 txtTextWindow.Top  =  0
txtTextWindow.Left  =  0
txtTextWindow.FontBold  -  False
txtTextWindow.Fontltalic  =  False
txtTextWindow.FontUnderline  =  False
Printer.FontBold  =  False
Printer.Fontltalic  =  False
Printer.FontUnderline  =  False
End  Sub
 Private  Sub  Form_Resize()
 txtTextWindow.Width  =  ScaleWidth
txtTextWindow.Height  =  ScaleHeight
End  Sub
 Private  Sub  mnuPrint_Click  (.)
 If  txtTextWindow.Text  =  ""  Then
 MsgBox  "Нет  текста  для  печати"
 Exit  Sub
End  If
 Printer.Print  txtTextWindow.Text
Printer.EndDoc
End  Sub
 Private  Sub  mnuEnd_Click()
 End
End  Sub
 Private  Sub  mnuBold_Click()
 If  txtTextWindow.FontBold  =  False  Then
txtTextWindow.FontBold  =  True
mnuBold.Checked  =  True
Printer.FontBold  =  True

Else
 txtTextwindow.FontBold  =  False
mnuBold.Checked  =  False
Printer.FontBold  =  False
End  If
End  Sub
 Private  Sub  mnuItalic_Click  ()
 If  txtTextwindow.Fontltalic  =  False  Then
txtTextwindow.Fontltalic  =  True
mnultalic.Checked  =  True
Printer.Fontltalic  =  True
 Else
 txtTextwindow.Fontltalic  -  False
mnultalic.Checked  =  False
Printer.Fontltalic  =  False
End  If
End  Sub
 Private  Sub  mnuUnderline_Click()
 If  txtTextwindow.  Font  Under  line  =  False  Then
txtTextwindow.FontUnderline  =  True
mnuUnderline.Checked  -  True
Printer.FontUnderline  =  True
 Else
 txtTextwindow.FontUnderline  =  False
mnuUnderline.Checked  =  False
Printer.FontUnderline  =  False
End  If
End  Sub
 Private  Sub  mnuNeu_Click()
 txtTextFenster.Text  =  ""
 End  Sub
 Это  текст  первой  настоящей  профессиональной  программы.

Теперь  остается  только  написать  код  для  пункта  меню  Размер  шрифта.
Пользователь  должен  иметь  возможность  самостоятельно  задавать  тре¬
буемое  значение.  Посмотри  на  следующий  фрагмент  кода:
 Private  Sub  mnuFontsize_Click()
 Dim  InputValue  As  String
InputValue  =  InputBox("Введите  размер  J
шрифта:", 	"Размер  шрифта", 	"8")
 If  InputValue  о  ""  Then
 txtTextWindow.FontSize  =  InputValue
End  If
End  Sub
 Как  всегда,  программу  можно  дополнить.
 Но  разберемся  в  этом  коде.  Прежде  всего,  введи  его  и  запусти
приложение.  При  выборе  соответствующей  команды  меню  на  экране
появится  следующее  окно:
 Задание  размера  шрифта
 Укажи  в  поле  ввода  какое-нибудь  число  и  нажми  кнопку  ОК.  Размер
шрифта  в  поле  элемента  TextBox  изменится  соответствующим
образом.  Если  ты  нажмешь  кнопку  Отмена,  то  размер  шрифта
останется  равным  8.  Что  происходит  в  коде?
 Вначале  мы  объявляем  переменную  типа  String:
 Dim  InputValue  As  String
 В  следующей  строке  ей  присваивается  значение.

Обрати  внимание  на  то,  как  происходит  присвоение.  Очевидно,
оператор  Input  Box  предоставляет  некоторое  значение.  Гово¬
рят  также,  что  он  возвращает  значение.  Оно  и  присваивается  пе¬
ременной  InputValue.
 Возвращаемые  значения
 В  изучении  языка  Visual  Basic  мы  добрались  до  очень  важного  пункта.
Тебе  необходимо  тщательно  разобраться  в  нем.
 Сохрани  программу  и  создай  новый  проект.
 Как  ты  помнишь,  чтобы  добавить  в  программу  процедуру,  нужно
выбрать  в  меню  Tools  команду  Add  Procedure.  На  экране  появится
следующее  окно:
 Внимательно  посмотри  на  него.  Кроме  переключателя  Sub  ты  найдешь
также  переключатель  Function  (Функция).
 Щелкни  мышью  этот  переключатель  и  присвой  ему  имя  Addition
(Сложение).  Окно  примет  следующий  вид:

Нажми  кнопку  ОК.  В  окне  кода  появится  следующий  текст:
 Наша  первая  функция
 Этот  текст  очень  похож  на  каркас  процедуры.  Однако  в  отличие
от  процедуры,  функция  возвращает  некоторое  значение  для
дальнейшей  работы.  В  этом  и  заключается  принципиальное  отли¬
чие  между  процедурой  и  функцией.
 Введи  следующий  код:
 Option  Explicit
Private  Sub  Form_Load()
 Debug.Print  Addition
End  Sub
 Public  Function  Addition()
Addition  =  7
End  Function

При  выполнении  программы  в  окне  отладки  появится  цифра  7.
 Таким  образом,  мы  сделали  следующее:  написали  функцию
Addition  и  присвоили  ей  значение  7.  Затем  мы  вызвали  ее  (для
этого  за  командой  Debug.  Print  было  написано  имя  функции).
Результат  получился  таким  же,  как  если  бы  за  данной  командой
мы  написали  цифру  7.
 Ты  спросишь,  зачем  нужны  функции?  В  этом  примере  они  не  нужны  и
только  усложняют  программу.  Моей  целью  было  познакомить  тебя  с
основами  работы  функций.  В  следующем  примере  ты  увидишь,  что  они
действительно  очень  полезны.
 Измени  текст  кода  примера  следующим  образом:
 Option  Explicit
Private  Sub  Form_Load()
 Debug.Print  Addition
End  Dub
 Public  Function  Addition()
 Addition  =3+4
End  Function
 Ты  видишь,  что  изменилось?  Значение  не  просто  присваивается
функции,  —  оно  рассчитывается  внутри  нее.  И  расчеты,  разуме¬
ется,  могут  быть  значительно  более  сложными,  чем  в  этом  при¬
мере.
 Более  того,  до  сих  пор  наша  функция  всегда  возвращала  значение  7.
Однако  функции  можно  передавать  значения,  на  основе  которых  она  и
будет  производить  расчеты.  В  этом  и  заключается  основное  ее  назна¬
чение.  Объясню,  как  производится  передача  значений.  Рассмотрим
пример:
 Option  Explicit
Private  Sub  Form_Load()
 Debug.Print  Addition(3,  4)

End  Sub
 Public  Function  Addition  (fx  As  Integer,  fy  As  Integer)
Addition  =  fx  +  fy
End  Function
 Итак,  для  вызова  функции  записывается  ее  имя,  за  ним  в  скобках
ставятся  аргументы,  с  которыми  она  должна  работать.
 В  тексте  самой  функции  в  скобках  указываются  переменные,  в
которые  записываются  передаваемые  значения.  С  ними  функция
производит  дальнейшие  действия.  Эти  переменные  на  професси¬
ональном  языке  называются  параметрами.
 В  нашем  примере  функции  передаются  два  значения,  а  именно
числа  3  и  4.  Она  записывает  первое  из  них  в  переменную  f  х  (на¬
звания  переменных  могут  быть  любыми),  а  второе  —  в  fy.
 Затем  функция  производит  действия  с  указанными  переменны¬
ми.  В  результате  она  получает  значение  7  и  возвращает  его  в  то
место  приложения,  из  которого  она  была  вызвана  (строка
 Debug.  Print).
 Это  настолько  важно,  что  мы  рассмотрим  еще  один  пример  на  данную
тему.
 Введи  следующий  программный  код:
 Option  Explicit
Private  Sub  Form_Load()
 Dim  InputValue  As  Single
 InputValue  =  5.5
 Debug.Print  Quadrate(InputValue)
 End  Sub
 Public  Function  Quadrate(Number  As  Single)
 Quadrate  =  Number  *  Number
End  Function
 Запусти  программу.  В  окне  отладки  появится  число  30.25.

Из  этого  примера  мы  узнали  кое-что  новое  о  функции:  в  качестве
передаваемых  ей  аргументов  могут  использоваться  переменные,
а  не  только  фиксированные  значения.  Так  чаще  всего  и  происхо¬
дит.  Например,  пользователь  вводит  некоторые  значения,  кото¬
рые  затем  записываются  в  переменные  и  передаются  функции.
 Количество  аргументов  функции  может  быть  произвольным.
Разрешены  все  типы  данных.  В  примерах  использовались  типы
Integer  и  Single,  но  можно  было  работать  и  с  String.  Необ¬
ходимо  только  следить  за  тем,  чтобы  тип  данных  и  количество
передаваемых  аргументов  совпадали  с  типом  данных  и  количест¬
вом  параметров  функции.  Иначе  возникнет  путаница.
 Функция  1в1|шШох
 Познакомившись  с  понятием  функции,  вернемся  к  inputBox.  Эту
функцию  не  требуется  писать,  так  как  она  предоставляется  языком
Visual  Basic.  Рассмотрим  ее  еще  раз  со  значениями,  требующимися
для  текстового  редактора:
 InputBox("Введите  размер  шрифта:","Размер  шрифта",  "8")
В  качестве  аргументов  этой  функции  передаются:
 • 	переменная  типа  String,  выводящаяся  в  окне  ввода  (InputBox);
 • 	переменная  типа  String,  выводящаяся  в  заголовке  окна  ввода;
 • 	переменная  типа  String,  в  которой  указывается  значение  по  умол¬
чанию,  возвращаемое  функцией  в  том  случае,  если  пользователь  не
внес  никаких  изменений.
 Функция  имеет  гораздо  больше  аргументов,  чем  описано  в  тексте,  но
задавать  их  все  не  обязательно.  Она  чаще  всего  используется  именно
в  том  виде,  в  котором  я  ее  привел.

Каково  значение,  возвращаемое  функцией  InputBox?  Если
пользователь  нажмет  кнопку  Отмена,  то  возвратится  пустая
строка.  В  противном  случае  (при  нажатии  кнопки  ОК)  возвратит¬
ся  стоящее  в  поле  ввода  значение.  Им,  в  частности,  может  быть
значение  по  умолчанию  (в  нашем  случае  «8»).  Оно  возвращается
не  как  число,  а  как  переменная  типа  String,  так  как  бывают
приложения,  в  которых  пользователю  требуется  ввести  некото¬
рый  текст,  скажем,  пароль.
 Остальная  часть  программы  должна  быть  тебе  понятна.  Возвращенное
функцией  InputBox  значение  присваивается  переменной
InputValue,  которая  ранее  была  объявлена  как  переменная  типа
String.  Затем  проверяется,  не  является  ли  ее  новое  значение  пустой
строкой.  Если  является,  то  не  происходит  никакой  реакции.  В  противном
случае  оно  присваивается  свойству  FontSize  элемента  текстового  окна,
и  программа  начинает  использовать  новый  размер  шрифта.
 В  заключение  зададим  размер  шрифта  для  принтера:
 Printer.FontSize  =  txtTextWindow.FontSize
 Таким  образом,  первый  этап  работы  над  небольшим  текстовым  редак¬
тором  завершен.
 Несколько  небольших  заданий
 Напиши  программу,  которая  требует  от  пользователя  ввести  в  окне
ввода  (InputBox)  свое  имя.  После  совершения  пользователем  указан¬
ных  действий  на  экран  должно  быть  выведено  окно  сообщения
(MessageBox)  с  приветствием,  содержащим  обращение  к  пользовате¬
лю  по  имени.
 Напиши  программу,  в  которой  пользователь  вводит  в  поля  двух  эле¬
ментов  TextBox  два  числа.  Используя  функцию,  программа  должна
сложить  их  и  вывести  результат  в  поле  элемента  Label.

Вт  Работа  с  данными
 До  сих  пор  все  вводимые  пользователем  данные  терялись  при
завершении  работы  наших  приложений.  Этот  недостаток  мы
постараемся  исправить.
 В  этой  главе  ты  узнаешь:
 • 	как  вывести  на  экран  ранее  сохраненный  текстовый  файл,  чтобы
прочесть  или  изменить  его;
 • 	как  сохранить  информацию  в  текстовом  файле,  чтобы  она  не
исчезла  даже  после  выключения  компьютера;
 • 	как  использовать  управляющие  элементы  DriveListBox,
DirListBox  и  FileListBox;
 • 	как  написать  программу  так,  чтобы  с  ней  легко  было  работать;
 • 	как  раскладывать  переменные  типа  String  на  составные  части.

Как  открыть  файл?
 Предположим,  что  пользователь  хочет  загрузить  в  текстовый
редактор  некоторый  файл,  например,  ранее  написанный  текст,
чтобы  просмотреть  и  подправить  его.  Этот  файл  может
находиться  где  угодно  —  в  корневой  или  любой  другой  папке.
При  выборе  команды  Открыть  на  экране  должно  появиться
окно,  в  котором  пользователь  должен  указать  нужный  файл.
 В  Visual  Basic  имеется  набор  управляющих  элементов,  приспособлен¬
ных  для  данной  цели.  Нам  требуется  только  поместить  их  в  форму  и
связать  друг  с  другом.
 Что  нужно,  чтобы  приложение  однозначно  распознало  файл?  Прежде
всего,  необходимо  установить,  на  каком  диске  он  находится  —  на
дискете  в  дисководе  А,  на  каком-либо  из  жестких  дисков  или  на
компакт-диске.  Затем  следует  определить  папку  на  выбранном  диске
и,  наконец,  имя  файла.  Например:  С:  \МОИ  ДОКУМЕНТЫ\ПИСЬМАХ
ПИСЬМО  1.
 Посмотрим  на  панель  инструментов  среды  Visual  Basic.  В  нижней  ее
части  мы  найдем  три  элемента  с  подходящими  названиями:
 • 	DriveListBox  (Список  дисков).  Приводится  список  дисководов,
имеющихся  на  компьютере  пользователя.
 • 	DirListBox  (Список  папок).  Приводится  список  всех  папок,
имеющихся  на  диске.
 • 	FileListBox  (Список  файлов).  Приводится  список  всех  файлов,
расположенных  в  папке.
 ■  Создай  в  программе  текстового  редактора  новую  форму  (для  этого  в
меню  Project  выбери  команду  Add  Form).
 ’  Помести  в  нее  управляющие  элементы  DriveListBox,  DriveListBox  и
FileListBox,  а  также  две  командные  кнопки.

Форма  должна  выглядеть  следующим  образом:
 Окна  управляющих  элементов:  слева  вверху  —  DriveListBox,
под  ним  —  DirListBox,  справа  —  Fi/eListBox
 В  таблице  приведены  значения  свойств  Caption  и  Name  данных
элементов:
 Упр.  элемент
 Form
 DriveListBox
 DirListBox
 FileListBox
 CommandButton
 CommandButton
 frmOpen
 Drv
 Dir
 File
 cmdOK
 cmdCancel
 Открытие  файла
 &0K
 От&мена
 Сохрани  новую  форму  в  папке,  предназначенной  для  текстового
редактора.

Для  того  чтобы  вызвать  эту  форму,  необходимо  в  меню  формы
txtTextEditor  указать  команду  Открыть  и  ввести  в  появив¬
шийся  каркас  программы
 Private  Sub  mnuOpen_Click()
 End  Sub
 следующую  строку,  уже  известную  тебе  из  приложения  «Фами¬
лии»:
 frmOpen.Show  vbModal
 Запусти  программу  и,  выбрав  команду  Открыть,  перейди  в  окно
Открытие  документа.  В  нем  выбираются  диски,  папки  и  файлы.
 Три  наших  управляющих  элемента  никак  не  связаны  друг  с  дру¬
гом.  При  выборе  другого  диска  в  окнах  папок  и  файлов  ничего  не
меняется.  Связь  между  элементами  устанавливается  в  программ¬
ном  коде.
 Настало  время  познакомиться  еще  с  двумя  понятиями  языка
Visual  Basic.  Их  необязательно  запоминать,  —  достаточно  хоро¬
шо  разобраться  в  сказанном.

Прежде  всего,  настроим  окно  папок  так,  чтобы  оно  реагировало  на  из¬
менение  диска.  Иными  словами,  при  переходе  в  окне  дисководов  с
диска  С:  на  D:  в  окне  папок  должны  отображаться  папки,  расположен¬
ные  на  диске  D:.
 Дважды  щелкни  мышью  управляющий  элемент  DriveListBox.  В  окне
кода  появятся  следующие  строки:
 Private  Sub  Drv_Change()
 End  Sub
 Таким  образом,  язык  Visual  Basic  предполагает  по  умолчанию,  что  мы
собираемся  работать  с  процедурой  Change.  И  действительно,  нам
нужна  именно  эта  процедура.
 В  каркасе  процедуры  для  начала  достаточно  ввести  одну  строку:
 Dir.Path  =  Drv.Drive.
 Под  словом  Path  (по-английски  означает  «путь»)  понимают  папку,  в  ко¬
торой  находится  файл,  например  С:  \мои  документы\письма.  В  ка¬
честве  пути  с  помощью  символа  присваивания  (=)  (его  называют  еще
оператором  присваивания)  мы  задаем  выбранный  диск.  Теперь  в  окне
элемента  DirListBox  должны  отображаться  папки  указанного  диска.
 Запусти  программу  и  выбери  в  окне  элемента  DriveListBox  другой  же¬
сткий  диск  или  компакт-диск.  Показания  окна  элемента  DirListBox  из¬
менятся  соответствующим  образом.
 Если  ты  выберешь  диск  А:  (дискету),  и  в  дисководе  ее  не  окажется,  на
экране  появится  следующее  окно  сообщения  об  ошибке:

Программа  попыталась  обратиться  к  несуществующему  носителю
данных.  Естественно,  это  привело  к  ошибке.
 Обработка  ошибок
 Итак,  мы  добрались  до  еще  одного  важного  момента.  Програм¬
мист  всегда  исходит  из  того,  что  пользователь  непременно  будет
делать  ошибки,  как  легкие,  так  и  самые  серьезные.  Для  их  преду¬
преждения  программист  должен  писать  части  кода,  отвечающие
за  предотвращение  сбоя  работы  приложения.
 Посмотрим,  как  это  делается.  Представим  ситуацию,  когда
пользователь  выбрал  дисковод,  в  котором  нет  дискеты.
 Вначале  я  приведу  код  процедуры  обработки  ошибок,  а  потом  мы
попытаемся  в  нем  разобраться:
 Private  Sub  Drv_Change()
 On  Error  GoTo  ErrorHandling
Dir.Path  =  Drv.Drive
Exit  Sub
ErrorHandling:
 MsgBox  "Дисковод  недоступен!"
 Drv.Drive  =  Dir.Path
Exit  Sub
End  Sub
 (ErrorHandling  в  переводе  с  английского  означает  «обработка
ошибок»).

Данный  фрагмент  программного  кода  означает  следующее:  «Ес¬
ли  происходит  ошибка,  перейти  в  другой  раздел  программы  с  на¬
званием  ErrorHandling.  Остальные  действия  не  выполнять.
Вывести  окно  сообщения.  Вернуться  к  прежнему  дисководу  и
выйти  из  процедуры.  Если  ошибки  не  происходит,  перейти  в  эле¬
менте  DirListBox  к  новому  дисководу.  Выйти  из  процедуры  и  не
выполнять  инструкции  раздела  ErrorHandling.»
 Команда  GoTo  языка  Visual  Basic  заставляет  программу  перейти  к  дру¬
гому  участку  кода,  которому  программист  дает  некоторое  имя  (в  на¬
шем  случае  —  ErrorHandling).  Данный  участок  программа  опреде¬
ляет  по  тому,  что  перед  ним  стоит  его  имя  с  двоеточием.
 Как  уже  было  сказано,  указанный  фрагмент  кода  должен  выполняться
только  в  случае  возникновения  ошибки.  Это  обеспечивается  инструк¬
цией  On  Error  (в  переводе  с  английского  ее  название  означает  «в
случае  ошибки»).  Если  ошибки  нет,  то  производятся  действия,  о  кото¬
рых  мы  говорили  ранее.  Затем  в  результате  выполнения  инструкции
Exit  Sub  происходит  выход  из  процедуры,  чтобы  не  выполнялись
стоящие  далее  операторы,  связанные  с  обработкой  ошибок.  Если  не
написать  эту  инструкцию,  то  сообщение  об  ошибке  будет  выдаваться
всегда!
 При  возникновении  выводится  окно  сообщения,  извещающее  пользо¬
вателя  о  ней  (сбоя  программы  не  происходит).  Строка  кода,  а  именно:
 Drv.Drive  =  Dir.Path
 выполняет  следующие  функции.  Пользователь  выбрал  дисковод,  к  ко¬
торому  нельзя  обратиться.  Для  элемента  DriveListBox  должен  быть
указан  установленный  в  нем  ранее  диск.  Сведения  о  диске  хранятся  в
свойствах  элемента  DirListBox,  которого  не  затронули  изменения.
Поэтому  происходит  присвоение  —  восстановление  предшествующего
состояния.

Далее  присвоим  управляющему  элементу  FileListBox  папку,  выбран¬
ную  в  DirListBox.  Это  делается  аналогично  тому,  как  устанавливалась
связь  между  диском  и  папками.  Если  папке  должен  быть  сопоставлен
файл,  то  присвоение  выглядит  так:
 File.Path  =  Dir.Path
 Это  единственная  строка  в  процедуре  Private  Sub  Dir_Change  (),
для  входа  в  которую  необходимо  дважды  щелкнуть  мышью  элемент
DirListBox.  В  данном  случае  не  требуется  писать  код  для  обработки
ошибок,  так  как  пользователь  в  любом  случае  не  сможет  выбрать  несу¬
ществующую  папку.
 Посмотрим  текст  программного  кода,  написанный  к  настоящему  мо¬
менту:
 ^  Необходимо  еще  раз  протестировать  программу  (это  вообще  следует
делать  как  можно  чаще,  чтобы  заметить  ошибку  на  более  ранней
стадии).  Запусти  ее  и  попробуй  выбрать  разные  диски,  папки  и  файлы.

В  конечном  итоге  цель  данной  части  программы  заключается  в
том,  чтобы  выбрать  файл  и  загрузить  его  в  поле  элемента
TextBox  формы  frmTextEditor.  Сейчас  нам  предстоит  это
сделать.
 Допустим,  что  требуется  открыть  файл  ПИСЬМО  1,  находящийся  на
диске  С:.  Выберем  в  окне  элемента  DriveListBox  этот  диск.  В  окне
элемента  DirListBox  укажем  папку,  в  которой  находится  нужный  файл
 (МОИ  ДОКУМЕНТЫ\ПИСЬМА).
 Если  у  тебя  действительно  есть  в  папке  такой  файл,  то  он  появится  в  окне
элемента  FileListBox.  Форма  для  выбора  файлов  выглядит  так:
 Следовательно,  значение  свойства  Path  элемента  File  равно
 С:\Мои  документы\Письма
 Но  что  бы  мы  ни  делали  —  выделяли  этот  файл  и  нажимали  кнопку  ОК
или  дважды  щелкали  его  мышью,  —  приложение  никак  не  реагирует.
Напишем  программный  код.

Если  у  тебя  нет  в  указанной  папке  файла  с  именем  ПИСЬМО  1
работай  с  любым  файлом,  который  открывается  в  окне  нашего
текстового  редактора  (то  есть  с  файлом,  имеющим  расширение
txt  или  doc).  Тебе  необязательно  также  создавать  папки,
упоминающиеся  в  данном  примере.
 Очевидно,  что  для  открытия  файла  требуется  знать  не  только  его  путь,
но  и  имя.  Путь
 С:\МОИ  ДОКУМЕНТЫ\ПИСЬМА
 является  значением  свойства  File.  Path.  Нам  требуется  дополнение,
которое  мы  получаем  из  окна  для  выбора  файлов:
 С:\МОИ  ДОКУМЕНТЫ\ПИСБМА\ПИСЬМО1
 Дважды  щелкни  мышью  элемент  FileListBox.  Откроется  окно
программного  кода  со  следующим  текстом:
 Private  Sub  File_Click()
 End  Sub
 Для  того  чтобы  обеспечить  обозримость  кода  и  сэкономить  время,
объявим  вначале  переменную,  в  которую  запишется  полный  путь,
включая  имя  файла.  Она  должна  быть  доступна  во  всей  форме.
Поэтому  в  декларативной  части  формы  непосредственно  под  строкой
 Option  Explicit  напиши  следующее:
 Dim  FileNm  As  String
 Вернись  в  процедуру  File_Click.  Прежде  всего,  напиши  в  ней:
 FileNm  =  File.Path

В  значение  этой  переменной  включи  имя  файла.  Имя  файла,
выбранного  в  поле  элемента  FileName,  хранится  в  свойстве
FileListBox  этого  элемента.  Возможно,  следует  написать  так:
 FileNm  =  FileName  +  File.FileName
 Проверим,  верна  ли  эта  инструкция.
 Введи  данный  код  в  каркас  процедуры  и  добавь  инструкцию
 Debug.Print  FileNm
 Весь  код  целиком  должен  выглядеть  таким  образом:
 Private  Sub  File_Click()
 FileNm  =  File.Path
FileNm  =  FileNm  =  File.FileName
Debug.Print  FileNm
End  Sub
 Запусти  программу  и  посмотри  в  окно  отладки.  У  меня  появился  текст
 С:\МОИ  ДОКУМЕНТЫ\ПИСЬМАПИСЬМО1
 Между  ПИСЬМА  и  ПИСЬМО1  не  хватает  обратной  косой  черты  (\).  В
некоторых  случаях  она  добавляется  автоматически.  Однако  ее  нужно
указывать  всегда,  так  как  иначе  файл  невозможно  опознать  и
загрузить  его  в  элемент  TextBox.
 Для  того  чтобы  справиться  с  этой  проблемой,  прежде  всего,  следует
установить,  стоит  ли  в  конце  значения  свойства  File  .  Path  обратная
косая  черта.  Если  да,  то  все  в  порядке.  Если  нет,  как  в  данном  примере,
то  ее  необходимо  поставить.  Следовательно,  придется
воспользоваться  условным  оператором,  действие  которого  можно
перевести  на  обычный  язык  таким  образом:
 «Если  в  конце  значения  свойства  File.  Path  нет  обратной  косой
черты,  поставь  ее».
 Чтобы  установить,  есть  ли  она,  необходимо  определить,  какой  символ
стоит  последним  в  значении  свойства  File.  Path.  Для  этого  нам
понадобятся  дополнительные  сведения  о  переменных  типа  String.

Операции  с  переменными  типа  String
 Привожу  сразу  соответствующий  программный  код  в  его
окончательном  виде:
 Private  Sub  File_Click()
 FileNm  =  File.Path
 If  Right(FileNm,  1) 	<> 	"\" 	x
 Then  FileNm  =  FileNm  +  "\"
 FileNm  =  FileNm  +  File.FileName
Debug.Print  FileNm
End  Sub
 Новая  строка  (она  выделена  курсивом)  следует  за  присвоением
значения  переменной  FileNm.
 Команда  Right,  встретившаяся  в  этом  фрагменте  кода,  являет¬
ся  функцией,  то  есть  ей  передаются  аргументы,  и  она  возвраща¬
ет  значение.  Рассматриваемой  функции  в  качестве  аргументов
передаются  переменная  типа  String  и  число.  Оно  указывает,
сколько  символов  из  переменной  типа  String  необходимо  счи¬
тать,  начиная  справа.  Данные  символы  и  являются  возвращае¬
мым  значением.
 Приведу  пример:
 Option  Explicit
Private  Sub  Form_Load()
 Dim  Partstring  As  String
Partstring  =  Right("Сергей",  1)
 Debug.Print  Partstring
End  Sub
 При  выполнении  этого  кода  (если  хочешь,  создай  для  него  новый
проект)  в  окне  отладки  появляется  буква  «й».  Действительно,  если
ограничиться  одним  символом  слова  «Сергей»,  начиная  справа,  то  им
как  раз  и  окажется  «й».

Если  ввести  инструкцию
 Partstring  =Right("Сергей",  2)
 то  результатом  выполнения  программы  будет  «ей»,  то  есть  две
последние  буквы  слова  «Сергей».
 Кроме  того,  существует  функция  Left,  в  которой  строка
символов  читается  слева.  Результатом  выполнения  инструкции
 Left  ("Сергей",  2)  является  «Се».
 Таким  образом,  в  нашем  случае  с  помощью  инструкции
 Right(FileNm,  1)
 мы  получаем  последний  символ  в  переменной  FileNm.  Если  им
оказывается  не  обратная  косая  черта  (оператор  сравнения  о),  то  она
ставится.  В  результате  имя  папки,  в  которой  находится  нужный  файл,
заканчивается  обратной  косой  чертой.  Затем  к  нему  добавляется  имя
файла,  который  следует  загрузить  в  поле  элемента  TextBox.
 В  окончательном  варианте  программы  строку  Debug.  Print,
разумеется,  необходимо  убрать.
 Подведем  некоторые  итоги.  Итак,  пользователь  выбрал  с  помощью
команды  Открыть  файл,  который  он  хотел  бы  загрузить  в  окно
текстового  редактора.  Имя  этого  файла  с  полным  путем  записано  в
переменной  FileNm.  Сделаем  последний  шаг:  откроем  его.  Для  этого
нажмем  кнопку  ОК,  расположенную  в  окне  Открытие  документа.

Работа  с  файлами
 Дважды  щелкни  мышью  кнопку  ОК  в  объектном  окне  формы
Открытие  документа.
 Откроется  окно  кода  с  каркасом  программы:
 Private  Sub  cmdOK_Click()
 End  Sub
 В  этой  процедуре  необходимо  открыть  файл,  чтобы  пользователь  мог
с  ним  работать,  например  изменить  или  дополнить  его.
 Разумеется,  нам  следует  указать  имя  файла.  Оно  хранится  в
переменной  FileNm,  поэтому  соответствующая  инструкция  выглядит
так:
 Open  FileNm  For  Input
 (Open  For  Input  по-английски  Означает  «открыть  для  ввода»).
 Операционная  система  Windows,  которая  относится  к  числу  сис¬
тем,  позволяющих  одновременно  оперировать  с  несколькими
файлами.  На  профессиональном  языке  такой  способ  работы  на¬
зывается  многозадачностью.  Например,  можно  распечатывать
текст  на  принтере  и  в  то  же  время  играть  в  компьютерную  игру.
Данный  способ  удобен  для  пользователя,  но  создает  определен¬
ные  проблемы  для  программиста:  ведь  операционная  система
должна  точно  знать,  к  какому  файлу  относится  вызов  Open,  ина¬
че  возникнет  хаос.
 Для  этого  каждому  файлу  при  открытии  сразу  же  присваивается
номер.  Он  указывается  при  каждом  обращении  (например,  при
открытии  файла  с  помощью  команды  Open).  Благодаря  этому
удается  избежать  путаницы.

Прежде  всего,  следует  объявить  переменную  типа  Integer,  в  которой
будет  храниться  номер  файла.
 Введи  в  начале  процедуры  следующую  строку:
 Dim  FileNumber  As  Integer
 Кроме  того,  системе  Visual  Basic  нужно  знать  длину  файла,  чтобы
правильно  считать  его.
 Поэтому  введем  еще  одну  переменную:
 Dim  FileLength  As  Long
 Вместо  типа  Integer  мы  выбрали  Long,  чтобы  можно  было  работать
и  с  большими  файлами.
 После  того  как  с  объявлениями  покончено,  определим  номер  файла.
Его  не  требуется  придумывать.  Для  этой  цели  существует  специальная
функция,  которая  возвращает  номер  файла.  Она  называется  FreeFile
(Свободный  файл).  Эта  функция  является  исключением  из  общего
правила:  ей  не  передаются  аргументы.
 Введи  следующую  строку  кода:
 FileNumber  =  FreeFile
 Приведу  для  сравнения  написанный  текст  кода:
 Private  Sub  cmdOK_Click()
 Dim  FileNumber  As  Integer
Dim  FileLength  As  Long
FileNumber  =  FreeFile
End  Sub
 Проверим,  выбран  ли  какой-нибудь  файл  пользователем  до  того,  как  он
нажал  кнопку  ОК.  Если  системе  Visual  Basic  придется  открывать  документ
в  ситуации,  когда  он  не  указан,  то  обязательно  возникнет  ошибка.
 Для  того  чтобы  избежать  ее,  проверим,  не  является  ли  значение
переменной  FileNm  пустой  строкой.  Если  является,  то  следует  выдать
пользователю  сообщение  об  этом  и  выйти  из  процедуры.

Введи  следующий  код:
 If  FileNm  =  ""  Then
 MsgBox  "Файл  не  выбран!"
 Exit  Sub
End  If
 Запусти  программу,  войди  в  окно  Открытие  документа  и  нажми  кноп¬
ку  ОК,  не  выбирая  файл.  На  экране  должно  появиться  соответствую¬
щее  сообщение.
 Займемся  непосредственно  открытием  файла.  Для  этого  в  конце  ус¬
ловного  оператора  i  f  введи  следующую  строку:
 Open  FileNm  For  Input  As  FileNumber
 Эта  инструкция  не  нуждается  ни  в  каких  дополнениях.  В  ней  ука¬
зано  имя  файла,  его  номер  и  тип  открытия  (Input  —  для  ввода).
Перейдем  к  определению  длины  файла.  Знать  ее  важно,  так  как
необходимо,  чтобы  с  диска  был  полностью  считан  указанный
файл.  Для  этой  цели  существует  функция  LOF.  Ее  имя  представ¬
ляет  собой  сокращение  от  английских  слов  Length  Of  File  (длина
файла),  и  все  буквы  в  нем  обычно  прописные.
 Введи  в  текст  программного  кода  следующую  строку:
 FileLength  =  LOF(FileNumber)
 Таким  образом,  в  качестве  аргумента  данной  функции  передает¬
ся  номер  файла,  и  она  возвращает  его  длину,  которая  запомина¬
ется  в  переменной  FileLength.  Данная  последовательность
действий  при  открытии  файла  строго  определена  в  языке  Visual
Basic,  и  ее  необходимо  соблюдать.

Далее  требуется  загрузить  содержимое  открытого  файла  в  окно
текстового  редактора.  Это  делается  так:
 frmTextEditor.txtTextWindow.Text  =  J
Input(FileLength,  FileNumber)
 В  левой  части  этой  инструкции  происходит  обращение  из  окна
Открытие  документа  к  управляющему  элементу,  расположен¬
ному  в  другой  форме  (frmTextEditor).  Следовательно,  впере¬
ди  должно  стоять  ее  имя.  Затем  следует  имя  элемента  TextBox
(txtTextWindow)  и,  наконец,  имя  свойства  (Text).
 В  левой  части  стоит  функция  Input.  Ее  аргументами  является  ко¬
личество  выдаваемых  символов,  то  есть  длина  файла  и  его  но¬
мер.  Возвращаемое  значение  имеет  тип  String.  В  нем  находит¬
ся  все  содержимое  файла.
 Итак,  содержимое  файла  загружено  в  поле  элемента  TextBox  и
выведено  на  экран.  Цель  достигнута.
 Однако  это  еще  не  все:  остались  кое-какие  важные  действия,  которые
следует  выполнить  во  избежание  возможного  сбоя  системы.
 Запомни:  открытый  файл  необходимо  закрыть!  Иначе  он  так  и
будут  «висеть»  в  системе,  а  это  не  приведет  ни  к  чему  хорошему.
Поэтому  следующей  командой  должна  быть
 Close  FileNumber
 (Close  в  переводе  с  английского  означает  «закрыть»).
 Добавь  в  значение  свойства  Caption  главного  окна  имя  открытого
файла.  Это  делается  с  помощью  следующей  инструкции:
 frmTextEditor.Caption  =  "Мой  редактор  "  +  FileNm

И,  в  заключение,  убери  с  экрана  форму  для  открытия  файлов.
Воспользуйся  командой
 Hide
 Для  сравнения  приведу  полный  текст  программного  кода,
относящийся  к  кнопке  ОК:
 Private  Sub  cmdOK_Click()
 Dim  FileNumber  As  Integer
Dim  FileLength  As  Long
FileNumber  =  FreeFile
If  FileNm  =  ""  Then
 MsgBox  "Файл  не  выбран!"
 Exit  Sub
End  If
 Open  FileNm  For  Input  As  FileNumber
FileLength  =  LOF(FileNumber)
frmTextEditor.txtTextWindow.Text  =
 Input(FileLength,  FileNumber)
 Close  FileNumber
 frmTextEditor.Caption  =  "Мой  редактор  "  +  J
FileNm
 Hide
End  Sub
 Несколько  небольших  заданий
 Мы  еще  не  написали  программный  код  для  кнопки  Отмена.  При  ее  на¬
жатии  форма  исчезает,  и  загрузка  файла  не  производится.  Для  этого
достаточно  одной  команды.
 Допустим,  что  файл  уже  загружен,  а  ты  собираешься  очистить  окно
текста,  выбрав  команду  Создать.  Но  в  строке  заголовка  программы
остается  имя  загруженного  файла.  Исправь  это  положение,  вернув  за¬
головку  первоначальный  вид:  имя  программы  плюс  БезымянныйОО.

Не  забывай,  что  таким  образом  можно  загружать  не  любые  фай¬
лы,  а  только  текстовые.  Если  ты  попытаешься  открыть  файл,  ска¬
жем,  с  расширением  ехе,  то  программа  даст  сбой.  В  принципе,
следовало  бы  разработать  механизм  для  предотвращения  по¬
добных  ошибок,  однако  эта  задача  выходит  за  рамки  настоящей
книги.  Важнее  научиться  сохранять  текст,  чем  мы  и  займемся.
 Сохранение  данных
 В  меню  Файл  формы  frmTextEditor  укажи  команду  Сохранить.
Откроется  окно  программного  кода  со  следующим  текстом:
 Private  Sub  rmuSave_Click  ()
 End  Sub
 В  этой  процедуре  необходимо  объявить  две  переменные:  одну  —  типа
String  (в  нее  будет  записываться  имя,  под  которым  пользователь
хочет  сохранить  текущий  файл),  другую  —  типа  Integer  (в  ней  будет
храниться  номер  файла).
 Dim  FileNm  As  String
Dim  FirlNumber  As  Integer
 Для  организации  ввода  имени  файла  воспользуемся  окном  InputBox.
 В  главе  8  мы  уже  работали  с  этой  функцией.  Ей  передаются  три
аргумента:  текст,  выводимый  в  окне  InputBox,  его  заголовок  и
возвращаемое  по  умолчанию  значение.  Функция  возвращает
значение  типа  String,  в  котором  хранится  либо  введенная
пользователем  строка,  либо  строка  по  умолчанию.

В  данном  случае  мы  станем  использовать  только  два  первых  аргумен¬
та.  Имя  файла  по  умолчанию  задавать  не  будем.  Пользователь  должен
ввести  имя,  под  которым  он  хочет  сохранить  текущий  файл.  Оно  и  бу¬
дет  значением,  возвращаемым  функцией  InputBox.  Сохраним  его  в  пе¬
ременной  FileNm:
 FileNm  =  InputBox  J
 'Весь  текст  следует  записать  одной  строкой!
("Введите  имя  файла",  "Сохранение")
 Запусти  программу.  Окно  выглядит  так:
 Ожидание  ввода  имени  файла
 Разумеется,  файл  следует  сохранять  только  в  случае,  если  пользова¬
тель  задал  имя  и  не  нажал  кнопку  Отмена.  Значит,  нужно  воспользо¬
ваться  условным  оператором  if:
 If  FileNm  о  ""  Then
 End  If
 Действия,  заключенные  внутри  условного  оператора,  выполня¬
ются  только  в  том  случае,  если  пользователь  ввел  непустое  имя
файла.
 Если  имя  файла  задано,  то  необходимо  определить  незанятый  номер
файла.  Это  делается  так:
 FileNumber  =  FreeFile

На  этот  раз  файл  требуется  открыть  не  для  чтения  или  ввода  тек¬
ста  (что  выполнялось  с  помощью  команды  Open  For  Input),  а  для
записи,  иными  словами,  для  сохранения  данных.
 Разница  заключается  в  том,  что  с  помощью  команды  Open  For
Input  на  экран  выводилось  та  информация,  которая  ранее  была
сохранена  в  памяти  компьютера.  Теперь  поставлена  задача  запи¬
сать  в  память  компьютера  то,  что  находится  на  экране.  Это,  мож¬
но  сказать,  обратная  операция.
 Команда  открытия  файла  для  записи  такова:  Open  For  Output
(английское  слово  output  в  переводе  означает  «вывод»).
 Соответствующая  строка  программного  кода  имеет  следующий  вид:
 Open  FileNm  For  Output  As  FileNumber
 Итак,  файл  открыт.  Но  в  него  еще  нужно  записать  текст,  содер¬
жащийся  в  поле  элемента  TextBox  текстового  редактора.  В  язы¬
ке  Visual  Basic  в  качестве  команды  для  записи  (вывода)  использу¬
ется  Print.
 Она  указывает  на  вывод  данных  на  экран,  как  в  знакомой  тебе
инструкции  Debug.Print.  Для  осуществления  записи  в  файл
следует  использовать  такую  конструкцию:
 Print  #FileNumber,  txtTextWindow.Text
 Таким  образом,  за  командой  Print  ставится  номер  файла,  перед  кото¬
рым,  в  отличие  от  записи  на  экран,  пишется  символ  #  (означающий  но¬
мер).  Далее  через  запятую  следует  текст,  который  должен  быть  запи¬
сан  в  данный  файл.
 После  этого  файл  необходимо  закрыть:
 Close  FileNumber

И  в  заключение  заголовок  формы  f  rmTextEditor  следует  привести
в  соответствие  с  новым  именем  файла:
 Caption  =  "Мой  Редактор  "  +  FileNm
 На  всякий  случай  я  приведу  полностью  текст  этой  процедуры:
 Private  Sub  mnuSave_Click()
 Dim  FileNm  As  String
Dim  FileNumber  As  Integer
FileNm  =  InputBox  J
 ("Введите  имя  файла",  "Сохранение")
 If  FileNm  о  ""  Then
 FileNumber  =  FreeFile
Open  FileNm  For  Output  As  FileNumber
Print  #FileNumber,  txtTextWindow.Text
Close  FileNumber
 Caption  =  "Мой  редактор  "  +  FileNm
End  If
End  Sub
 Запусти  программу  и  введи  в  окне  редактора  какой-нибудь  текст.
 Выбери  в  меню  Файл  команду  Сохранить.  На  экране  появится  окно
ввода.
 Введи  имя  файла,  например  TestText.  txt  и  нажми  кнопку  ОК.
Укажи  команду  Создать,  чтобы  текстовое  поле  очистилось.
 Укажи  команду  Открыть  для  только  что  сохраненного  файла.
Введенный  тобой  текст  появится  на  экране.
 Если  программа  все-таки  не  работает,  сравни  внимательно
введенный  тобой  код  с  тем,  который  приведен  в  книге.
 Итак,  программа  для  текстового  редактора  написана.  Разумеется,  за
рамками  настоящей  книги  осталось  очень  многое.  Например,  работа  с

базами  данных  осуществляется  совсем  иначе,  нежели  с  текстовыми
файлами.  Существуют  и  иные  возможности  организации  записи  и
чтения  из  файла,  но  разговор  о  них  выходит  далеко  за  рамки  вводного
курса.
 Несколько  небольших  заданий
 При  выборе  в  меню  Файл  команды  Создать  текст  из  соответствующе¬
го  окна  исчезает.  Это  не  очень  удобно  для  пользователя.
 Запрограммируй  окно  InputBox  так,  чтобы  оно  сообщало  пользовате¬
лю  о  риске  потери  текста,  и  предоставляло  возможность  сохранить  его
в  файле  с  каким-нибудь  именем.
 Кроме  того,  при  выборе  команды  Выход  приложение  завершает  рабо¬
ту,  не  предлагая  пользователю  сохранить  введенный  текст.
 Напиши  небольшую  программу,  которая  предлагает  пользователю  вве¬
сти  имя,  состоящее  из  б  букв.  Затем  имя  выводится  в  окне  отладки  та¬
ким  образом,  чтобы  в  первой  строке  была  записана  первая  буква  име¬
ни,  во  второй  —  две  первых  буквы,  в  третьей  —  три  и  т.д.  Например,  ес¬
ли  пользователь  введет  имя  «Сергей»,  то  результат  выполнения  про¬
граммы  должен  выглядеть  так:
 С
 Се
 Сер
 Серг
 Серге
 Сергей
 На  этом  наш  курс  завершен.  В  следующей,  последней  главе  мы  погово¬
рим  о  том,  что  нужно  делать,  чтобы  закрепить  и  расширить  приобре¬
тенные  знания.

Заключение
 Итак,  ты  прочел  эту  книгу.  Я  надеюсь,  ты  продолжишь  заниматься  языком
Visual  Basic.  Было  бы  жаль,  если  бы  ты  потерял  приобретенные  знания.
 Если  ты  тщательно  изучил  и  проработал  все,  о  чем  говорилось  в  книге,
то  тобой  проделана  большая  и  полезная  работа.
 Как  я  тебе  уже  говорил,  самое  важное  заключается  в  том,  что
программированию  можно  научиться,  только  самостоятельно
создавая  программы.  Поэтому  пиши  их  как  можно  больше.
 Некоторые  предложения.
 Расширь  приложение  для  игры  в  мяч,  заставив  его  сталкиваться
с  препятствиями,  которыми  управлял  бы  пользователь.  Или'по¬
пробуй  написать  программу  для  игры  в  карты,  используя  симво¬
лы  карточных  мастей,  предоставляемые  системой  Visual  Basic
при  полной  установке  (вспомни  раздел  «Элементы  PictureBox  и
Image»  главы  3).  Наконец,  попробуй  ввести  в  текстовый  редактор
дополнительные  функции.  Возможностей  существует  бесконеч¬
но  много!
 Рекомендую  тебе  постоянно  пополнять  свои  знания.  В  книжных
магазинах  продается  масса  книг,  посвященных  языку  Visual
Basic.  Как  правило,  они  слишком  трудны  для  новичков.  Но  после
прочтения  этого  издания  тебе  стоит  взяться  за  них.
 Итак,  ты  видишь  —  работы  еще  очень  много.  Поверь  мне,  что  чем  лучше
знаешь  программирование,  тем  большее  удовольствие  оно  доставляет.
 Я  желаю  тебе  успеха  в  реализации  будущих  программных  проектов.

Приложение  А
 Установка  Visual  Basic  6.0
с  компакт-диска
 Прежде  чем  ты  приступишь  к  разработке  программ  и  выполнению  за¬
даний  из  книги,  тебе  необходимо  установить  на  компьютер  систему
Visual  Basic.  Я  подробно  объясню  тебе,  как  устанавливается  с  компакт-
диска  рабочая  версия,  обладающая  почти  всеми  возможностями  пол¬
ной  версии.  Единственное,  что  ты  не  сможешь  делать  с  ее  помощью,  —
создавать  программы,  которые  могли  бы  работать  независимо  от  сре¬
ды  Visual  Basic.  Но  эта  версия  вполне  подходит  для  того,  чтобы  выпол¬
нить  все  предложенные  в  книге  задания.  Таким  образом,  ее  возможно¬
стей  тебе  хватит  еще  надолго.
 Процедура  установки  программы  с  компакт-диска  сравнительно  про¬
ста.  Мы  пройдем  ее  шаг  за  шагом,  чтобы  избежать  вероятного  возник¬
новения  проблем.
 Вставь  приобретенный  компакт-диск  в  дисковод  для  компакт-дисков.
Программа  установки  должна  запуститься  автоматически.
 Если  этого  не  случится,  действуй  следующим  образом:  дважды  щелкни
мышью  значок  My  Computer  (Мой  компьютер),  расположенный  на  ра¬
бочем  столе  в  среде  Windows.  Появится  окно  с  перечнем  всех  дисков,
имеющихся  на  компьютере.  Дважды  щелкни  мышью  значок  дисковода
для  компакт-дисков.  При  этом  программа  установки  запустится  автома¬
тически,  либо  откроется  еще  одно  окно  со  списком  файлов  и  папок.
Дважды  щелкни  мышью  файл  SETUP.  EXE,  и  установка  начнется.

На  экране  появится  следующее  окно:
 Установка  системы  Visual  Basic  6.0  начинается
Нажми  кнопку  Next  (Далее).
 Появится  следующее  окно,  содержащее  условия  лицензионного  со¬
глашения.  Щелкни  мышью  переключатель  I  Agree  (Я  согласен),  чтобы
продолжить  установку.  Затем  нажми  кнопку  Next.
 В  поле  Name  (Имя)  следующего  окна  должно  быть  указано  твое  имя
(обычно  операционная  система  Windows  указывает  его  автоматичес¬
ки).  Если  поле  Name  пусто,  введи  свое  имя  и  нажми  кнопку  Next.
 Иногда  на  этом  этапе  появляется  окно  установки  программы  Microsoft
Internet  Explorer.  Ты  можешь  сохранить  все  параметры  по  умолчанию.
После  установки  данной  программы  компьютер  перезагрузится.
 Продолжи  установку  Visual  Basic.  Нажми  кнопку  Next  в  очередном  ок¬
не.  Компьютер  перезагрузится  еще  раз.  К  сожалению,  это  неизбежно
при  установке  современных  программ,  обращающихся  к  системным
файлам  Windows.

После  того  как  операционная  система  Windows  перезагрузится,  ты
увидишь  следующее  окно:
 Выбор  папки
 Выбери  в  нем  значение  по  умолчанию.  Затем  нажми  в  этом  и  следую¬
щем  окне  кнопку  Next.
 Программа  установки  покажет  тебе  идентификационный  номер  про¬
дукта  (Product  ID).  Внимательно  прочти  весь  текст  и  подтверди  свое  со¬
гласие  с  ним,  нажав  кнопку  ОК.

Следующее  окно  выглядит  так:
 Выбери  нужный  вариант
 В  нем  необходимо  указать,  в  какой  папке  следует  установить  програм¬
му  Visual  Basic.  Ты  можешь  либо  согласиться  с  выбором  по  умолчанию
(что  я  рекомендую  сделать),  либо,  нажав  кнопку  Browse  (Обзор),  вы¬
брать  другую  папку.
 Программа  установки  спросит,  создавать  ли  соответствующую  папку.
Нажми  кнопку  ОК.
 Далее,  необходимо  выбрать  тип  установки:  Standard  (Стандартный)
или  Custom  (Выбираемый  пользователем).  Для  того  чтобы  иметь  воз¬
можность  выполнить  все  примеры,  приведенные  в  этой  книге,  выбери
вариант  Custom.  Разница  между  ним  и  стандартным  вариантом  уста¬
новки  заключается,  прежде  всего,  в  том,  что  при  установке  типа
Custom  на  компьютер  будут  скопированы  определенные  графические
файлы,  которые,  хотя  и  занимают  много  места  на  жестком  диске,  бы¬
вают  очень  полезны.
 Если  ты  выбрал  установку  типа  Custom,  укажи  программе,  что  именно
следует  установить:

Выбор  компонентов
 Если  объем  свободной  памяти  компьютера  достаточно  большой,
нажми  кнопку  Select  All  (Выбрать  все),  а  затем  —  кнопку  Next.
 После  этого  программа  установки  начнет  копирование  необходимых
файлов  на  компьютер  и  настроит  систему  Visual  Basic  так,  чтобы  ты
смог  с  ней  работать.  По  окончании  этого  процесса  на  экране  появится
следующее  окно:

Нажми  кнопку  Restart  Windows  (Перезагрузить  Windows).
 Если  у  тебя  есть  доступ  к  Интернету,  то  ты  сможешь
зарегистрироваться  в  интерактивном  режиме.  Если  этого  не  требуется,
щелкни  мышью  соответствующую  надпись  для  отмены  регистрации.
 В  заключение  нажми  кнопку  Finish  (Готово),  чтобы  завершить
установку.

Приложение  В
 Установка  файлов  с  компакт-диска
 Если  для  выполнения  упражнений  тебе  понадобится  установить  с  при¬
обретенного  компакт-диска  те  или  иные  файлы,  я  объясню  тебе,  как
это  делается.  Пусть,  например,  на  компакт-диске  находится  несколько
папок.  Есть  два  способа  работы  с  ними:  либо  загружать  их  непосредст¬
венно  с  компакт-диска,  либо  копировать  на  жесткий  диск.
 Загрузка  файлов  с  компакт-диска
 Предположим,  что  в  папке  MYPR0GRAMS1  /EXAMPLES  находится  файл
TEST.VBP.  На  его  примере  я  покажу,  как  происходит  загрузка.  Для
остальных  файлов  порядок  действий  аналогичен.
 Выполни  следующие  действия:
 Запусти  систему  Visual  Basic  в  соответствии  с  указаниями,  данными  в
начале  главы  2.
 Выбери  в  пункте  меню  File  (Файл)  команду  Open  Project  (Открыть
проект).
 В  окне  Open  Project  укажи  компакт-диск.
 Дважды  щелкни  мышью  папку  MYPROGRAMS1,  а  в  ней  —  вложенную
папку  EXAMPLES.

Файлы  в  папке  Examples
 Дважды  щелкни  мышью  файл  TEST.VBP,  и  он  загрузится.
 Возможно,  пользовательская  оболочка  Visual  Basic  останется  пустой,
и  в  ней  не  будет  виден  загруженный  проект.  Тогда  действуй  следую¬
щим  образом.
 Справа  вверху  в  окне  пользовательской  оболочки  находится  окно  про¬
екта.  Вероятнее  всего,  оно  выглядит  так:
 Щелкни  мышью  знак  плюса  перед  папкой  Forms  (Формы).  Раскроется
список  отдельных  форм.  Пусть  в  данном  случае  он  состоит  из  одной
формы  TEST.  FRM.
 Окно  проекта
 Дважды  щелкни  мышью  эту  форму,  чтобы  открыть  ее  объектное  окно.

Запись  файлов  на  жесткий  диск
 Однако  более  рациональным  является  копирование  всех  файлов  на
жесткий  диск.  Тогда  обращение  к  ним  будет  происходить  быстрее,  в
процессе  работы  тебе  не  понадобится  всякий  раз  обращаться  к  ком-
пакт-диску  и,  кроме  того,  не  возникнет  проблем  с  внесением  измене¬
ний.
 Для  того  чтобы  скопировать  файлы  на  жесткий  диск,  необходимо  сде¬
лать  следующее.
 Создай  на  жестком  диске  новую  папку.  Для  этого  щелкни  мышью  рас¬
положенный  на  рабочем  столе  значок  My  Computer  (Мой  компьютер)
и  с  помощью  двойного  щелчка  мыши  выбери  нужный  диск  (если  у  тебя
их  несколько).  Укажи  в  меню  File  последовательно  команды  New  (Со¬
здать)  и  Folder  (Папку).  Назови  созданную  папку,  например,  УВПри-
меры.
 Щелкни  мышью  новую  папку,  чтобы  открыть  ее.
 Щелкни  правой  (!)  кнопкой  мыши  в  окне  My  Computer  значок  компакт-
диска  (щелчок  левой  кнопкой  приведет  к  запуску  программы  установки).
 В  появившемся  контекстном  меню  выбери  команду  Open  (Открыть).
На  экране  появится  список  всех  папок,  содержащихся  на  компакт-дис¬
ке.  Среди  них,  предположим,  находятся  папки  MYPROGRAMS1  и
MYPROGRAMS2.
 Выбери  с  помощью  левой  кнопкой  мыши  папку  MYPROGRAMS  1.  Затем
в  меню  Edit  (Правка)  выбери  команду  Сору  (Копировать).
 Перейди  в  ранее  созданную  папку.
 Выбери  в  пункте  меню  Edit  команду  Paste  (Вставить).  Все  файлы  ско-
пируются  в  эту  папку.
 То  же  сделай  и  с  папкой  MYPR0GRAMS2.
 Теперь  у  тебя  имеется  возможность  загружать  эти  файлы  в  среду
Visual  Basic  непосредственно  с  жесткого  диска  компьютера.

Если  ты  изменишь  эти  файлы  и  попытаешься  сохранить  изменения,  на
экране  появится  сообщение  об  ошибке:
 В  этом  случае  действуй  следующим  образом:
 Выбери  с  помощью  окна  My  Computer  нужный  файл  (например,
TEST.VBP)  и  щелкни  его  правой  кнопкой  мыши.  В  раскрывшемся
контекстном  меню  укажи  команду  Properties  (Свойства).
 На  экране  появится  следующее  окно:
 Установи  флажок  Read-Only  (Только  чтение).  Если  уже  установлен
флажок  Archive  (Архивный),  сними  его.  После  этого  ты  сможешь
вносить  в  файл  изменения.

Алфавитный  указатель
 Activate  152
Alignment  39,  53
Autosize  27
 BackColor  75
BackStyle  88
BorderStyle  39
Byte  67
 Caption  13,26
 Change  (работа  с  файлами)  202
Change  (свойство)  40
CheckBox  29
Checked  (свойство)  185
Click  57
 Close  (работа  с  файлами)  214
ComboBox  36,  117
 Debug  62
Dim  66
 DirListBox  199
Do  While  94
Drive  (свойство)  202
DriveListBox  199
 Else  82
Elself  84
 Enabled  43,  98,  147
End  20
EndDoc  182
Exit  Sub  81,  182
 FileListBox  199
Font  27
 FontBold  (свойство)  183
Fontltalic  (свойство)  187
FontUnderline  (свойство)  187
for  91
 Form_Load  133
Form_Load()  41,  102
Forml  13
Format  77
 FreeFile  (функция)  212
 if  36,82,  108
if  then  36
Image  48
InputBox  191,  195
Integer  67
 Interval  (свойство)  43
 GoTo  204
 Hide  146,215
 &,  символ  45

Label  24
 Left  (свойство)  88
Left  (функция)  210
Line  (инструмент)  112
ListBox  33
Load  41
 LOF  (функция)  213
Long  67
Loop
цикл  Do  While  94
 MultiLine  (свойство)  54
 On  Error  GoTo  203
Open  For  Input  211
Open  For  Output  218
Option  Explicit  66  ■
OptionButton  31
 Path  202
 Picture  (свойство)  48
PictureBox  48
Print  62,218
Printer  182
 RadioButton  31
Resize  175
RichTextBox  187
Right  (функция)  209
 ScaleHeight  107,  173
ScaleWidth  94,  173
ScrollBar  38
SetFocus  127
Shape  88
Show  120
Single  67
 Sorted  (свойство)  117
Step
цикл  for  93
Stretch  (свойство)  49
String  67,  209
 TextBox  24
Timer  42,  98
Top  (свойство)  100
Type  158
 Value  (свойство)  31
Variant  68
vbModal  121
Visual  Basic
запуск  11
определение  7
 WindowState  (свойство)  171
 Next
цикл  for  93

Аргумент  194
 База  данных  7,  114
 Выделение  управляющих  элементов  30,  53
Вычисления  в  Visual  Basic  68
 Деление  72
на  ноль  80
нацело  73
по  модулю  73
 чисел  с  плавающей  запятой  72
Держатели  25
Добавление  формы  119
 Запуск  программы  17
Знаки  после  запятой  72
 Игры  8
Индекс  116
 Калькулятор  51
Командная  кнопка  23
Комментарий  136
Комментирование  138
Компьютерная
графика  47,  89
программа  7
 Массив  115,160
Меню  170
 Многозадачность  211
Модуль  140
 Номер  файла  211
 Обратная  косая  черта  208
Объявление  переменной  66
Окно
объекта  19
 программного  кода  18
проекта  19,  131,  141
свойств  13
Оператор
постфиксный  58
присваивания  202
условный  124
Операторный  блок  91
Операционная  система  7
Опечатки  64
Опрос  столкновений  104
Открытие  файла  201
Ошибки  пользователя  203

Панель  инструментов  16,  23
Папки  23
 Переменная-счетчик  123
Переменные  61,  101
Private  135
Public  140
 область  определения  135
объединение  114
с  полями  115
цикла  92
Печать  182
 Планирование  программы  51
Пользовательская  оболочка  11
Постфиксный  оператор  58,  89,  129,  159,  183
Программирование  7
Прохождение  цикла  91
Процедура  149,192
вызов  152
 обработки  ошибок  203
 Секундомер  42
 Система  координат  в  Visual  Basic  87
Скобки  107
 Сохранение  программ  15
Стартовое  окно  11
Строка  меню  14
 Текстовый  редактор  170
Типы  данных  67,  156
определенные  пользователем  157
 Угол
 отражения  97,  105
падения  97,  105
Управляющие  элементы  23
изменение  размера  25
имя  26
 Уровни  разработки  программы  23
 Фокус  127
Функция  191
 Шрифт  90
 Язык  программирования  7
 Равенство  45
 Редактор  меню  175
 Режимы  выполнения  программы  51
 Цикл  90

Бернд  Вайланд
 В14 	Visual  Basic  6  для  детей:  Пер.  с  нем.  —  М.:  АО  «Интерэксперт»,  2002.  —  240  с.
 Изучение  языка  программирования  Visual  Basic  б  с  помощью  среды
разработки  Visual  Basic.  Создание  проектов,  описание  основных  уп¬
равляющих  элементов  и  их  свойств.  Работа  с  переменными:  объеди¬
нений  переменных,  область  определения,  использование  модулей,
массивы.  Создание  собственных  типов  данных  и  меню.
 Для  всех,  кто  начинает  осваивать  азы  программирования  на  языке
Visual  Basic.
 ISBN  5-85523-065-1
 УДК  087.5  :  004.434
ББК  32.973.26  =  018.1
В14

Научно-популярное  издание
 Бернд  Вайланд
 Visual  Basic  б  для  детей
 Редактор
 Корректор
 Верстка
 Автор  обложки
 Дизайн  русского  варианта
 В.  И.  Фомичёв
Н.  Е.  Аникина
Е.  А.  Никищихина
Дж.  Пулидо
И.  И.  Цыганова
 Подписано  в  печать  с  оригинал-макета  10.08.2001.
Формат  70x100/16.  Бумага  офсетная.
 Гарнитура  TextBook.  Печать  офсетная.  Уел.  печ.  л.  22,23
Заказ  4111.  Тираж  5000  экз.
 АО  «Интерэксперт»  (ЛР  №  090032  от  13.08.97)
 109548,  Москва,  ул.  Шоссейная,  д.  1,  корп.  1.  Тел.  (095)  179-49-71
 Отпечатано  в  полном  соответствии
с  качеством  предоставленных  диапозитивов
в  ОАО  «Можайский  полиграфический  комбинат».
 143200,  г.  Можайск,  ул.  Мира,  93.

Бернд  Вайланд
 Ты  хотел  бы  овладеть  компьютером?
 Тогда  изучай  программирование!  С  помощью  этой  книги
ты  шаг  за  шагом  постигнешь  мир  языка  Visual  Basic.
 Начав  с  самых  азов,  ты  постепенно  достигнешь  уровня
разработчика  небольших  профессиональных  программ.
Большое  количество  примеров  и  упражнений  делают
книгу  наглядной  и  понятной.
 Когда  ты  начнёшь  программировать,  она  станет
хорошим  подспорьем  в  твоей  работе!
 Кому  предназначена  эта  книга?
 Всем  тем,  кто  хочет  научиться  программированию.
Сколько  бы  тебе  ни  было  лет,  при  серьёзном  желании
такая  задача  окажется  по  плечу.
 Из  предварительных  знаний  требуются  только
основные  навыки  работы
в  операционной  системе  Windows.
 5-85523-065-
 785855
 230659
 Незаменимое  пособие  по  обучению
профессиональному
компьютерному  программированию
 Visual  Basic  6