Титульный
Содержание
Предисловие
Введение
1. Язык программирования visual basic
Что такое программирование
2. Вводный пример
Потихоньку осваиваемся
Первая программа
3. Управляющие элементы и их свойства
Два уровня разработки программы
Создание папки
Элементы Label и TextBox
Элементы CheckBox и OptionButton
Элементы ListBox и ComboBox
Элементы Scroll Bars
Таймер
Элементы PictureBox и Image
4. Первые шаги
Режимы выполнения программы
Понятие переменной
Вычисления в системе Visual Basic
Операция деления
Подсчет продолжается
Усложненная конструкция if
5. Дальнейшее изучение visual basic
Создание циклов
Игра в мяч
Цикл for
Циклы While
Еще один цикл While
Новое приложение «Игра в мяч»
Работа с таймером
Мяч продолжает скакать
6. Объединение переменных
Что такое масси в
Вторая форма
Переменные и их область определения
Потребность в модуле
Работа с процедурами
7. Создание собственных типов данных
База данных увеличивается
Объединение переменных
Расширение программы
Изменения в программном коде
8. Меню
Создание меню
Новые конкуренты корпорации Майкрософт
Полужирное начертание шрифта
Последний рывок
Возвращаемые значения
Функция InputBox
9. Работа с данными
Как открыть файл
Обработка ошибок
Операции с переменными типа String
Работа с файлами
Сохранение данных
Заключение
Приложение А
Приложение В
Алфавитный указатель
Аннотация
Выходные данные
Обложка 2
Text
                    Бернд  Вайланд  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