Саратовский госуниверситет им. Н. Г. Чернышевского Кафедра математического моделирования процессов и систем управления
...
78 downloads
186 Views
1MB Size
Report
This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form
Саратовский госуниверситет им. Н. Г. Чернышевского Кафедра математического моделирования процессов и систем управления
Основные понятия информатики
Учебное пособие по дисциплине Информатика и программирование
для специальностей ПИЭ и ПИЮ
Составители Амелин Р.В., Блинков Ю.А., Ковалев А.Д., Мозжилкин В.В.
Саратов 2003
1.
ОСНОВНЫЕ ПОНЯТИЯ ИНФОРМАТИКИ ......................................................................................4 1.1. 1.2. 1.3. 1.4. 1.5. 1.6. 1.7. 1.8. 1.9.
ПОНЯТИЕ «ИНФОРМАЦИЯ» ...................................................................................................................4 ПЕРЕХОД ОТ ПРЕДСТАВЛЕНИЙ К ИНФОРМАЦИИ...................................................................................5 ПРЕОБРАЗОВАНИЕ ПРЕДСТАВЛЕНИЙ....................................................................................................6 НОРМАЛЬНЫЕ ФОРМЫ...........................................................................................................................6 ЦЕПОЧКИ И ФОРМАЛЬНЫЕ ЯЗЫКИ........................................................................................................7 АЛГОРИТМЫ .........................................................................................................................................8 ФОРМАЛЬНОЕ ОПИСАНИЕ АЛГОРИТМА ТЕКСТОВЫХ ЗАМЕН. ..................................................................9 МОДЕЛИ И МОДЕЛИРОВАНИЕ. ............................................................................................................10 МЕТОДИКИ МОДЕЛИРОВАНИЯ...............................................................................................................10
2. ИНФОРМАЦИОННЫЕ ТЕХНОЛОГИИ И ПРОГРАММИРОВАНИЕ ............................................12 2.1. 2.2. 2.3. 2.4. 2.5. 3.
ИНФОРМАЦИОННЫЕ ТЕХНОЛОГИИ ........................................................................................................12 ПРОГРАММИРОВАНИЕ..........................................................................................................................12 АБСТРАКЦИЯ И ДЕКОМПОЗИЦИЯ ........................................................................................................15 МЕТОДОЛОГИИ ПРОГРАММИРОВАНИЯ ...................................................................................................16 ЯДРА МЕТОДОЛОГИЙ..........................................................................................................................17
ВЫЧИСЛИТЕЛЬНЫЕ СТРУКТУРЫ ................................................................................................18 3.1. 3.2. 3.3. 3.3. 3.4. 3.4. 3.5.
4.
ВЫЧИСЛИТЕЛЬНЫЕ ВЫЧИСЛИТЕЛЬНАЯ ВЫЧИСЛИТЕЛЬНАЯ ВЫЧИСЛИТЕЛЬНАЯ ВЫЧИСЛИТЕЛЬНАЯ ВЫЧИСЛИТЕЛЬНАЯ ВЫЧИСЛИТЕЛЬНАЯ
СТРУКТУРЫ ...........................................................................................................18 СТРУКТУРА СТРУКТУРА СТРУКТУРА СТРУКТУРА СТРУКТУРА СТРУКТУРА
BOOL. .............................................................................................19 UINT ...............................................................................................21 INT..................................................................................................23 SEQ .................................................................................................25 SET..................................................................................................26 FILE ...............................................................................................27
ЯЗЫКИ ПРОГРАММИРОВАНИЯ ВЫСОКОГО УРОВНЯ ......................................................................28
4.1. 4.2. 4.3.
СИНТАКСИС, ФОРМАЛЬНЫЕ ГРАММАТИКИ..........................................................................................28 СЕМАНТИКА. .....................................................................................................................................30 КОРРЕКТНОСТЬ ПРОГРАММ. ..............................................................................................................35
РАЗРАБОТКА ПРИЛОЖЕНИЙ В СРЕДЕ
VISUAL BASIC 6.0..............................................................39
ВВЕДЕНИЕ...........................................................................................................................................................39 1.
ИНТЕГРИРОВАННАЯ СРЕДА РАЗРАБОТКИ ................................................................................39 Toolbars - Панели инструментов ..............................................................................................40 Toolbox - Панель элементов управления..............................................................................40 Project Explorer Window - Окно проекта ...........................................................................40 Properties Window - Окно свойств..........................................................................................41 Object Browser - Каталог объектов .......................................................................................41 Form Designer - Конструктор форм..........................................................................................41 Code Editor Window - Редактор кода.....................................................................................41 Form Layout Window - Окно размещения форм ....................................................................41
2.
ПРОГРАММИРОВАНИЕ НА VISUAL BASIC.........................................................................................41 2.1 ПРАВИЛА КОДИРОВАНИЯ ........................................................................................................................41 Размещение операторов....................................................................................................................41 Комментарии............................................................................................................................................41 2.2 ПЕРЕМЕННЫЕ И КОНСТАНТЫ...................................................................................................................42 Типы переменных ..................................................................................................................................42 Объявление переменных....................................................................................................................43 Область определения переменных ..............................................................................................44 Массивы .....................................................................................................................................................44 Пользовательский тип данных .....................................................................................................45 Константы ................................................................................................................................................46 2.3 ОПЕРАТОРЫ ЯЗЫКА ................................................................................................................................46 Оператор присваивания....................................................................................................................46
Математические операторы.............................................................................................................46 Условные выражения...........................................................................................................................47 Условный оператор .............................................................................................................................47 Оператор выбора ..................................................................................................................................48 Цикл типа For.......................................................................................................................................49 Цикл типа While ..................................................................................................................................49 2.4 ПРОЦЕДУРЫ ...........................................................................................................................................49 3.
ЭЛЕМЕНТЫ УПРАВЛЕНИЯ........................................................................................................................54 3.1 ИСПОЛЬЗОВАНИЕ ЭЛЕМЕНТОВ УПРАВЛЕНИЯ ............................................................................................54 Свойства...................................................................................................................................................55 Методы .......................................................................................................................................................56 События .....................................................................................................................................................57 3.2 СТАНДАРТНЫЕ ЭЛЕМЕНТЫ УПРАВЛЕНИЯ .................................................................................................58 Кнопка (CommandButton) .................................................................................................................58 Надпись (Label) ..................................................................................................................................59 Текстовое поле (TextBox).............................................................................................................59 Флажок (CheckBox) .............................................................................................................................61 Переключатель (OptionButton) ...................................................................................................61 Список (ListBox)................................................................................................................................62 Поле со списком (ComboBox)........................................................................................................63 Полосы прокрутки (ScrollBar) ...................................................................................................63 Таймер (Timer) ....................................................................................................................................64 Список устройств (DriveListBox) ............................................................................................64 Список каталогов (Directory ListBox) ................................................................................65 Список файлов (FileListBox) .....................................................................................................65 Рамка (Frame).......................................................................................................................................66 Окно с рисунком (PictureBox) ...................................................................................................66 Изображение (Image) ........................................................................................................................67 3.3 АКТИВИЗАЦИЯ ЭЛЕМЕНТОВ УПРАВЛЕНИЯ................................................................................................67 3.4 МАССИВЫ ЭЛЕМЕНТОВ УПРАВЛЕНИЯ .......................................................................................................67 3.5 ФОРМЫ ...................................................................................................................................................68 Свойства формы ....................................................................................................................................68 События формы.......................................................................................................................................69 3.6 МЕНЮ .....................................................................................................................................................69 Правила составления меню.............................................................................................................70 Создание меню.......................................................................................................................................70 Правила назначения имени.............................................................................................................70 Свойства Visible, Enabled, Checked.....................................................................................71
4.
ВВЕДЕНИЕ В ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ .........................................71 4.1 АБСТРАГИРОВАНИЕ ................................................................................................................................71 4.2 ИНКАПСУЛЯЦИЯ......................................................................................................................................72 4.3 НАСЛЕДОВАНИЕ......................................................................................................................................72 4.4 ПОЛИМОРФИЗМ........................................................................................................................................73 4.5 МОДУЛЬ КЛАССА ....................................................................................................................................73 4.6 СВОЙСТВА .............................................................................................................................................73 4.7 ПРОЦЕДУРЫ СВОЙСТВ ............................................................................................................................74 Оператор Property Let....................................................................................................................74 Оператор Property Get....................................................................................................................74 Оператор Property Set....................................................................................................................75 4.8 МЕТОДЫ .................................................................................................................................................75 Синтаксис процедуры ........................................................................................................................75 Синтаксис функции .............................................................................................................................75 Мастер классов ....................................................................................................................................76 Использование.......................................................................................................................................76 4.9 СОБЫТИЯ ...............................................................................................................................................76 4.10 ОБЪЕКТЫ, ОПРЕДЕЛЯЕМЫЕ ПОЛЬЗОВАТЕЛЕМ .....................................................................................77 4.11 КАТАЛОГ ОБЪЕКТОВ ..........................................................................................................................78
4.12 РАННЕЕ И ПОЗДНЕЕ СВЯЗЫВАНИЕ .....................................................................................................78 4.13 СОБЫТИЯ INITIALIZE И TERMINATE ..............................................................................................79 4.14 ОПЕРАТОР IMPLEMENTS ....................................................................................................................79 4.15 ОБРАБОТКА ОШИБОК ..........................................................................................................................80 4.16 КОЛЛЕКЦИИ .......................................................................................................................................81 Методы и свойства .............................................................................................................................81 Мастер классов ....................................................................................................................................81 Цикл For Each...Next ......................................................................................................................81
1. Основные понятия информатики 1.1. Понятие «информация» Информатика включает в себя науку о машинной обработке информации. Это охватывает вопросы: -
схематизированного представления информации: структуры объектов и данных, а также их взаимосвязи;
-
правил и предписаний для обработки информации (алгоритмы, вычислительные предписания) и их представления, включая описание протекания работы (процессы, взаимодействующие системы).
Перед информатикой стоит задача представления, моделирования и использования самых различных видов информации. Так как машинная обработка информации, соответственно ее представления, требует точно установленных форм представления и преобразования, информатика пользуется формальными методами. Часто не осознается различие между информацией и ее представлением. Пример 1. Оператор цикла языка Basic For i = 1 To 10 x = x+1 Next i может быть истолкован различными способами: а) как строка символов; б) как набор лексем: ключевых слов For, To, Next; идентификаторов i, x; знака присваивания =, операции +; в) как оператор языка Basic; г) как цикл For языка Basic; д) как цикл, пошагово увеличивающий значение х на единицу. Т.о. информация имеет внешнюю форму и внутреннее смысловое содержание. Они связаны между собой соглашением о том, как трактовать ту или иную информацию. Информация (“содержательное значение”, ”семантика”) — абстрактное содержание какого-либо высказывания, описания, указания, сообщения или известия. Внешнюю форму изображения называют представлением (конкретная форма сообщения). Весьма важно установление способа выявление значения представления. Представление интерпретируется (истолковывается), чтобы получить информацию. Переход (часто только воображаемый, мыслимый) от представления к абстрактной информации, т.е. к значению представления, называется интерпретацией. Пример 2.
Строка символов примера 1 — это представление, допускающее неоднозначную интерпретацию. В применениях информатики обычно рассматривается точное описание множества R представлений c интерпретацией I в множестве А элементов (информаций). Интерпретация I данному представлению (сообщению) r∈R ставит в соответствие некоторое абстрактное информационное содержание I(r). Таким образом, интерпретации соответствует отображение I: R → A. Через (A,R,I) мы будем обозначать информационную систему. Таким образом, информационная система соответствует понятию отображения из математики. R называют также системой представлений, а A — семантической моделью.
1.2. Переход от представлений к информации. Обработка информации означает, строго говоря, обработку или преобразование представления информации. Для этого требуется, чтобы в применяемой информационной системе была представлена любая информация. Пусть (A,R,I) - информационная система. Если отображение I – сюръективно, т. е. для каждой информации a∈A существует представление r∈R c I(r)=a, то каждая информация имеет представление. Обычно информационные системы обладают этим свойством. Отображение на множестве представлений при определенных предположениях индуцирует и отображение информации. Пусть ρ:R→R — отображение на множестве представлений R. Если для всех x, y∈R справедливо: I(x)=I(y) ⇒ I(ρ(x))=I(ρ(y)),
(1)
а I сюръективно, то вследствие интерпретации I:R→A однозначным образом устанавливается отображение информации σ:A→A по следующему правилу: σ(a)=b, если для r∈R справедливо I(r)=a, I(ρ(r))=b. Условие (1) устанавливает, что отображение σ определено подходящим образом. Оно говорит, что отображение ρ совместимо с отношением эквивалентности, индуцированным с помощью отображения I: если два представления интерпретируются одинаково, т.е. они несут одну и ту же информацию, то и их образы над ρ также интерпретируются одинаково. Это означает, что семантическая эквивалентность относительно отображения ρ является отношением конгруэнтности. Сюръективность I обеспечивает, что также любая информация представима. Связь между ρ, σ и интерпретацией можно пояснить коммутирующей диаграммой:
R
I
ρ
σ R
Также справедливо:
A
I
A
I(ρ(r))=σ(I(r)). Часто σ называют абстракцией
ρ.
Рассмотрим коммутирующую диаграмму применительно к компьютерной обработке данных. Термин семантика отнесем к формальному представлению знаний о предметной области, реализованных в программной системе. Термин прагматика относится к неформальной в общем случае информации о предметной области, содержащихся в знаниях конкретных пользователей.
Прагматика определяется целью разработки программной системы: для обслуживания клиентов банка, для управления работой аэропорта, для обслуживания чемпионата мира по футболу и т.п. В формулировке цели участвуют предметы и понятия реального мира, имеющие отношение к разрабатываемой программной системе (см. рисунок 1.1). При объектно-ориентированном подходе эти предметы и понятия заменяются их моделями, т.е. определенными формальными конструкциями, представляющими их в программной системе
Реальный мир U
Прагматика
V
Input
Output
u
Семантика
v
Прагматика
Рис. 1.1. Семантика (смысл программы с точки зрения выполняющего компьютера) и прагматика (смысл программы с точки зрения ее пользователей)
ее
1.3. Преобразование представлений. Для заданной информационной системы (R,A,I) переход от одного представления r1∈R к другому r2∈R называется эквивалентной трансформацией, если r1 и r2 обладают одинаковой интерпретацией и тем самым являются семантически эквивалентными, т. е. справедливо I(r1)=I(r2). Пример 1. а) Даны два булевских терма t1=p, t2=¬¬p. представляет собой эквивалентную трансформацию.
Очевидно, редукция t2 | t1
б) В языке арифметических выражений обычное вычисление образует систему эквивалентных трансформаций. Понятие эквивалентной трансформации согласно определению зависит от рассматриваемой интерпретации. Если для отображения f:R→R имеет место, что для всех r∈R I(f(r))=I(r), то отображение f называют также эквивалентной трансформацией. Эквивалентная трансформация всегда переводит представления в семантически эквивалентные представления.
1.4. Нормальные формы. Информация представляется не непосредственно, а лишь изображается какимто образом. Однако не все эквивалентные представления определенной информации одинаково легко интерпретируются или обрабатываются. Пример 1. Следующие смысле:
формулы
семантически ∞
∑1 / 2
i
,
эквивалентны
0.99999999.... ,
в
обычном
математическом
1.
i =1
Все они имеют значение «1». Однако они различаются с точки зрения простоты чтения и понимания.
Простота конкретного изображения информации имеет важное значение по понятным причинам. Часто подмножество S ⊆ R изображений достаточно простой внешней формы выделяется как множество нормальных форм. Тогда S называется системой нормальных форм. Если в такой системе для каждого изображения существует по крайней мере одна семантически эквивалентная нормальная форма, то система нормальных форм называется полной. Пусть S⊆R – система нормальных форм. Если любое множество с одинаковой интерпретацией имеет единственную нормальную форму, т. е. отображение I|s инъективно, то система нормальных форм называется однозначной. Здесь I|s: S → A означает ограничение отображения I на S c I|s(r)=I(r) ∀ r∈R. Пример 2. Во множестве натуральных чисел в десятичной системе счисления множество непустых последовательностей цифр без ведущих нулей образует однозначную нормальную форму. Так как на множестве однозначных нормальных форм интерпретация есть инъективное отображение, то соответствующую информацию можно отождествить с ее нормальной формой.
1.5. Цепочки и формальные языки. Алфавитом будем называть любое множество символов. Термины буква или знак будем использовать как синонимы термина символ. Цепочкой символов (или строкой) называют произвольную последовательность символов, записанных один за другим. Цепочки символов α и β равны (совпадают), α = β, если они имеют один и тот же состав символов, одно и то же их количество и одинаковый порядок следования символов в цепочке. Существует одна цепочка, которая часто встречается и потому имеет специальное обозначение. Это пустая цепочка – цепочка, не содержащая ни одного символа. Она обозначается символом e. Формально цепочки в алфавите Σ определяются следующим образом: (a)
е — цепочка в алфавите Σ;
(b)
если α — цепочка в Σ и x∈Σ, то αx — цепочка в Σ;
(c)
β - цепочка в Σ тогда и только тогда, когда она является таковой в силу (a,b), т.е. других правил порождения цепочек нет.
Определим операции над цепочками. Если α и β – цепочки, то цепочка αβ называется конкатенацией или сцеплением α и β. Для любой цепочки α всегда αе = еα = α. Пример 1. α = «ab», β = «bcd», αβ = «abbcd». Обращением цепочки α (обозначается αR) называется цепочка α, записанная в обратном порядке: если α = x1x2...xn, то αR = xnxn-1...x1, где xi (i = 1,2,...,n) - символы Обращение пустой строки есть пустая строка. Пусть α,β,γ — произвольные цепочки в алфавите Σ. Назовем α префиксом цепочки αβ, а β - суффиксом цепочки αβ. Цепочку β назовем подцепочкой цепочки αβγ. Заметим, что пустая цепочка является префиксом, суффиксом и подцепочкой любой цепочки. Количество символов в цепочке символов α обозначается как |α|.
называют
длиной
цепочки.
Длина
цепочки
Языком в алфавите Σ называется множество цепочек в Σ.
1.6. Алгоритмы Алгоритм — это способ применения эффективных, практически выполнимых элементарных шагов с точным, т.е. выраженным в точно определенном языке, конечным описанием. Это неточное определение. Оно зависит от понимания использованных в нем понятий “эффективный”, “элементарный шаг” и т.д. Существует много разных возможностей описания алгоритма. Независимо формы его описания для алгоритма важно различать следующие аспекты: •
постановку задачи, которая должна быть решена с помощью алгоритма;
•
специфичный способ, каким решается задача, при этом различают: (a)
элементарные шаги обработки, которые имеются в распоряжении;
(b)
описание выбора отдельных подлежащих выполнению шагов.
от
Алгоритм для какой-либо задачи называется: терминистическим (завершающимся, применимым), если он для всех допустимых последовательностей шагов заканчивается после конечного числа шагов; детерминистическим, если нет никакой свободы в выборе очередного шага обработки; детерминированным, если результат алгоритма определен однозначно; последовательным, если шаги обработки всегда выполняются друг за другом; параллельным, одновременно
если
некоторые
шаги
обработки
могут
выполняться
Алгоритм имеет пять важных свойств. Конечность. Алгоритм всегда конечного числа шагов.
должен
заканчиваться
после
выполнения
Определенность. Каждый шаг алгоритма должен быть точно определен. Наличие входных данных. Алгоритм имеет некоторое число входных данных, задающихся до начала его работы или определяющихся динамически во время его выполнения. Наличие выходных данных. Алгоритм имеет одно или несколько выходных данных, имеющих определенную связь с входными данными. Эффективность. Алгоритм обычно считается эффективным, если его операторы (элементарные шаги) достаточно просты для того, чтобы их можно было бы выполнить в течении конечного промежутка времени с помощью карандаша и бумаги. Большинство алгоритмов, с которыми работают программисты, являются полиномиальными. Это означает, что время работы алгоритма на входе длины n составляло не более O(nk) для некоторой константы k, не зависящей от n. Не всякая задача может быть решена за полиномиальное время. Некоторые решаются лишь за экспоненциальное время, а некоторые вообще не могут быть решены любым алгоритмом. Имеется особый класс задач, называемый “NP-полными” задачами. Для этих задач не известны полиномиальные алгоритмы, однако и не доказано, что таких алгоритмов не существует. Для программиста знание о NP-полных задачах важно по следующей причине. Если для некоторой задачи удалось показать, что она NP-полная, то есть основания считать ее практически неразрешимой. В этом случае лучше потратить время на построение приближенного алгоритма, чем продолжать искать быстрый алгоритм, решающий ее точно.
Программист должен помнить, что алгоритмически разрешимых задач хоть и бесконечно много, но сравнительно мало — всего счетное число. Да и среди алгоритмически разрешимых большинство задач экспоненциальной сложности.
1.7. Формальное описание алгоритма текстовых замен. Обозначим через Σ* множество, содержащее все цепочки в алфавите Σ, включая пустую цепочку. Множество всех цепочек в Σ, за исключением е обозначается Σ+. Для точного описания алгоритма, которое допускало бы компьютерную обработку, требуется формальный язык для записи алгоритма и точное определение эффективности элементарных шагов обработки. Одной из простейших концепций элементарных шагов обработки является замена подцепочек. На этом принципе построены алгоритмы текстовых замен на последовательности знаков. Пусть V - алфавит. Пара (v,w)∈V*×V* называется заменой над V. Замена записывается в виде v→w. Конечное множество R замен будем называть системой текстовых замен (СТЗ) над V. Элементы этой системы будем называть правилами текстовых замен (ПТЗ). Замена s→t называется применением правила v→w, a,v,w,z∈V*, такие, что справедливо s=avz, t=awz.
если
имеются
цепочки
Слово s∈V* называется терминальным в R, если не существует слова t∈V* такого, что справедливо следующее: замена s→t является применением какого либо правила из R. Таким образом, к терминальному слову s нельзя применить никакого правило замены. Пример 1. R = {«ак»→«ила»}. Тогда «жак»→«жила» и последнее слово является терминальным. Если t0,t1,...,tn∈R*, и ti→ti+1 есть применение правила ri∈R, то эту последовательность называют конечным вычислением (последовательностью вычислений) и записывают следующим образом: t0→t1→t2…→tn. Слово t0 - вход для вычисления. Если tn - терминал, то вычисление называется завершающим с результатом tn. Слово tn - выход для R со входом t0. Пример 2. (a)
V = {L,O} , R = {«LL»→e, «O»→e}. Завершающееся вычисление с результатом L: «LOLL»→«LO»→«L».
(b)
V = {L,O} , R = {«O»→«OO», «O»→«L»}. Завершающееся вычисление с результатом LL: «O»→«OO»→«OL»→«LL». Незавершающееся вычисление: «O»→«OO»→«OOO»...
Система текстовых замен R в V определяет следующий алгоритм текстовых замен (АТЗ): Если одно из правил множества R применимо ко входному слову t∈V*, то применим к нему это правило. В результате получим t→s. Затем опять применим этот алгоритм к s. Алгоритм прекращается, если в R нет подходящей к очередному слову замены. Пример 3. Сложение двух натуральных чисел, представленных вертикальными черточками . R={>+ y = ¬( x ≤ y ) ,
x =UINT y = ( x ≤ y ) ∧ ( y ≤ x) . В последнем равенстве, поскольку равенство (=) употреблялось в различном смысле (контексте), для устранения неоднозначности было использовано «полное имя» функции =UINT. Очень важно сразу научиться обращать внимание на контекст. В программировании всегда стоит дилемма: использовать полное описание и в результате получить громоздкую программу или использовать контекст, и давать полные имена только, когда это необходимо для устранения неоднозначности. Как и при описании вычислительной структуры BOOL набор правил является избыточным. Главное чтобы он был полным, т.е. любое соотношение между функциями являлось комбинацией представленных. Надо также стремиться не делать данный набор слишком большим. Для контроля за ошибками (в данном случае это отсутствие полноты) удобно использовать лексикографический порядок. Выше мы считали операцию next старше prev, и все правила использовали именно эту операцию, хотя с помощью prev(next(x))=x они могли бы быть переписаны и через prev. Аналогично поступили с операциями сравнения. Полностью описав ≤, и считая её старшей, все остальные связи для функций сравнения мы показали через нее и операции вычислительной структуры BOOL.
3.3. Вычислительная структура INT В силу важности целых чисел для программирования рассмотрим вычислительную структуру INT: UINT = (S, F) S = {bool, int}, F = {true, false, ¬,∧,∨, zero, next, prev, +,-,*,\, mod ,≤,≥,,=} Множество носителей, сопоставленное типу int, пусть состоит из следующих символов: intINT = {...,-1, 0, 1,...}∪{ ⊥}. Для представления сигнатуры функций (задания типов входных и типа выходного аргумента) воспользуемся диаграммой сигнатуры построенной для вычислительной структуры UINT, заменив формально тип uint на int. Это пример
когда сигнатуры совпадают для различных вычислительных структур, хотя набор связей между функциями может значительно различаться. ∀ x, y ∈ intINT выполнены следующие равенства:
zero = 0 , prev(next ( x)) = x , x + zero = x , x + next ( y ) = next ( x + y ) [ y ≥ 0] , x + y = x − y [ y < 0] , x − zero = x , x − next ( y ) = prev( x − y ) [ y ≥ 0] , x − y = x + y [ y < 0] , x * zero = zero , x * next ( y ) = x * y + x x * prev( y ) = x * y − x
[ y ≥ 0] [ y ≤ 0]
x \ zero =⊥ ,
[(0 ≤ x ∧ x < y) ∨ ( y < x ∧ x ≤ 0)] , x \ y = next (( x − y ) \ y ) [ ( x ≥ y ∧ y > 0) ∨ ( x ≤ y ∧ y < 0) ] , x \ y = prev(( x + y ) \ y ) [ ( x ≥ 0 ∧ y < 0) ∨ ( x ≤ 0 ∧ y > 0) ] , x \ y = zero
x mod zero =⊥ , x mod y = x [ (0 ≤ x ∧ x < y ) ∨ ( y < x ∧ x ≤ 0) ] , x mod y = next (( x − y ) mod y ) [ ( x ≥ y ∧ y > 0) ∨ ( x ≤ y ∧ y < 0) ] , x mod y = prev(( x + y ) mod y ) [ ( x ≥ 0 ∧ y < 0) ∨ ( x ≤ 0 ∧ y > 0) ] , next ( x) ≤ next ( y ) = x ≤ y ,
x≥ y = y ≤ x, x < y = ¬( y ≤ x ) , x > y = ¬( x ≤ y ) ,
x = INT y = ( x ≤ y ) ∧ ( y ≤ x) . При написании связей между функциями, в отличие от вычислительной структуры UINT, положен принцип симметрии. Введение дополнительных правил, если имеется произвол при написании, позволяет избежать ошибок и опечаток. Этот принцип очень часто используется в различных аспектах программирования.
3.4. Вычислительная структура SEQ Одной из вычислительных структур, в явном или неявном виде используемой в различных языках программирования, служит понятие последовательности. При ее формулировке сразу возникает проблема параметризации. Поскольку последовательности могут образовывать элементы любого типа, будем рассматривать вычислительную структуру SEQ с типом m в качестве параметра: SEQ m = (S, F) S = {bool, uint, m, seq m} F = {true, false, ¬,∧,∨, zero, next, prev, +,-,*,\, mod ,≤,≥,,=UINT,=m, empty, make, o, first, last, rest, lrest, length, =SEQ m} SEQ m содержит в качестве типов вычислительные структуры BOOL и UINT. Множество носителей, сопоставленное типу seq m, пусть состоит из следующих символов: seq mSEQ
m
= {m}*∪{⊥}.
Представленные на диаграмме функции выполняют следующие действия: empty конструирует пустую последовательность. make создает последовательность из одного элемента. Операция o сливает последовательности. first возвращает первый элемент, а last последний. rest возвращает последовательность без первого элемента, а lrest соответственно без
последнего. lenght дает количество элементов последовательности. =m сравнивает элементы последовательности, а =SEQ m — сами последовательности. ∀ x ∈ mSEQ
m
и ∀ y, z ∈ seq mSEQ
m
выполнены следующие равенства:
empty = , make( x) =< x > , y o empty = y , yoz = zo y,
first (empty ) =⊥ , first (make( x) o y ) = x , last (empty ) =⊥ , last ( y o make( x)) = x , rest (empty ) =⊥ , rest (make( x) o y ) = y , lrest (empty ) =⊥ , lrest ( y o make( x)) = y , length(empty ) = 0 , length(make( x) o y ) = next (length( y )) , empty = SEQ m empty = true , y = SEQ m empty = false empty = SEQ m z = false
[¬( y = empty)] , [¬( z = empty)] ,
y = SEQ m z = ( first ( y ) = m first ( z )) ∧ (rest ( y ) = SEQ m rest ( z ))
[¬( y = empty) ∧ ¬( z = empty)] 3.4. Вычислительная структура SET Одна из вычислительных структур может использоваться для имитации другой вычислительной структуры. Данный подход часто используется в программировании. Таким образом поступают при моделировании разнообразных данных возникающих в задачах с помощью ограниченного набора базовых типов, которые поддерживаются архитектурой компьютера. Рассмотрим одну из основных структур математики — вычислительную структуру множества SET с элементами типа m, смоделированную SEQ m: SET m = (S, F) S = {bool, uint, m, seq m} F = {true, false, ¬,∧,∨, zero, next, prev, +,-,*,\, mod ,≤,≥,,=UINT,=m, empty, make, o, first, last, rest, lrest, length, =SEQ m,
∅, {}, ∈, ∪, ∩, ⊂, ⊆, Card, =SET m} SET m содержит в качестве типов вычислительные структуры BOOL, UINT и SEQ m.
При построении диаграммы сигнатур не будем изображать структуры BOOL и UINT подробно, заменив их овалами. Тип seq m будет заменен типом set m:
Связи между функциями определим через функции seq m. ∀ x ∈ mSET
m
и ∀ y, z ∈ seq mSET
m
выполнены следующие равенства:
∅ = empty , {x} = make( x) , x ∈∅ = false , x ∈ y = ( x = m first ( y )) ∨ ( x ∈ rest ( y )) [ ¬( y = empty ) ] , y ∪∅ = y, y ∪ z = make( first ( z )) o ( y ∪ rest ( z )) [ ¬( first ( z ) ∈ y )] , y ∪ z = y ∪ rest ( z )
[ first ( z ) ∈ y ] ,
y ∩ ∅ = empty ,
[¬( first ( z ) ∈ y )] , y ∩ z = make( first ( z )) o ( y ∩ rest ( z )) [ first ( z ) ∈ y ] , y ∩ z = y ∩ rest ( z )
∅ ⊆ z = true , y ⊆ z = ( first ( y ) ∈ z ) ∧ (rest ( y ) ⊆ z ) [ ¬( y = empty ) ] , y = SET m z = ( y ⊆ z ) ∧ ( z ⊆ y ) , y ⊂ z = ( y ⊆ z ) ∧ ¬( y = SET m z ) , Card ( y ) = length( y ) . 3.5. Вычислительная структура FILE
Вычислительные структуры не обязательно представляют математические объекты или типы данных языков программирования. Они могут моделировать всевозможные редакторы, окна Windows, калькуляторы и т.д. Рассмотрим в качестве характерного примера вычислительную структуру FILE. Для демонстрации приведем диаграмму сигнатур и краткое описание функций и типов данных. В реальных операционных системах вычислительная структура FILE значительно сложнее.
Тип attribute используется при создании (create), копировании (copy), переносе (move). Тип attribute сильно зависит от операционный системы. Обычно это множество состоит из следующих свойств (property): скрытый, системный, только для чтения и т.д. Вычислительная структура строк STRING представляет набор всевозможных операций со строками и представляет собой специализированное свойство типа file. Аналогичным специализированным свойством выступает размер файла. Его предоставляет функция length. Содержимое файлов может быть сравнено с помощью функции compare. При удалении (delete) файла он перестает существовать. Для обозначения в этом случае, того что функция не возвращает значения, использовался пустой круг.
4. Языки программирования высокого уровня 4.1. Синтаксис, формальные грамматики. Для представления алгоритмов, предназначенных для выполнения на ЭВМ, используются языки программирования (ЯП). Внешняя форма программы на ЯП устанавливается с помощью синтаксиса языка , который определяет формальный язык. Он определяется с помощью определенных грамматических правил, аналогичных алгоритму текстовых подстановок. Основой формального определения синтаксиса являются формальные грамматики. Синтаксис языка — это набор правил, определяющих допустимые конструкции языка. Синтаксис определяет «форму языка» — задает набор цепочек символов, которые принадлежат языку. Семантика языка — это раздел языка, определяющий значение предложений языка. Семантика определяет «содержание языка» — задает смысловое значение для всех допустимых цепочек языка. Грамматика — это описание способа построения предложений некоторого языка. Иными словами, грамматика — это математическая система, определяющая язык.
Грамматику языка можно описать различными способами: например, грамматика русского языка описывается довольно сложным набором правил. Правило — это упорядоченная пара цепочек символов (α, β). В правилах очень важен порядок цепочек, поэтому их чаще записывают в виде α→β. Формально грамматика G определяется как четверка (N, T, P, S), где •
N — конечное множество нетерминальных символов или нетерминалов;
•
T — конечное множество терминальных символов или терминалов, причем N∩T=∅;
•
P — конечное множество правил грамматики вида α→β, где (α , β) ∈
•
( N U T )* N ( N U T )* × ( N U T )* .
S — символ из N, называемый начальным символом.
Множество V = N∪T называют полным алфавитом грамматики G. Каждый символ множества N может встречаться в цепочках как левой, так и правой частей правил грамматики, но он обязан хотя бы один раз быть в левой части хотя бы одного правила. Правила грамматики строятся так, чтобы в левой части каждого правила был хотя бы один нетерминальный символ. Пример 1. Дана грамматика G =({A, S}, {0, 1}, P, S), где P = {S→0A1, 0A→00A1, A→e}. Нетерминальными символами являются A, S, а терминальными
0, 1.
Грамматика определяет язык рекурсивным образом посредством задания особого рода выводимых цепочек. Выводимые образом:
цепочки
грамматики
G
=
(N,
T,
P,
S)
определяются
•
S — выводимая цепочка;
•
Если αβγ — выводимая цепочка, и β→δ содержится в Р, то αδγ - тоже выводимая цепочка
Выводимая цепочка грамматики G, не содержащая нетерминальных называется терминальной цепочкой, порождаемой грамматикой G. Язык, порождаемый грамматикой G цепочек, порождаемых грамматикой G.
(L(G))
-
это
множество
следующим
символов,
терминальных
Пусть G = (N, T, P, S) — грамматика, V = N∪T — ее алфавит. α,β,γ ∈ V*, δ ∈ V+. Цепочка ϕ = αβγ называется непосредственно выводимой из ψ = αδγ в грамматике G, если в G существует правило δ→β ∈ P. Обозначается ψ ⇒G ϕ. В тех случаях, когда из контекста ясно, о какой грамматике идет речь, нижний индекс G будем опускать. Иными словами, цепочка ϕ непосредственно выводима из ψ, если можно взять несколько символов в цепочке ψ, заменить их на другие символы согласно правилу грамматики и получить цепочку ϕ. Любая из цепочек δ и β (или обе они) может быть пустой. В предельном случае вся цепочка ψ может быть заменена на цепочку ϕ, тогда в грамматике G должно существовать правило ψ→ϕ ∈ P. Через ⇒k будем обозначать k-ю степень отношения ⇒. Иначе говоря, α⇒kβ , если существует последовательность α0,α1, α2,…, αk, состоящая из k+1 не обязательно различных цепочек, для которых α=α0, αi-1⇒αI, 1≤i≤k и αk=β. Эта последовательность называется выводом длины k цепочки β из цепочки α в грамматике G. Введем отношение ϕ⇒+ψ означающее, что цепочка ψ выводима из ϕ нетривиальным образом: ϕ⇒+ψ тогда и только тогда, когда ϕ⇒iψ для некоторого i≥1.
Говорят, что цепочка ψ выводима из ϕ (обозначение ϕ⇒*ψ)тогда и только тогда, когда ϕ⇒iψ для некоторого i≥0. Вывод называется законченным, если на основе цепочки ϕ, полученной в результате вывода, нельзя больше сделать ни одного шага вывода. Иначе говоря, вывод называется законченным, если цепочка ϕ пустая или содержит только терминальные символы грамматики G = (N, T, P, S). Цепочка, полученная в результате законченного вывода, называется конечной цепочкой вывода. Грамматики можно классифицировать по виду их правил. Грамматика G = (N, T, P, S) называется •
праволинейной, если каждое правило из Р имеет вид A→αB или A→α, где A,B∈N, α∈V*;
•
контекстно-свободной (бесконтекстной), если каждое правило из Р имеет вид A→α, где A∈N, α∈V*;
•
контекстно-зависимой (неукорачивающей), если каждое правило из Р имеет вид α→β, где α≤β.
Грамматика, не удовлетворяющая ни одному из указанных ограничений, называется грамматикой общего вида или грамматикой без ограничений. Пример 2. Праволинейная грамматика G1=({S}, {0, 1}, {S→0S|1S|e},S) L(G1)={0,1}*.
порождает язык
Пример 3. Пусть G2=({E, T, F}, {a, +, *, (, )}, P, E), где Р состоит из правил E→E+T|T T→T*F|F F→(E)|a Язык L(G2) представляет собой множество арифметических выражений, построенных из символов a, +, *, (, ). Грамматика G2 — контекстно-свободная. Пример 4. Пусть G3=({C, B, S}, {a, b, c}, P, S), где Р состоит из правил S→aSBC|abC CB→BC bB→bb bC→bc cC→cc Эта грамматика порождает зависимая грамматика.
язык
{anbncn|
n≥1}.Очевидно,
это
контекстно-
Для записи синтаксиса конструкций языков программирования часто используют форму Бэкуса-Наура. Она практически ничем не отличается от нотаций продукций формальных грамматик, только вместо знака → используется обозначение ::=. Пример 5. Десятичное целое без знака. ::=| ::=0|1|2|3|4|5|6|7|8|9
4.2. Семантика.
Для однозначного описания семантики целесообразно выбрать математическую форму описания, т. е. сопоставление математических объектов для описания конструкций языка. Язык программирования предоставляет как простые операторы, так и методы композиции, которые позволяют формировать структурные операторы из других простых или составных операторов. Поэтому для описания семантики языка программирования нужно решить две связанные между собой задачи. 1. Определить виды используемых в языке программирования простых операторов, а также часто используемые методы композиции решений подзадач. 2. Обеспечить правила вывода, позволяющие определить эффект воздействия простого оператора на состояние вычисления, а также вывести определенные свойства составного оператора из свойств составляющих его компонент. Ниже мы проиллюстрируем формальное определение семантики на простого модельного языка содержащего основные конструкции и композиции, встречающиеся в современных языках программирования .
примере правила
Фундаментальное свойство основных правил композиции современных языков программирования заключается в том, что они дают возможность объединить в одну сложную структурную схему с одним входом и одним выходом, которая имеет вид, изображенный на рис. 3.1 P
Q
Рис 3.1. Здесь S — оператор, группа операторов или программа; Р — предусловие — логическое выражение, которое должно быть истинным перед выполнением S; Q — постусловие — логическое выражение, которое должно принимать истинное значение при выходе из вычислений S. Если ввести в язык понятие комментария как произвольного текста, заключенного в фигурные скобки, то свойство, изображенного на рис 3.1. можно в тексте программы записать как: (1)
{P} S {Q}
Это — спецификация программы S со следующим смыслом: если соотношение Р истинно перед выполнением S, то Q будет истинно после выполнения S. Пусть Р некоторое логическое выражение. Для простоты будем полагать, что кванторы всеобщности и существования не принадлежат Р. Для выражения ∀x(P ) считаем, что вхождение переменной х в ∀x связано квантором всеобщности и каждое вхождение х в Р –связанное значение. Та же терминология применяется к выражению ∃x (P) , за исключением того, что в этом случае вхождение переменной х в ∃x называют связанным квантором существования. Каждое вхождение переменной х в логическое выражение, которое не связано квантором , называют свободной переменной этого выражения. Пример 1 •
все переменные в выражении
¬∃x(∀y ( y ≤ x)) связаны;
•
все переменные в выражении
(i < j ) = ( j < k ) свободны.
Определим понятие подстановки. Пусть P - логическое выражение. Нотация (2)
Pyx
используется для выражения, которое получается в результате систематической подстановки выражения у вместо всех свободных вхождений переменной х в Р. Аналогично (3)
Pyx11......ynxn
обозначает одновременную подстановку вместо всех свободных вхождений любой переменной xi в P соответствующего выражения yi. Вхождения xi в некоторые yi не замещаются. Переменные x1...xn должны быть различными, в противном случае подстановка не определена. Пример 2.
( z = 10) zx + y = ( x + y = 10) ( x + x + y ) ax ,+yb ,c = a + b + a + b + c ( x + x + y ) xx ,+yy , z = x + y + x + y + z Правила вывода - это схемы рассуждений, позволяющие доказывать свойства программы. Они имеют следующий вид:
H 1 ,..., H n H
(4)
Если H1,…,Hn — истинные утверждения, то H — также истинное утверждение. Рассмотрим правила вывода для простых операторов языка программирования. Пустой оператор Он не оказывает никакого воздействия на значения программных переменных. Для любого P имеем правило вывода (5)
{P}{P}
Оператор присваивания Он имеет вид x = e и устанавливает значение переменной x равным значению выражения e. Тогда для любого P (6)
e
{ Pч } x:=e { P }
Пример 3. {x+y=10} z:=x+y {z=10} {x-y>0} x:=x-y {x>0} Рассмотрим правила вывода для более сложных конструкций - составных и условных операторов. Составной оператор Он образуется путем последовательной композиции операторов S1; S2;…;Sn. Знак ; используется для соединения операторов в последовательность. В модельном языке составной оператор (или блок операторов) представлен программной конструкцией: (7)
begin S1; S2;…;Sn end
Правило вывода для составного оператора имеет вид: (8)
∀i = 1,..., n{Pi −1} S i {Pi } {P0 } begin S1 ; S 2 ;...; S n end {Pn }
Пример 4. Дан составной оператор Z: = z+y u := u-1 Известно постусловие Q = (z+u*y = x*y, u≥0) Тогда согласно правилу вывода для оператора присваивания легко установить {z+(u-1)*y = x*y, u-1≥0} u := u-1 {z+u*y = x*y, u≥0} {z+u*y = z+y+(u-1)*y = x*y, u>0} z := z+y {z+(u-1)*y = x*y, u-1≥0} Следовательно, для рассматриваемого составного оператора справедливо {z+u*y=z+y+(u-1)*y=x*y, u>0} begin z := z+y; u := u-1 end {z+u*y=x*y, u≥0} Нетрудно заметить, что логическое выражение z+u*y=x*y сохраняется при выполнении составного оператора. Логические выражения, сохраняемые прорграппной конструкцией называются инвариантами. Нетрудно заметить, что в нашем примере выполнение отдельных операторов присваивания в составном операторе не сохраняет инвариант. Выражение z+u*y=x*y инвариантно для всего составного оператора Условный оператор Если S1 и S2 - операторы, а B - булево выражение, то
if B then S1 else S 2 endif
(9)
есть оператор, выполняющий следующие действия: вычисляется B; если B=true, то выполняется оператор S1, в противном случае — S2 . Пусть предусловие этого оператора есть P, а постусловие — Q. Тогда если значение B есть true, то оператор S1 будет иметь постусловие Q, если справедливо соотношение {P ∧ B} S1 {Q}
(10)
Аналогично для оператора S2 должно быть справедливо соотношение {P ∧ ¬B} S2 {Q}
(11)
Объединяя (10,11) можно получить правило вывода для условного оператора
{P ∧ B} S1 {Q}, {P ∧ ¬B} S 2 {R} {P} if B then S1 else S 2 endif {Q}
(12)
Рассмотрим более простую форму условного оператора
If
(13)
B Then S Endif
По этому оператору вначале вычисляется B. Если B истинно, то выполняется оператор S, иначе должна быть выполнена тождественная операция. Правило вывода для оператора (13) имеет вид
{P ∧ B} S {Q}, P ⇒ Q {P} If B Then S {Q}
(14) Пример 5.
Легко доказать, что оператор If r0. В самом деле, составной оператор удовлетворяет соотношению (q*y+r=x,0≤r0}. Покажем, что данный цикл имеет инвариант
x=q*y+r ∧ 0≤r Согласно правилам вывода для оператора присваивания и составного оператора легко получаем соотношение {x=q*y+r ∧ 0≤r-y}
r:=r-y; q:=q+1
{x=q*y+r ∧ 0≤r}
Предусловие составного оператора имеет форму P∧B. рассматриваемого цикла справедливо согласно (20) соотношение: {(x=q*y+r) ∧ 0≤r}
Поэтому
для
While r>=y r:=r-y; q=q+1 Wend {(x=q*y+r) ∧ 0≤r0 ∧ y>0. Пусть требуемое постусловие цикла есть {z=x*y}. Очевидно, если объединить его с условием завершения цикла u=0, то его можно переписать в виде z+u*y=x*y. Используя правила вывода для операторов присваивания и составного оператора “z=z+y u=u-1” легко показать, что он имеет предусловие и постусловие {z+u*y=x*y}. Отсюда легко получить числитель правила вывода (22): {z+u*y=x*y}
z := z+y; u := u-1
{z+u*y=x*y}, {z+u*y=x*y} ∧ u>0
Отсюда и из правила вывода (22) следует, что {z+u*y=x*y}
z := z+y; u := u-1
{{z+u*y=x*y}∧ u=0}
Очевидно, полученное постусловие эквивалентно {z=x*y}. Следует обратить внимание, что неявно мы здесь воспользовались еще одной группой правил вывода - правилами консеквенции. Правила консеквенции имеют вид (23)
{P} S {R}, R ⇒ Q P ⇒ R, {R} S {Q} , {R} S {Q} {P} S {Q}
Таким образом, мы строго определили семантику основных некоторого гипотетического языка программирования посредством правил вывода.
операторов формальных
4.3. Корректность программ. Правильность программ обычно проверяется тестированием. Оно заключается в том, что выбираются конкретные значения входных данных программы и программа выполняется с этим входными данными. Результаты работы программы сравниваются с заранее известными правильными результатами.
Тестирование - процесс выполнения программы с намерением найти ошибку. Но оно никогда не докажет их отсутствия. Поэтому необходимо абстрагироваться от индивидуальных процессов и постулировать некоторые общезначимые условия, которые можно вывести из характера поведения. Этот аналитический метод проверки носит название верификация программ или доказательство корректности программ. Верификация основана на систематическом применении правил вывода, полученных в предыдущем параграфе. Проиллюстрируем этот прием на примерах программирования на языке Visual Basic. Единственное отличие нотации данного пункта, от ранее введенной – использование комментариев и оператора присваивания этого языка. Пример 1. Алгоритм деления целых неотрицательных чисел x на у. Результат операции частное q и остаток r, которые удовлетворяют соотношению x=q*y+r ∧ 0≤r0 Алгоритм можно записать следующим образом ‘{x≥0 ∧ y>0} q = 0 r = x ‘{x=q*y+r ∧ 0≤r} While r>=y ‘{x=q*y+r ∧ 0≤y0 ∧ y>0} Установить z равным нулю, u равным
x
‘{z+u*y=x*y ∧ u>0} 2. ‘{z+u*y=x*y ∧ u>0} ‘Увеличить z на величину y и уменьшить u на 1; повторять этот процесс до тех ‘пор пока u не станет равным 0 {z=x*y} Нетрудно заметить, что инвариантом является логическое выражение z+u*y=x*y Тогда подзадача 1 содержит операторы присваивания, инициализирующие этот инвариант. Действие «увеличить z на величину y и уменьшить u на 1» подзадачи 2 построено таким образом, чтобы сохранить инвариант. В самом деле, Z+y+(u-1)*y=z+u*y=x*y Условие «повторять этот процесс до тех пор, пока u не станет равным 0», гарантирует, что после окончания итераций будет получен требуемый результат z=x*y. Корректность подзадач показана, и мы получаем программу ‘{x>0 ∧ y>0} z = 0 u = x Do z = z+y u = u-1 Loop until u=0 ‘{z=x*y} Можно непосредственно доказать корректность этой программы. До сих пор мы рассматривали только один аспект корректности программ, а именно, являются ли корректными результаты, вырабатываемые в точке выхода, если аргументы удовлетворяют входному утверждению. Другим не менее важным
аспектом корректности является требование, чтобы результатам после конечного числа шагов алгоритма. Рассмотрим выражением.
цикл
While
B
S
Wend.
Пусть
е
процесс является
приводил
к
целочисленным
Предположим, что (1)
P∧B ⇒ (e>0)
И для e0, принимающего целочисленные значения,
∀(e0 ({0 < e = e0 }S{0 ≤ e < e0 })
(2)
Это значит, что e≥0 также является инвариантом цикла. Кроме того, согласно (2) каждое выполнение оператора S уменьшает значение е. При условии выполнения (1), (2) и, полагая, что {P∧B} S {P} доказано, сразу можно сделать вывод о конечности итерационного процесса, так как е не может уменьшаться бесконечное число раз и оставаться положительным, как требует (1). Пример 3. Для цикла примера 1 в качестве функции е в соотношениях (1) и (2) следует выбрать переменную r. Для цикла do S loop until B требуется в дополнении к {P}S{Q} и Q∧¬B ⇒ P необходимо доказать (3)
P ⇒ (e>0)
Тогда гарантируется завершаемость итерационного процесса за конечное число шагов.
∀(e0 ({0 < e = e0 }S{0 ≤ e < e0 })
(4)
Пример 4. Для цикла примера 2 в качестве функции е в соотношениях (3) и (4) следует выбрать переменную u.
Разработка приложений в среде Visual Basic 6.0 Введение Visual Basic (Beginner’s All-purpose Symbolic Instruction Code) представляет собой современную систему визуального программирования в среде Windows. Visual Basic является и интерпретатором, и компилятором. Как интерпретатор, Visual Basic позволяет запускать приложения непосредственно в среде разработки (команда Run\Start). Как компилятор, Visual Basic предоставляет возможность создавать независимые от среды разработки исполняемые ЕХЕ-файлы (команда File\Make имя_файла_проекта...). Исторически различные приложения Microsoft включали различные языки макросов, значительно отличающиеся друг от друга (WordBasic, ExcelMacro, AccessBasic и т.д.). Начиная с Office 97, корпорация Microsoft стала снабжать свои приложения общим языком макросов – VBA (Visual Basic for Applications). Visual Basic for Applications является диалектом Visual Basic, учитывающим в наборе используемых объектов и функций специфику приложений (текстовых редакторов, электронных таблиц и т.п.). Поэтому Visual Basic широко используется для разработки приложений под Windows на основе продуктов Microsoft. Имея длинную предысторию, язык Visual Basic обременен многими устаревшими конструкциями, оставленными в языке для обратной совместимости с предыдущими версиями. Поэтому ниже при описании синтаксиса указываются лишь рекомендуемые конструкции. В качестве металингвистических символов используются квадратные скобки для необязательных конструкций ([]), фигурные скобки для обязательных конструкций ({}), вертикальная черта для разделения альтернативных конструкций (|), многоточие для возможного повторения предшествующей конструкции (...) и комбинация запятой с двумя точками для возможного повторения предшествующей конструкции в виде списка конструкций, разделенных запятой.
1. Интегрированная среда разработки После запуска Visual Basic можно создать новый проект, указав его тип (например, Standard EXE или VB Enterprise Edition Controls), загрузить уже существующий проект или создать новый проект с помощью мастера (например, мастера приложений VB Application Wizard). Приложение, созданное мастером, можно в дальнейшем дорабатывать с помощью других штатных средств среды разработки. Главное окно интегрированной среды разработки (IDE Integrated Development Environment) содержит строку меню (Menu Bar), панели и окна. Контекстное меню (Context Menu), как обычно, открывается щелчком правой кнопки мышки.
Toolbars - Панели инструментов (1) Открывать и настраивать панели инструментов Debug (Отладка), Edit (Правка), Form Editor (Редактор форм), Standard (Стандарт), а также Shortcut Menus (Сокращенные меню) можно с помощью команды View \ Toolbars ►. Toolbox - Панель элементов управления (2) Панель содержит элементы управления, предназначенные для размещения на формах. Комплект содержащихся на панели элементов зависит от типа проекта. Открыть панель можно с помощью команды View \ Toolbox, настроить – с помощью контекстного меню (команды Components…, Add Tab…) и с помощью перетаскивания элементов между различными вкладками. Project Explorer Window - Окно проекта (3) Приложение в Visual Basic реализуется в виде совокупности файлов, соответствующих различным компонентам проекта – формам, модулям, классам и другим, перечисленным в меню Project \ Add тип_компонента_проекта. Информация о файлах компонентов сохраняется в VBP-файле проекта. Если несколько проектов объединяются в группу, их имена сохраняются в файле с расширением .VBG. Одни и те же файлы компонентов могут быть использованы в различных проектах. Открыть окно проекта можно с помощью команды View \ Project Explorer, добавить новый компонент в проект - с помощью команды Project \ Add тип_компонента_проекта. Для сохранения компонента проекта необходимо выделить его в окне проекта и затем выполнить команду File \ Save имя_файла [As…], для исключения компонента из проекта - выполнить команду Project \ Remove имя_файла; при этом файл с диска удален не будет. Для сохранения всего проекта совместно со всеми компонентами необходимо выполнить команду File \ Save Project [As…]. Команда File \ Remove Project закрывает проект, т.е. исключает проект из среды разработки; на диске все файлы проекта сохраняются.
Properties Window - Окно свойств (4) Открыть окно свойств выбранного компонента проекта или элемента управления можно с помощью команды View \ Properties Window. Список свойств состоит из двух столбцов – наименования и значения. Ввод значений осуществляется либо непосредственно с клавиатуры, либо выбором из выпадающего списка, либо при помощи вызова диалогового окна настройки свойства. Краткое описание выбранного свойства отображается в нижней части окна. Object Browser - Каталог объектов Открыть каталог доступных объектов можно с помощью команды View \ Object Browser. Каталог содержит информацию об объектах из всех библиотек типов, на которые ссылается проект (краткое описание классов, свойств, методов, событий, констант). Каталог имеет средства поиска членов классов по шаблонам имен с возможным использованием символов подстановки. Form Designer - Конструктор форм (5) Открыть конструктор формы можно с помощью команды View \ Object, предварительно выделив наименование формы в окне проекта, или с помощью двойного щелчка по наименованию формы. Перетаскивание элементов управления на форму может сопровождаться установкой желаемых размеров элемента (щелчок по пиктограмме элемента управления, затем протягивание диагонали области элемента на форме) или установкой стандартных размеров (двойной щелчок по пиктограмме элемента управления). Code Editor Window - Редактор кода Открыть редактор кода можно с помощью команды View \ Code, предварительно выделив наименование компонента проекта в окне проекта, а также с помощью двойного щелчка по наименованию невидимого элемента или по изображению видимого элемента. Form Layout Window - Окно размещения форм (6) Открыть окно размещения форм можно с помощью команды View \ Form Layout Window. Окно размещения позволяет визуально позиционировать формы относительно экрана.
2. Программирование на Visual Basic 2.1 Правила кодирования Размещение операторов В каждой строке кода размещается, как правило, один оператор, причем целиком. Однако иногда для улучшения читабельности одна логическая строка кода может быть разбита на несколько физических строк (с помощью символа продолжения строки – символа подчеркивания) или несколько логических строк могут быть объединены в одну физическую (с помощью символа объединения строк – символа двоеточия), например: 1) Text1.Text = ”Эта строка ” & _ ”могла бы быть ” & _ ”очень длинной.” 2) Text1.BackColor = vbYellow: Text1.ForeColor = vbRed Комбинирование рекомендуется.
разбиений
и
объединений
строк
допускается,
но
не
Комментарии Комментарий начинается со знака апострофа и занимает всю оставшуюся часть строки. Редактор кода не допустит одновременное продолжение строки и ее комментирование. Примеры:
1) ’Это комментарий, занимающий целую строку без переноса 2) Text1.ForeColor = vbRed ’Описание констант ищите в _ Object Browser по шаблону vb*
2.2 Переменные и константы Для работы любой программы требуется некоторая область памяти для временного хранения информации. В любом языке программирования для этой цели используются переменные и константы. Для определения переменной компилятору следует сообщить следующие данные: — Имя переменной. С помощью имен осуществляется привязка переменных к их положению в оперативной памяти компьютера. — Тип переменной. Определяет, какого рода информация хранится в ней. — Значение переменной. Это — те данные, которыми оперирует программа. Имена переменных Чтобы оперировать с переменной в программе, ей нужно присвоить некоторое имя. Стандартный способ сделать это в языке Visual Basic — написать следующий оператор: Dim As С помощью оператора Dim переменные объявляются или описываются. При объявлении переменной мы сообщаем Visual Basic, что нужно отвести участок для временного хранения данных и назвать его некоторым именем. Тип переменной, указанный после ключевого слова As, в частности, сообщает компилятору, сколько следует выделить памяти под переменную. Имя (идентификатор) переменной выбирается следует соблюдать некоторые ограничения:
произвольно,
однако
при
этом
— Имя переменной может начинаться только с буквы; — В оставшейся части имени можно использовать любую комбинацию букв, цифр и символа подчеркивания (_). В именах переменных нельзя использовать пробелы, точки и другие знаки препинания. — Имя переменной должно быть уникальным в пределах ее зоны видимости. — Длина имени переменной не должна превышать 255 символов. — Имя переменной не должно совпадать ни с одним из ключевых слов языка. При выборе переменной необходимо учитывать два противоречивых требования. С одной стороны, оно должно быть достаточно информативным, чтобы облегчить понимание программы, а с другой — как можно более коротким, чтобы ускорить ввод текста программы в компьютер. Типы переменных Род информации, которая может содержаться в переменной, определяется ее типом. Тип задает размер памяти, выделяемый под переменную, и набор допустимых операций, которые можно совершать с данной переменной. В таблице 2.1. перечислены стандартные типы данных Visual Basic Таблица 2.1. Типы данных № п/п
Тип
Разме р, байт
Содержимое
Область значений
1
Boolean
2
Логическое значение
True или False
2
Byte
1
Целое неотрицательное
3
Integer
2
Целое
-32768 … +32767
4
Long
4
Длинное целое
-2147483648 … +2147483647
5
Single
4
Число с плавающей точкой одинарной точности
-3.402823E+38 … -1.401298E-45; +1.401298E-45 … +3.402823E+38
6
Double
8
Число с плавающей точкой двойной точности
-1.79769313486231E+308 … -4.94065645841247E-324; +4.94065645841247E-324 … +1.79769313486232E-308
7
Currency
8
ЧИСЛО С ФИКСИРОВАННОЙ ТОЧКОЙ (ДЕНЕЖНАЯ ВЕЛИЧИНА)
-922337203685477.5808 … +922337203685477.5807
8
Decimal (подтип Variant)
14
Десятичное целое
- 79228162514264337593543950335 … + 79228162514264337593543950335
Десятичное с фиксированной точкой
-7.9228162514264337593543950335 … -0.0000000000000000000000000001; +0.0000000000000000000000000001 … +7.9228162514264337593543950335
9
Date
8
Дата/время
#01/01/0100 00:00:00# … #12/31/9999 23:59:59#
10
String
Строка переменной длины
Длина >= 0
String * длина
Строка фиксированной длины
длина = 1 … 65526 (= 2^16 - 10)
11
Object
Объект
Любая ссылка на объект
12
Variant
Все
13
имя_типа
Пользовательский тип (Type … End Type)
14
0 … 255
OLE объект типа имя_типа
Объявление переменных Компилятор Visual Basic не требует явного объявления переменных перед их использованием. Если используемая в программе переменная нигде ранее не описана, считается, что она имеет стандартный тип Variant. В переменной этого типа можно хранить любые данные, однако ее использование сопряжено с потреблением дополнительных ресурсов. Если явно не объявлять переменные, это может привести к ошибкам в программе. Рекомендуется включить оператор Option Explicit в секцию (General) (Declarations) кода, чтобы компилятор треовал явного объявления.
Область определения переменных Помимо имени переменной и ее типа при объявлении указывается также область ее действия, или, другими словами, в каком месте программы может использоваться описываемая переменная. Область действия переменной называется зоной ее видимости. При создании сложных многомодульных приложений, состоящих из нескольких форм, часто возникает потребность в переменных, которые были бы доступны из любой части программы. Эти переменные называются общими или глобальными. Глобальные переменные определяются в секции (General) (Declarations) модуля. При этом вместо оператора Dim используется зарезервированное слово Public. Чаще всего в программе используются переменные, которые имеют смысл только в рамках текущей процедуры или формы. Они называются локальными переменными, а для их описания используется ключевое слово Private оператора Dim. Тип зоны видимости зависит от того, в каком месте программы расположен оператор объявления. Если переменная описана в разделе общих объявлений модуля формы или программы, то она будет доступна для всех процедур данной формы или программы. Такие переменные называют локадьными переменными модуля или формы. Если переменная описана внутри процедуры, она может использоваться только внутри нее. Такая переменная создается в памяти в момент входа в процедуру и уничтожается при выходе из нее. Переменные, которые сохраняют свое значение после завершения работы процедуры, называются статическими. Они описываются в операторе объявления с помощью ключевого слова Static. Статические переменные являются локальными для процедуры, в которой они используются, но их значение сохраняется до повторного вызова процедуры. Если перед описанием процедуры указать ключевое слово Static, то статическими будут все переменные процедуры. Массивы Массивом называется совокупность переменных одного типа, имеющих одно и то же символическое имя. Предположим, нам требуется подсчитать определитель матрицы размером 4x4. Тогда для хранения содержимого всех ячеек этой матрицы нам потребуется 16 уникальных переменных. Гораздо удобнее воспользоваться одной переменноймассивом. Каждая из переменных, составляющих массив, называется элементом массива. С каждым элементом ассоциировано целое число, называемое индексом и уникальное в пределах одного массива. Количество хранящихся в массиве элементов называется размером массива. Размер массива ограничен объемом оперативной памяти и типом данных элементов массива. Все элементы массива имеют одинаковый тип. Однако если массив имеет тип variant, то отдельные элементы могут содержать данные разных типов. Например, одни элементы могут быть числами, другие — строками или объектами. Индекс элемента указывается в круглых скобках после имени массива. Например, A(l), A(2), A(10) являются элементами массива с именем A. Каждый из элементов массива может использоваться точно так же, как и простая переменная. В Visual Basic существуют массивы фиксированного размера и динамические массивы. Массив фиксированного размера имеет неизменный размер, заданный при его объявлении. Динамические массивы могут изменять размер в процессе выполнения. При объявлении массива фиксированного размера после его имени в круглых скобках указывается верхняя граница массива. По умолчанию нижней границей массива является 0. Например, в приведенном ниже коде, задается массив A из 21 элемента. Индекс элементов массива изменяется от 0 до 20:
Dim A(20) As Integer Можно явно задать нижнюю границу массива, используя ключевое слово то: Dim A (1 To 20) As Integer В этом случае задается массив A из 20 элементов. Индекс элементов массива изменяется от 1 до 20. Visual Basic позволяет использовать матрицы). Например, в следующем коде размерностью 21х21:
многомерные объявляется
массивы (таблицы, двумерный массив
Dim B (20, 20) As Integer При использовании многомерных массивов, как и в случае одномерных, можно явно задавать нижнюю границу: Dim B (1 To 20, 1 То 20) As Integer Dim B (20, 1 То 20) As Integer В случае, когда размер массива заранее неизвестен, Visual Basic позволяет использовать динамические массивы, размеры которых можно изменять во время выполнения. Применение динамических массивов позволяет эффективно управлять памятью, выделяя память под большой массив лишь на то время, когда этот массив используется, а затем освобождая ее. При объявлении динамического массива после его имени ставится пара круглых скобок. Например: Dim C() As Integer Например, способов:
размерность
массива
может
быть
задана
любым
из
следующих
ReDim C(х) ReDim C(20) ReDim C(1 То 20) При выполнении оператора ReDim данные, размещенные в массиве ранее, теряются. Это удобно в том случае, если данные нам больше не нужны и мы хотим переопределить размерность массива и подготовить его для размещения новых данных. Если мы хотите изменить размер массива, не потеряв при этом данных, то необходимо воспользоваться оператором ReDim с ключевым словом Preserve. Например, приведенный ниже программный код увеличивает размер массива на единицу без потери хранящихся в массиве данных: ReDim Preserve C(X + 1) Однако в этом случае можно изменять только верхнюю границу последнего измерения. Переменной, соответствующей динамическому массиву, может быть присвоено значение переменной, соответствующей статическому или динамическому массиву. Пользовательский тип данных Для определения пользовательского типа данных используется оператор Type, размещаемый в секции (General) (Declarations) модуля: {Public | Private} Type имя_типа имя_элемента [([нижняя_гр To верхняя_гр],..)] As тип_данных … End Type Доступ к элементам следующей форме:
переменной
пользовательского
имя_переменной.имя_элемента[([идекс],..)]
типа
осуществляется
в
Переменным пользовательского переменных того же типа.
типа
можно
присваивать
значения
других
Пример 1. Тип точки в двумерном пространстве (точка состоит из двух кооржинат). Private Type Point x As Integer y As Integer End Type Константы Константой называют элемент выражения, значение которого не изменяется в процессе выполнения программ. Константы часть применяют восприятие программы.
вместо
числовых
значений,
чтобы
упростить
Для объявления констант используется оператор Const: [Public | Private] Const имя_константы [As тип_данных] = значение Константы могут быть определены как Public или Private в секции (General) (Declarations) модуля, или внутри процедуры (тогда они локальные). В Visual Basic предусмотрено большое количество встроенных констант практически для всех возможных случаев: цвета, клавиши, сообщения и т. п. Встроенные константы имеют префикс vb. Для поиска констант определенной категории можно воспользоваться браузером объектов, который открывается при нажатии кнопки Object Browser на стандартной панели инструментов.
2.3 Операторы языка Основные операторы были рассмотрены нами в разделе 4 с точки верификации программ. Ниже мы кратко остановимся на них еще раз:
зрения
Оператор присваивания Прежде чем использовать переменную в программе, ей необходимо присвоить значение. Самый простой способ присвоения заключается в использовании оператора присваивания "=", который имеет следующий синтаксис: «переменная» = «выражение» Аргумент «переменная» задает имя переменной, которой будет значение выражения, стоящего справа от знака равенства. Например:
присвоено
X = 10 S = "Иванов" Математические операторы Математические операторы позволяют выполнять в программе действия над числами. В табл. 2.2 приведены арифметические операторы и выполняемые ими функции. Таблица 2.2. Математические операторы Оператор
Выполняемая операция
+
Сложение
-
Вычитание
*
Умножение
/
Деление
\
Целочисленное деление
Mod
Остаток от деления нацело
^
Возведение в степень
Условные выражения Основанием для принятия решений в управляющих конструкциях являются условные выражения, поэтому предварительно необходимо сказать несколько слов об этих выражениях и работе с ними. Условные выражения — это такие выражения, которые возвращают одно из двух значений true (Истина) или false (Ложь). В условных выражениях используются операторы сравнения, приведенные в табл. 2.3. Таблица 2.3. Операторы сравнения для условных выражений Оператор
Назначение
=
Равно
>
Больше
=
Больше или равно
New Project и нажать кнопку Открыть. При сохранении проекта необходимо помнить, что проект состоит из входящих в него компонентов, таких как формы, модули кода, классы, элементы управления и т. д. Поэтому процесс сохранения проекта требует последовательного сохранения его компонентов. Для выполнения созданного в Visual Basic приложения следует вызвать команду Run из меню Start (или нажать на кнопку Start на стандартной панели инструментов Visual Basic). Большинство приложений, созданных в Visual Basic, работают в интерактивном режиме. На экран выводится информация, предназначенная для пользователя программы, и ожидается его ответная реакция в виде ввода данных или команд. Интерактивное приложение в Visual Basic создается на базе формы, являющейся, как правило, основным окном интерфейса, с элементами управления, позволяющими осуществлять взаимодействие с пользователями. Большинство программ (приложений), выполняющихся в среде Windows, используют одно или несколько окон. Окном называется прямоугольная область экрана, которая служит для взаимодействия с пользователем. Типичное окно Windows содержит заголовок, на котором отображается название окна и три стандартные кнопки (минимизации, максимизации и закрытия окна). Одно из окон программы является главным — щелчок по кнопке закрытия этого окна прекращает выполнение программы. Положение окна и его размеры однозначно определяются координатами (в пикселах) двух противоположных углов окна. (Система координат, принятая в Windows, считает начало координат в левом верхнем углу.) Заготовка окна программы в среде Visual Basic называется формой. Форма обычно создается в проекте по умолчанию (рис 3.2.).
При запуске программы форма превращается в окно, которое пользователи видят на экране и с помощью которого управляют выполнением программы. Но сами по себе формы мало на что способны. Функциональность программы опреляют расположенные на форме элементы управления (или визуальные компоненты). Элементами управления являются кнопки, текстовые поля, меню, выпадающие списки и т.д. С их помощью можно получать данные от пользователя и выводить различную информацию. Форма также является визуальным компонентом. На панели элементов управления (см рис. 3.1.) расположен набор пиктограмм, каждая из которых соответствует определенному классу. Чтобы разместить на форме новый элемент управления (например, кнопку), необходимо щелкнуть мышкой по соответствующей пиктограммке, а затем обозначить позицию элемента на форме. В результате будет создан конкретный экземпляр или объект данного типа. Можно провести аналогию с переменными и их типами. В программе использоваться несколько переменных одного типа (например, Integer). также на форме может располагаться несколько объектов одного (например, несколько кнопок: класс CommandButton). Каждый объект, переменная, имеет уникальное имя, по которому можно обращаться к нему.
может Точно класса как и
Свойства Свойства определяют внешний вид визуального компонента и в некоторой степени позволяют настроить его поведение. Для каждого класса визуальных компонентов Visual Basic предусмотрен свой набор свойств. Так, например, у компонента CommandButton — кнопки — есть свойство Caption, определяющее надпись на ней, а у компонета Timer — таймера — есть свойство Interval, задающее время одного «тика». Значения свойств можно считывать и программы, так и на этапе ее разработки.
изменять
как
во
время
выполнения
На этапе разработки изменить значения можно с помощью ПАНЕЛИ СВОЙСТВ (см. рис. 3.1.). Эта панель представляет собой таблицу, в каждой строчке которой описывается одно свойство выбранного элемента управления. В первом столбце указано название свойства, а во втором — его значение. Содержимое второго столбца можно менять, причем, если свойство отвечает за внешний вид объекта, изменения сразу отобразятся на экране. Если поменять свойство Caption у кнопки, надпись на ней тут же изменится. Во время выполнения программы свойства работают как обычные переменные (т.е. их можно изменять с помощью оператора присваивания и использовать в выражениях). Но для того, чтобы получить доступ к свойству конкретного объекта, необходимо перед названием свойства указать имя этого объекта через
точку. Например, изменить надпись на кнопке выполнения программы можно с помощью оператора:
с
именем
Button1
во
время
Command1.Caption = “Новая надпись” Проект может состоять из нескольких форм, каждая из которых может содержать элементы управления с одинаковым именем. Поэтому корректное обращение к свойству должно выглядеть так: Form1.Command1.Caption = “Новая надпись”, где Form1 — имя формы, на которой расположена кнопка Command1 Имя формы указывать не обязательно, если обращаются к элементу управления собственной формы. Некоторые компонентов:
свойства
являются
общими
почти
для
всех
типов
визуальных
•
Left, Top — определяют положение объекта на форме. Значение свойства Left определяет расстояние от левого края объекта до левой стороны содержащего его контейнера, а значение свойства Top — расстояние от верхнего края объекта до верхней стороны содержащего его контейнера. В случае обычной формы контейнером является экран монитора (т.е. свойства Left и Top формы определяют положение окна программы на экране). Если же визуальный компонет размещается на форме, роль контейнера играет сама форма (и свойства Left и Top компонента характеризуют его положение в окне программы). Справедливо заметить, что некоторые элементы управления сами могут являться контейнерами для других объектов.
•
Width, Height — ширина и высота объекта соответственно.
•
Enabled — это свойство может принимать значения true и false. Если свойство установлено в false, объект становится недоступным (т.е. перестает реагировать на обращения к нему со стороны пользователя). На кнопку нельзя нажать, а в текстовое поле нельзя ввести информацию. Обычно этот прием используется в программах установки, когда прежде чем нажать на кнопку ДАЛЕЕ пользователь должен выполнить какие-то другие действия (например, согласиться с лицензией).
•
Visible — аналогично Enabled это свойство принимает логичесткое значение. Когда element.Visible = false, объект element не просто становится недоступным, но и вообще не виден на форме.
•
Управление цветовым оформлением элементов осуществляется с помощью свойств BackColor (цвет заднего плана), ForeColor (цвет переднего плана) и FillColor (цвет заполнения), которым по умолчанию назначаются стандартные цвета Windows.
•
Name — самое главное свойство, присутствующее у абсолютно всех визуальных компонентов. Это свойство содержит уникальное имя объекта и может изменяться только в режиме разработки программы. Имена объектов подчиняются тем же правилам, что и имена переменных. Visual Basic по умолчанию генерирует стандартные имена для новых элеменов управления (например, если «нарисовать» на форме две кнопки, они будут называться Command1 и Command2). Рекомендуется сразу после создания очередного элемента поменять его имя на более осмысленное и соответствующее логике программы.
Остальные свойства мы рассмотрим отдельно для каждого класса визуальных компонентов. Методы Visual Basic является объектно-ориентированным языком программирования. Помимо свойств, объект имеет методы, определяющие выполняемые им действия. Если свойства можно сравнить с переменными, которые хранят данные о конкретном объекте, то методы — это процедуры и функции, «встроенные» в объект. Кнопку можно, например, переместить, сделать активной, или спрятать, обращаясь к ее методам (или вызывая методы). Синтаксис обращения к методам
конкретной кнопки аналогичен синтаксису доступа к свойствам: перед названием метода через точку указывается имя объекта: Command1.Move(20) Приведенная команда сдвигает кнопку Command1 на 20 единиц вправо. Заметим, что то же самое действие можно было выполнить путем изменения свойств кнопки: Command1.Left = Command1.Left + 20 Однако вызов метода гораздо проще и наглядней. Большинство методов помимо прочего как раз изменяют значения свойств объекта. Некоторые управления:
методы
являются
стандартными
для
большинства
элементов
•
Drag — данный метод обеспечивает поддержку опускания объектов в пределах контейнера
•
Move — позволяет изменить положение объекта на экране
•
SetFocus — позволяет сделать объект активным (или, как говорят, поместить объект в фокус). После получения фокуса пользователь может взаимодействовать с этим объектом (например, вводить текст с клавиатуры). В данный момент времени фокус может получить только один элемент управления формы, который при этом выделяется визуально (например, в текстовом поле появляется курсор, а кнопка будет обведена пунктирным прямоугольником).
операции
перетаскивания
и
События Кроме выполнения основных функций с помощью методов, объекты программы могут реагировать на некоторые события, возникающие в результате каких-либо действий пользователя или генерируемых операционной системой. С каждым классом визуальных компонентов связан набор событий. Например, у кнопки есть событие Click, которое происходит, когда пользователь нажимает на нее. В момент возникновения события, связанного с конкретным объектом, запускается специальная процедура, называемая обработчиком события. Например, когда пользователь нажимает на кнопку, кнопка должна «утопиться», имитируя «вдавливание», а когда он отпускает кнопку, кнопка должна вернуться в исходное состояние. Однако помимо этих очевидных действий (которые являются стандартными и запрограммированы по умолчанию), обработчик события может выполнить и другие команды, заданные программистом. Для этого при разработке программы программист должен написать требуемый программный код и поместить его в нужный обработчик события. Например, если программа-калькулятор при нажатии на кнопку с надпиью «=» должна выполнять арифметическую операцию, этот код должен содержаться в обработчике события Click этой кнопки. По сути, весь программный код на Visual Basic, исключая определение переменных и описание пользовательских процедур и функций, сосредоточен в разнообразных обработчиках событий. Имя процедуры – обработчика события состоит из имени объекта, для которого вызывается событие, знака подчеркивания и названия самого события. Например, при нажатии на кнопку Command1 вызывается событие Command1_Click, а значит, необходимо описать процедуру именно с таким именем и с параметрами, соответствующими событию Click. Visual Basic сам может генерировать шаблоны обработчиков событий (заголовок и список параметров). Некоторые управления:
события
являются
стандартными
для
большинства
элементов
•
События Click и соответственно.
•
Событие MouseDown вызывается при нажатии кнопки мыши. При этом процедуре обработки события передается параметры, определяющие нажатую кнопку (1 левая, 2 - правая, 4 - средняя), состояние управляющих клавиш (Shift, Ctrl, Alt) и позицию курсора в момент нажатия относительно левой верхней точки элемента управления (X, Y).
Dblclick
вызываются
одиночным
и
двойным
щелчком
мыши
•
Событие Mouseup вызывается при отпускании кнопки мыши.
•
Событие MouseMove управления.
•
События KeyPress, KeyUp и KeyDown связаны с клавиатурой. Обычно эти события вызываются для активного элемента управления, находящегося в фокусе. Однако, если свойству формы KeyPreview присвоить значение True, то событие, связанное с клавиатурой, передается сначала форме, а затем уже активному элементу управления. В процедуру обработки события KeyPress передается по ссылке код ASCII нажатой клавиши (не перехватываются нажатия специальных клавиш, таких как PrintScreen или Alt; нажатия клавиш Enter, Esc, Backspace перехватываются). В процедуре можно осуществить, например, фильтрацию вводимых данных и, установив значение аргумента КеyAscii равным нулю, предотвратить передачу недопустимого символа для дальнейшей обработки.
•
События KeyDown и KeyUp вызываются при нажатии и отпускании клавиш. Они происходят даже при нажатии специальных клавиш управления, например функциональных клавиш. При этом передаются два параметра: KeyCode и Shift. Параметр KeyCode содержит клавиатурный код (а не код ASCII) нажатой клавиши, например vbKeyFl, а параметр Shift информирует о состоянии клавиш Shift , Ctrl и Alt. События нажатия клавиш наступают в последовательности KeyDown, KeyPress и KeyUp.
•
События LostFocus соответственно.
вызывается
и
GotFocus
при
движении
возникают
при
курсора
потере
и
над
элементом
получении
фокуса
3.2 Стандартные элементы управления Рассматриваемые в издания Visual Basic.
данном
разделе
элементы
управления
включены
во
все
Кнопка (CommandButton)
Этот элемент управления используется для того, чтобы начать, прервать или закончить какой либо процесс. Кнопка встречается во всех приложениях Windows. Главным событием для кнопки является Click. Кроме этого события, у кнопки могут быть и другие, но они применяются редко. Для вызова события Click имеются разные способы. Самый простой непосредственный щелчок н кнопке мышью. Это же событие вызывается также, если с помощью клавиши Tab переместить фокус на кнопку, затем нажать клавишу Enter. Можно программно вызвать событие Click, установив равным True значение свойства Value, доступного только во время выполнения. Есть два интересных свойства кнопки, связанных с событием Click. Свойство Default определяет, что данная кнопка является кнопкой, активной по умолчанию. Если это свойство равно True, то нажатием клавиши Enter автоматически генерируется событие Click этой кнопки независимо от того, какой элемент имеет фокус. Присваивать значение True этому свойству можно
только для одной кнопки в форме. Следует учитывать, что в этом случае нажатие клавиши Enter перехватывается и передается этой кнопке. Обычно кнопкой по умолчанию является кнопка ОК. Свойство Cancel используется подобно Default. Оно обеспечивает перехват клавиши Esc и вызов события Click для соответствующей кнопки. Обычно это свойство имеют кнопки Cancel (Отмена). Надпись (Label)
Надпись (Label) предназначена для отображения текста, который пользователь не может изменить с клавиатуры. Хотя некоторые события этого элемента обычно эта возможность не используется.
управления
можно
обрабатывать,
Самым важным свойством надписи является Caption, содержащее отображаемый текст. Воспользовавшись свойством BorderStyle, можно установить способ отображения текста - с рамкой или без нее. Оформлять текст можно, используя все возможности форматирования текста, доступные в окне свойств, - от вида и размера шрифта до цвета символов. Если текст длиннее, чем поле надписи, то оставшаяся часть текста просто не отображается (усекается). Этого можно избежать, если присвоить значение True свойству AutoSize, что приводит размер надписи в соответствие с длиной текста. Таким же образом можно корректировать размер надписи и по вертикали. Для этого одновременно со свойством AutoSize нужно установить свойство Wordwrap. Тогда слова, не помещающиеся в строке, автоматически будут переноситься в следующую строку. Установка в тексте надписи перед любой буквой символа амперсэнда (&) позволяет определить для выбора объекта клавишу быстрого доступа. Так как надпись не может получать фокус, она передает его следующему элементу управления. Если амперсэнд просто должен появляться в тексте без дальнейшего действия, следует отключить свойство UseMnemonic. Текстовое поле (TextBox)
Текстовое поле (TextBox) является предназначенным для ввода данных.
основным
элементом
управления,
При использовании текстового поля представляют интерес несколько событий. Прежде всего, это событие Change, которое вызывается при изменении содержимого текстового поля. Это событие происходит каждый раз при вводе, удалении или изменении символа. Например, при вводе в текстовое поле слов "Hello" событие Change вызывается пять раз - по одному разу для каждой буквы. Для анализа введенного в поле текста лучше всего подходит событие LostFocus. Это событие вызывается после того, как текстовое поле становится неактивным (после передачи фокуса другому элементу, т.е. когда пользователь закончит ввод). Однако если это поле является единственным элементом управления в форме, оно не может потерять фокус. Чтобы удалить или инициализировать содержимое текстового окна, используется событие GotFocus. Оно вызывается, когда пользователь "входит" в текстовое окно. Можно воспользоваться и другими свойствами текстового поля. Самым важным является свойство Text. Это свойство содержит отображаемый в поле текст. Элементы управления, которые разрешают ввод символов, имеют свойство Text, а элементы, предназначенные только для отображения текста, - свойство Caption. Текстовое поле подобно маленькому редактору. Чтобы использовать его в таком качестве, достаточно установить свойство MultiLine. Это дает возможность вводить в поле несколько строк. В многострочном поле для перехода на новую строку можно использовать клавишу Enter. Но при этом следует помнить, что для некоторой кнопки, возможно, установлено свойство Default. Поэтому нажатие клавиши Enter вызовет срабатывание этой кнопки. В таком случае для перехода на новую строку надежнее использовать комбинацию клавиш Ctrl+Enter или Shift+Enter. Если форма не содержит многострочное текстовое поле и кнопку по умолчанию, то нажатие клавиши Enter в текстовом поле,имеющем фокус, вызовет звуковой сигнал. Для предотвращения этого можно написать следующую процедуру обработки события KeyPress текстового поля: Private Sub Textl_Keypress(KeyAscii As Integer) If KeyAscii = 13 Then KeyAscii = 0 End Sub При этом клавиша Enter просто игнорируется. При работе с многострочным текстовым полем можно столкнуться со следующей проблемой: если вводимый текст больше, чем может поместиться в текстовом поле, текст хотя и не усекается, но и не отображается полностью. Эта проблема решается установкой свойства ScrollBars. С его помощью можно определить, какую полосу прокрутки будет иметь текстовое поле: горизонтальную, вертикальную или обе. При этом полосы прокрутки функционируют самостоятельно, т.е. нет необходимости писать дополнительный код. В текстовом поле, как это обычно делается в среде Windows, можно также выделять текст. Для этого Visual Basic предоставляет следующие три свойства текстового окна. Свойство SelStart определяет начальную позицию выделенного текста в символах. Свойство SelLength содержит количество выделенных символов. И, наконец, с помощью свойств SelText можно прочитать или изменить выделенный текст. Иногда в поле требуется быстро удалить текст или заменить его новым. Для этого выделяется весь текст в поле, как только данное поле получает фокус.
Флажок (CheckBox)
Флажки - это элементы управления, которые можно отмечать (ставить "галочку"), выбирая из ряда опций одну или несколько. CheckBox может иметь два основных состояния - отмеченное и не отмеченное. В третьем состоянии он отображается как отмеченный, но недоступный. Установить такое состояние элемента управления можно только программно. Важнейшим для флажка, как и для кнопки, является событие Click. Единственным важным свойством элемента управления CheckBox является его значение (Value). В зависимости от того, отмечен флажок или нет, Value может принимать следующие значения: 0 – не отмечен, 1 – отмечен, 2 – отмечен, но недоступен. Переключатель (OptionButton)
Этот элемент управления, представляющий собой кружок с точкой или без, предназначен для установки только одной опции из группы. Обычно все переключатели формы объединены в одну группу. Если необходимо сформировать новую группу переключателей, то нужно поместить их в отдельный элемент контейнер, например Frame. Работа с элементами контейнерами будет рассмотрена далее. Так же, как и для элемент управления CheckBox, для переключателей важно только одно событие - Click. Важнейшим свойством переключателей является свойство Value. С его помощью можно определить состояние переключателя. Это свойство может принимать значения True и False.
Список (ListBox)
Список - ListBox - позволяет пользователю выбирать из списка один или несколько элементов. В любое время в список можно добавлять новые элементы или удалять существующие. Если не все элементы могут одновременно отобразиться в поле списка, то в нем автоматически отображаются полосы прокрутки. Основное событие списка - Click. Это событие вызывается, если пользователь с помощью мыши или клавиш управления курсором выбирает элемент в списке. Окно списка - это элемент управления, для которых важную роль играют методы. Методы списка необходимы для обработки элементов списка - добавления или удаления. Для добавления новых элементов используется метод Addltem. Для удаления элемента из списка используется метод RemoveItem, которому в качестве параметра передается индекс удаляемого элемента .Индексация элементов списка начинается с 0. Для удаления всех элементов списка используется метод Clear: Использование свойства списка Text - самая простая возможность получить текст выбранного элемента списка. В любой момент времени значение этого свойства содержит текст выбранного элемента списка или пустую строку, если ни один элемент не выбран. Для определения текста выбранного элемента существуют и другие возможности. Однако следует помнить, что и в памяти все элементы списка сохраняются в виде списка. При этом первый элемент списка имеет индекс 0. Зная это, можно воспользоваться свойством списка List(), которое позволяет определить текст элемента списка по его индексу. Комбинируя свойства List() и Listlndex, можно получить выбранный элемент списка. Если в списке не выбран ни один элемент, значение свойства Listlndex равно 1. Текущее количество элементов в списке сохраняется в свойстве ListCount. Элементы поля списка по умолчанию отображаются в одном столбце. Во время проектирования, при необходимости, их число можно изменить с помощью свойства Columns. Заполнение столбцов в этом случае осуществляется последовательно – сначала заполняется первый, затем второй и т.д. Свойство Sorted определяет способ расположения элементов в списке. Если установить это свойство, то все элементы будут сортироваться по алфавиту, даже если они были добавлены с указанием индекса. Индекс последнего добавленного элемента содержит свойство NewIndex. Это свойство связано с другим свойством списка – ItemData(), с помощью которого каждому элементу списка можно поставить в соответствие число тип Long. Используя это свойство, можно составить, например, список сотрудников, сохранив их индивидуальные номера в свойстве ItemData(). При добавлении в список нового элемента следует позаботиться о присвоении (при необходимости) требуемого значения свойству ItemData(), так как оно изначально не инициализировано соответствующим значением ранее добавленного элемента. Пользователь может выбирать одновременно несколько элементов списка. Для этого следует присвоить свойству Multiselect одно из следующих значений:
•
0 - Множественный выбор невозможен. Щелчком мыши или нажатием клавиши пробела в списке можно выбрать только один элемент.
•
1 - Простой множественный выбор. Элементы списка выбираются щелчком мыши или нажатием клавиши пробела.
•
2 - Расширенный множественный выбор. Пользователь может выбрать несколько элементов с помощью мыши или клавиш управления курсором с использованием клавиш Shift и Ctrl.
При множественном выборе свойство Text содержит текст последнего выбранного элемента списка. Значение свойства Selected() элемента списка показывает, выделен данный элемент списка или нет. Если свойство равно True, то данный элемент выбран. Поле со списком (ComboBox)
Поле со списком или ComboBox - это, по сути, комбинированный список, который представляет собой комбинацию двух элементов управления – самого списка со значениями и поля ввода текста (текстового поля). Поля со списком используются в том случае, если нельзя заранее определить значения, которые следует включить в список, или список содержит слишком много элементов. В таком списке нужное значение можно не только выбирать, но и вводить непосредственно в поле ввода. Новое значение после ввода автоматически помещается в список. Для поля со списком важную роль играют события как поля ввода, так и списка. Основные из них - Click, используемое для выбора элемента списка, и Change - для изменения записи в поле ввода текста. Поле со списком имеет почти все свойств текстового поля TextBox и списка ListBox (исключением является свойство MultiLine). Однако особо следует выделить значение свойства Style, определяющее внешний вид и функционирование поля со списком: •
0 = vbComboDropDown - Значение по умолчанию. ComboBox представляет собой текстовое поле для редактирования и открывающийся список.
•
1 = vbComboSimple - ComboBox постоянно открытый список.
•
2 = vbComboDropDownList Отличается от списка со значением vbComboDropDown только тем, то пользователь не может вводить текст в текстовое поле.
представляет
собой
текстовое
поле
и
Полосы прокрутки (ScrollBar) Элемент управления ScrollBar - это полосы прокрутки окна. Некоторые элементы управления (например, TextBox, ListBox) используют такие полосы прокрутки, причем от разработчика не требуется написание программного кода для выполнения прокрутки. Однако полоса прокрутки как элемент управления Visual Basic хотя и предназначена для выполнения аналогичных функций, но не
выполняет автоматически каких либо действий, т.е. ее поведение необходимо программировать. Существует два вида полос прокрутки: горизонтальная и вертикальная. Полосы прокрутки имеют два интересных события: Change, которое возникает после изменения позиции бегунка или после программного изменения значения свойстваValue, и Scroll, происходящее во время прокрутки (когда пользователь захватил и передвигает бегунок). Перед тем как использовать полосу прокрутки, необходимо установить для нее диапазон прокрутки, который показывает количество шагов прокрутки между крайними позициями бегунка. Текущее положение бегунка определяется значением свойства Value. Диапазон прокрутки определяется свойствами Min и Мах полосы прокрутки. При этом значение Min всегда соответствует верхнему концу полосы, Мах - нижнему (для вертикальной полосы прокрутки), и при прокрутке содержимого окна сверху вниз значение свойства Value увеличивается. Чтобы изменить направление изменения свойств Value, достаточно поменять мест ми значения свойств Min и Мах. Щелчок н одной из двух кнопок со стрелками н полосе изменяет значение свойства Value на величину, определяемую свойством SmallChange. Если пользователь щелкнет в области между бегунком и какой-либо из кнопок, то значение свойства Value полосы прокрутки и соответственно положение бегунка изменяется на величину, определяемую свойством LargeChange. Таймер (Timer) Использование таймера является хорошим способом управления программой. С помощью таймера можно запускать или завершать процессы приложения в определенные моменты времени. Таймер может быть полезным и в том случае, если приложение выполняется в фоновом режиме. Во время проектирования таймер отображается в форме ,но во время выполнения программы он является невидимым. Таймер имеет единственное событие - Timer, которое вызывается по истечении установленного временного интервала. Для установки интервала времени служит свойство Interval, значение которого устанавливается в миллисекундах. Например, задание значения 250 вызывает событие Timer через каждые 250 миллисекунд независимо от того, какое приложение активно. Для отключения таймера следует присвоить свойству Interval значение 0 или свойству Enabled значение False. Максимально допустимый интервал составляет 64757 миллисекунд. Но следует помнить, что операционная систем может обрабатывать только 18,2 прерывания таймера в секунду, поэтому точность задания интервала составляет максимум одну восемнадцатую секунды. Необходимо также учесть, что при большой загрузке системы (поддержка сети, печать и т.п.) прерывания могут обрабатываться еще реже. В Windows можно использовать не более 32 таймеров. Поскольку для работы системы также нужен таймер, то для всех приложений остается максимум 31. Если обработка события Timer длится дольше, чем задано значением Interval, то новое событие Timer не вызывается, пока Visual Basic не обработает это событие. Список устройств (DriveListBox) Элемент управления DriveListBox относится к группе элементов управления, предназначенных для отображения и работы с дисками, каталогами и файлами. DriveListBox служит для отображения списка всех доступных дисков и устройств системы и обеспечивает возможность их выбора. Самым интересным событием элемента DriveListBox событие вызывается при смене носителя данных.
является
Change.
Это
Элемент DriveListBox обладает почти всеми свойствами обычного поля со списком. Но чаще всего используется только свойство Drive, возвращающее выбранный диск или устройство (например, "С:\"). Список каталогов (Directory ListBox) DirectoryListBox или кратко DirListBox - это второй элемент управления, предназначенный для выбора файлов. Он отображает структуру выбранного диска и позволяет осуществлять выбор и смену каталога. Для этого элемента также главную роль играет событие Change. Оно вызывается в результате двойного щелчка мышью на имени каталог в окне просмотра. Элемент управления DirListBox также имеет некоторое сходство со списком. Однако главным его свойством является свойство Path, возвращающее полный путь к выбранному каталогу, включая имя диска (например, C:\WINDOWS\WORD). После добавления в форму элементов управления DriveListBox и DirListBox они еще не работают совместно. То есть в один и тот же момент в DriveListBox может отображаться имя диска С, а в DirListBox - структура каталогов диска D. Поэтому прежде чем использовать эти элементы управления, их необходимо синхронизировать. Это происходит при обработке события Change в DriveListBox: Private Sub Drivel_Change() Dirl.Path = Drivel.Drive End Sub Обычно для выбора каталог пользователь нажимает клавишу Enter. Однако элемент управления DirListBox игнорирует эту клавишу. Решением такой проблемы является возможность обработки события KeyPress и программная смена каталога. Список файлов (FileListBox) FileListBox - последний элемент управления, который можно использовать для выбор файлов. Он отображает файлы текущего каталога, откуда их можно выбирать. Для FileListBox основным событием является Click, которое вызывается при выборе пользователем имени файла в списке. Представляют также интерес события PathChange и PatternChange. Событие PathChange происходит после изменения пути (свойство Path), а событие PatternChange после изменения маски выбора файлов (свойство Pattern). Этот элемент управления также имеет много общих свойств с элементом ListBox. Однако основным его свойством является свойство FileName, которое содержит имя выбранного файла (например,BOOK.DOC). Свойство Pattern позволяет определить тип тех файлов, которые должны отображаться в списке. Например, для отображения файлов с расширением *.1СО и *.ВМР необходим следующий код: Filel.Pattern = "*.ICO;*.BMP" Расширения файлов разделяются точкой с запятой. Список файлов также должен синхронизироваться с выбранными устройствами и каталогом. Это происходит при обработке события Change для DirListBox. При этом используется свойство Path элемента FileListBox: Private Sub Dirl Change() Filel.Path = Dirl.Path End Sub Так как элемент DirListBox уже синхронизирован с выбором диска, все три элемента теперь работают вместе. Для отображения полного имени файла, включая путь, нужно просто сложить соответствующие строки, содержащие значения имени диска, пути и имени файла. Поместить символ ”\”между путем и именем файла достаточно просто. Это выполняется следующим оператором:
IblPath.Caption = Filel.Path &”\”&Filel.Filename Чтобы избежать отображения в пути излишнего количества символов "\", например в случае выбора файла корневого каталога,нужно немного изменить код: Private Sub Filel_Click() If Right(Filel.Path,1)=c Then IblPath.Caption = Filel.Path & Filel.Filename Else IblPath.Caption = Filel.Path & ”\” & Filel.Filename End If End Sub Рамка (Frame) Рамка (Frame) - это один из элементов контейнеров. Его назначение объединить в группу несколько элементов управления. Объекты, объединенные с помощью рамки, можно как единое целое перемещать, активизировать и деактивизировать, делать видимыми или невидимыми. Некоторые элементы сами нуждаются в контейнере - например, все переключатели в форме всегда объединяются в одну группу. Чтобы создать вторую группу опций, нужно требуемые переключатели объединить в элементе контейнере. Для объединения объектов в группу нужно сначала создать элемент контейнер, затем добавить в него нужные элементы управления. Если требуемые элементы управления уже находятся в форме, их достаточно переместить в элемент контейнер. Чтобы проверить, действительно ли элемент принадлежит контейнеру, достаточно переместить контейнер. Элемент управления, принадлежащий контейнеру, будет перемещаться вместе с ним. Рамка - это элемент управления, который не имеет особых свойств, присущих только ей. События рамки обычно не анализируются, так как чаще всего проектировщик работает только с элементами управления, принадлежащими рамке. Окно с рисунком (PictureBox) Как следует из самого названия, элемент PictureBox предназначен для отображения рисунков и других графических объектов. Этот элемент управления также является элементом контейнером, поэтому его можно использовать для объединения других элементов. Как и события рамки, события элемента PictureBox обычно не обрабатываются, хотя при необходимости это можно сделать. Положение PictureBox в форме задается свойством Align, которое определяет будет ли PictureBox закрепляться у одного из краев формы или сохранит положение, заданное разработчиком. Если элемент управления закрепляется у одного из краев формы, то его размер (ширина или высота) всегда устанавливается в соответствии с размером формы. Свойство AutoSize определяет, будут ли автоматически изменяться размеры элемента управления для отображения рисунков различного размера. Самое важное свойство PictureBox - Picture, которое содержит отображаемый графический объект. Это может быть растровое изображение (*.ВМР), пиктограмма (*.IСО), метафайл (*.WMF) или расширенный метафайл (*.EMF), также GIF и JPEG файлы. При выполнении LoadPicture:
приложения
для
изменения
свойства
используется
Picturel.Picture = LoadPicture(”C:\WINDOWS \AUTOS.BMP”) Сохранить изображение можно при помощи функции SavePicture: SavePicture Picturel.Picture, ”BUILD.BMP”
функция
Методы PictureBox позволяют нарисовать точку, линию и окружность, также вывести текст (метод Print). Способность элемента PictureBox отображать рисунки различных форматов можно использовать для преобразования пиктограммы (*.IСО) в растровое изображение (*.ВМР). Для этого нужно загрузить пиктограмму и сохранить ее с расширением BMP. Однако растровое изображение преобразовать в пиктограмму нельзя. Изображение (Image) Элемент управления Image также создан для отображения рисунков. Но в отличие от PictureBox, он не является элементом контейнером. Он не позволяет рисовать и не допускает группирования объектов. Однако Image использует меньше ресурсов и перерисовывает быстрее, чем PictureBox. Поэтому для отображения рисунков Image может быть лучшим вариантом. Так как главное назначение обычно не анализируются.
Image
—
отображение
рисунков,
его
события
Главным свойством Image также является Picture. С его помощью можно определить рисунок, отображаемый элементом управления, на стадии проектирования либо при выполнении программы. Свойство Stretch определяет, как отображается рисунок. Если значение свойства Stretch равно True, то размеры рисунка изменяются до размеров элемента управления Image, в противном случае элемент управления изменяется до размера рисунка.
3.3 Активизация элементов управления Горячие клавиши Горячие клавиши (hot key) можно назначить почти всем элементам управления, имеющим свойство Caption. Их можно определять в Caption путем добавления знака амперсэнда (&) перед соответствующей буквой. Несмотря на то, что текстовое поле не имеет свойства Caption, для него также можно определить горячую клавишу. Для этого нужно добавить элемент управления Label перед текстовым окном и определить для него горячую клавишу. Затем следует присвоить свойству Tablndex элемента управления Label значение на единицу меньше, чем для такого же свойства текстового поля. Свойство Tablndex С помощью клавиши Tab в Windows можно передавать фокус от одного элемента другому. Свойство Tablndex элемента управления устанавливает последовательность перехода при нажатии клавиши Tab. Значение индекса 0 присваивается свойству Tablndex элемента управления, который помещается в форму первым. Visual Basic автоматически увеличивает это свойство. Это значит, что каждый новый элемент управления формы получает значение свойства Tablndex на единицу больше, чем у предыдущего элемента управления. Если вас не устраивает предложенная последовательность перехода, ее можно изменить с помощью свойства Tablndex. При этом Visual Basic автоматически изменит значения индексов остальных элементов управления. Если установить значение свойства TabStop элемента управления равным False,т о передать ему фокус посредством клавиши Tab будет невозможно.
3.4 Массивы элементов управления Для создания массива элементов экземпляров элемента с одним и тем обязательно по порядку, значениями эти элементы будут ассоциироваться
необходимо разместить на форме несколько же именем (свойство Name) и различными, не индекса (свойство Index). В результаты все с одними и теми же процедурами обработки
событий, в которых появится дополнительный управления, вызвавшего событие.
аргумент
–
индекс
элемента
Для динамической загрузки и разгрузки элементов из массива элементов управления можно использовать операторы {Load | Unload} массив (индекс). Другой метод добавления элементов управления заключается в использовании метода Add семейства Controls. Синтаксис метода Add следующий: объект.Add(ProgID, имя[, контейнер]) Здесь объект представляет собой семейство Controls, в которое добавляется элемент управления. ProgID – строка, идентифицирующая элемент управления (значение ProgID можно определить с помощью каталога объектов Object Browser; это значение обычно составляется из имени библиотеки и имени класса конкретного элемента управления ), имя - строка, идентифицирующая элемент семейства, контейнер - ссылка на объект-контейнер для элемента управления. Если этот аргумент не определен или равен NULL, то принимается по умолчанию контейнер, которому принадлежит семейство Controls. Для удаления элементов добавления с использованием метод Add, используется метод Remove объект.
3.5 Формы Каждая форма сохраняется в проекте в виде отдельного файла. Этот файл содержит описание рабочей среды и код, относящийся к элементам управления и форме. Формы сохраняются как обычные текстовые файлы Свойства формы Кроме стандартных свойств, таких как Caption, BackColor, Font и т.д., формы имеют и свои собственные свойства, присущие только им. Эти свойства рассматриваются ниже. Для просмотра свойств формы в окне свойств нужно либо щелкнуть в пустом месте формы (но не в строке заголовка), либо выбрать форму из списка объектов в окне свойств. Стандартное окно имеет рамку (border). С ее помощью пользователь может изменять размеры окна. Для этого в системном меню имеется соответствующая команда. Вид рамки можно изменить с помощью свойства BorderStyle, которое может принимать одно из следующих значений: •
0 = vbBSNone - Окно без рамки. Размер окна изменяться не может. Нет строки заголовка. Окно не может перемещаться. Минимизация и максимизация окна также невозможны.
•
1 = vbFixedSingle - Фиксированная рамка. Есть заголовок, кнопки минимизации и максимизации, но размер окна изменяться не может.
•
2 = vbSizable размера окна.
•
3 = vbFixedDialog - Окно окаймляется толстой рамкой. Изменения размера невозможны. Нет кнопок минимизации и максимизации. Минимизировать и максимизировать можно только из системного меню.
•
4 = vbFixedToolWindow - Поведение такое же, как vbFixedSingle, но строка заголовка более узкая и имеет меньший шрифт. Эта форма не отображается на панели задач Windows.
•
5 = vbSizableToolWindow - Поведение такое же, как vbSizeable, но строка заголовка более узкая и имеет меньший шрифт. Эта форма также не отображается на панели задач Windows.
-
Значение
по
умолчанию.
Возможны
все
изменения
С помощью рамки можно изменять не только внешний вид окна, но и его размеры. Это важно, так. как содержимое окна не подгоняется автоматически к
его измененному размеру. Это может привести к тому, что элемент управления после изменения размера будет находиться вне видимой области и поэтому «забудется». Не включится также и полоса прокрутки. Свойство ControlBox определяет, отображается ли системное меню, с помощью которого пользователь может выйти из программы (Alt+F4). Если системное меню удаляется, пользователю следует обеспечить другой способ выхода из программы. Кнопкой максимизации пользователь может увеличить окно до размера экрана. Ее наличие определяется свойством MaxButton формы. Если присвоить этому свойству значение False, то соответствующая кнопка будет отсутствовать, а команда Maximize (Развернуть) удалится из системного меню. Если для свойства MinButton задать значение False, то кнопка затемняется, из системного меню удаляется строка Minimize (Свернуть). События формы Имена процедур обработки событий формы всегда имеют формат Form_событие безотносительно к наименованию формы. Одним из наиболее используемых событий формы является Load. Это событие происходит при загрузке формы в память. Поэтому Load лучше всего подходит для инициализации объектов и переменных, принадлежащих форме. Событие Unload вызывается, если форма удаляется из параметра Cancel можно отменить удаление формы с экрана.
памяти.
С
помощью
Более практичным, чем Unload, является событие QueryUnload. Наряду с параметром Cancel в процедуру обработки события передается и параметр UnloadMode, указывающий причину возникновения события: •
0 = vbFormControlMenu - Пользователь закрыл приложение посредством Alt+F4, кнопки Close окна или одноименной команды системного меню
•
1 = vbFormCode - В коде выполняется команда Unload
•
2 = vbAppWindows - Завершение сеанса Windows
•
3 = vbAppTaskManager - Выход из приложения с помощью менеджера задач
•
4 = vbFormMDIForm вышестоящая форма MDI
Дочерняя
форма
MDI
закрыта,
так
как
закрыта
Проблема, возникающая при изменении размеров формы, уже рассматривалась. Решить ее помогает событие Resize, которое вызывается при любом изменении размеров формы. При этом следует учитывать два аспекта. Во-первых, во время обработки события Load форма еще не видна. Во-вторых, при загрузке и отображении формы всегда возникает и событие Resize, так как при запуске размеры формы изменяются от нулевых до заданных в свойствах формы. При создании процедур для связанных событий типа Activate, GotFocus, Paint и Resize следует убедиться, что их действия не находятся в противоречии друг с другом и что они не вызывают рекурсивных событий.
3.6 Меню Большинство приложений Windows обладает меню. Вы также можете оснастить им свое приложение, поскольку меню это тоже элемент управления. Прежде чем проектировать меню, следует ознакомиться с некоторыми правилами его создания. Обычно меню состоят из нескольких уровней. Верхний уровень - это строка меню, в которой находятся элементы главного меню. Они обозначают главные группы команд, например File или Edit. Лучше придерживаться общепринятой структуры меню - это облегчает пользователю изучение программы и работу с ней.
При выборе элемента меню первого уровня автоматически открывается меню второго уровня. Элементы второго уровня «выпадают» в виде списка. В большинстве приложений меню заканчивается на этом уровне. Но можно создать и больше уровней - максимум шесть. Правила составления меню Для обеспечения простого и удобного обращения с меню следует учитывать следующие правила: •
обычно элементы строки меню позволяют открывать меню следующего уровня. Если же требуется, чтобы после выбора команды меню выполнялся код, то текст элемента должен заканчиваться восклицательным знаком, например Info!;
•
ограничивайтесь двумя или находить элементы меню;
•
элементы меню, выполнение которых вызывает появление диалогового окна, отмечаются тремя точками после имени, например Open… .
тремя
уровнями
-
так
пользователю
легче
Создание меню Создание меню в Visual Basic осуществляется с помощью специального инструмента создания меню - редактора меню. Окно редактора меню открывается одним из трех способов: путем нажатия комбинации клавиш Ctrl+E, нажатием соответствующей кнопки на панели инструментов или после выбора команды меню Tools \ Menu Editor… . Меню строится иерархически. Проще всего создавать меню при помощи встроенного редактора меню Visual Basic. Для этого сначала в поле Caption окна редактора вводится текст, который будет виден в строке меню. Для быстрого открытия меню или вызова команды используются горячие клавиши. Для определения горячих клавиш достаточно в поле Caption перед соответствующей буквой пост вить амперсэнд (&). Например ,для быстрого открытия меню File в поле Caption диалогового окна редактора меню необходимо ввести ”&File”. Если же в качестве горячих клавиш нужно определить Alt+i, то в поле Caption следует ввести ”F&ile”. Второй шаг - назначение имени элементу меню (так же, как любому элементу управления). Visual Basic не задает имя по умолчанию, как для других элементов управления. Правила назначения имени При назначении имен элементам меню также нужно соблюдать правила. Имя должно состоять из следующих частей: прежде всего, префикса, указывающего, что это меню, т.е. mnu. Затем следует: для пунктов главного меню - имя пункта, для подменю - сокращенные имена родительских пунктов, а затем собственное имя меню, например: File
mnuFile
File\Qpen...
mnuFOpen
File\Send\Fax
mnuFSFax
Последняя задача при создании меню - определение уровней .Для этого воспользуйтесь кнопками со стрелками. Кнопка со стрелкой вправо смещает элемент меню на уровень ниже, а со стрелкой влево - на уровень выше. Кнопки с вертикальными стрелками изменяют позицию отдельных элементов меню, т.е. перемещают их в списке вверх или вниз. Поле Shortcut позволяет определить комбинации клавиш для быстрого доступа к отдельным элементам меню.
Свойства Visible, Enabled, Checked В последней строке верхней половины окна редактора меню есть еще три свойства элементов меню. Свойство Visible позволяет отображать или скрывать отдельные элементы меню. Свойство Enabled функционирует так же, как в других элементах управления: если его значение False, то текст надписи подсвечивается серым цветом и пользователь не может выполнить эту команду меню .Свойство Checked позволяет пометить выбранный элемент меню галочкой. Свойств элементов меню можно изменять и во время выполнения. При этом синтаксис такой же, как и для других элементов управления: mnuFLoad.Caption = ”&3агрузить” mnuFLoad.Enabled = False mnuFLoad.Visible = False mnuFLoad.Checked = True Для создания процедуры выполнения команды меню проектирования выбрать соответствующий пункт в форме. процедура обработки события Click.
следует во время При этом создастся
4. Введение в объектно-ориентированное программирование Объектно-ориентированное программирование - это методология разработки программ, основанная на представлении программы в виде совокупности объектов, каждый из которых является реализацией определенного класса. В объектноориентированном программировании объект представляет собой элемент приложения, например лист, ячейку, диаграмму, форму или отчет. Программный код и данные структурируются так, чтобы имитировалось поведение фактически существующих объектов. В объектно-ориентированном программировании важную роль играют четыре понятия. При абстрагировании реальные процессы ограничиваются их функциями, существенными для программирования. Внутреннее содержимое объекта защищается от внешнего мира посредством инкапсуляции. Благодаря наследованию уже запрограммированные функциональные возможности можно использовать и для других объектов. Полиморфизм позволяет использовать различные объекты и поразному реализуемые функции под одним именем. Объекты являются программным представлением физических и/или логических сущностей реального мира. Они необходимы для моделирования поведения физических или логических объектов, которые они представляют. Например, элемент управления TextBox служит для отображения или редактирования текста в форме. Для добавления элемента управления TextBox в форму не нужно писать ни строчки - можно просто воспользоваться готовым объектом TextBox из панели элементов. Для изменения поведения и состояния элементов управления используются их свойства и методы. На панели элементов Visual Basic находятся, строго говоря, не объекты, а классы. Различие между классами и объектами состоит в том, что объекты в Visual Basic существуют только во время выполнения. Классы же используются для задания структуры объектов. Во время выполнения создаются копии классов. Благодаря этому для данного класса можно создавать произвольное количество объектов. С другой стороны, классы образуют группы одноименных объектов.
4.1 Абстрагирование Человек использует абстрагирование для того, объекты окружающей среды. Представьте себе, что объектов (понятий), абстрагирующих окружающий сообщить другому человеку о каком то предмете, бы его подробно описывать. Трудно вообразить,
чтобы проще описывать сложные в обычном языке не существует мир. Тогда для того, чтобы например автомобиле, пришлось сколько времени потребовалось
бы для описания объекта. Причем описание должно быть очень точным, чтобы не возникло ошибочное представление о другом объекте. То же относится и к программированию. Например, для использования текстового окна (TextBox) не нужно разрабатывать специальный драйвер графической карты. Вы просто используете объект класса TextBox. Этот абстрагированный объект содержит все, что нужно для редактирования текста в Windows. Если вы создаете собственное приложение, то большую помощь при этом окажут собственные объекты. В исходном коде вы используете программное представление таких объектов, как фирмы, служащие, овары, счета и многое другое. Такой способ рассмотрения больше соответствует реальности, чем при чисто процедурной разработке приложений.
4.2 Инкапсуляция Объекты позволяют значительно упростить разработку приложения. В очень редких случаях разработчика интересует внутренняя реализация объектов. Главное, чтобы объект обеспечивал функции, которые он должен предоставить. Поэтому объекты защищены от внешнего вмешательства. Например, если вы хотите снять деньги со счета через банкомат, то без карточки это невозможно, так как его содержимое защищено от доступа случайного клиента. Денежные автоматы защищены - инкапсулированы. На процессы, протекающие внутри банкомата, и на его содержимое клиент не имеет прямого влияния. Взаимодействие клиента с объектом происходит через интерфейс. Обычно интерфейс определяет единственный способ входа в объект и выхода из него; детали реализации остаются инкапсулированными. При создании собственных объектов необходимо организовать такие же интерфейсы. В объектах Visual Basic интерфейсами являются свойства, методы и события. Только они предоставляются данным объектом в распоряжение других объектов. Благодаря этому система программирования предотвращает доступ других объектов (клиентов) к внутренним переменным состояния объекта, которые могут обрабатываться только предусмотренными для этого процедурами. Это имеет большое значение при сопровождении программы. Если в связи с изменившимися обстоятельствами потребуется изменить реализацию интерфейса объекта, то изменение ограничится только процедурой, относящейся к свойству или методу. Если синтаксис интерфейса не изменился, то можно с уверенностью сказать, что изменение не отразится на других проектах, использующих этот объект. В противном случае при попытке использовать переменную, которая не существует в новом варианте объекта, в других проектах может возникнуть ошибка. Инкапсуляция поддерживает абстрагирование тем, что объект можно использовать, не зная, как он реализован внутри. Если программист поддерживает определенны интерфейс, то инкапсуляцию можно обеспечить и при процедурном построении программы. В объектно-ориентированных языках реализация инкапсуляции обеспечивается системой программирования.
4.3 Наследование Наследованием мы называем повторное использование уже созданной части кода в других проектах. Посредством наследования формируются связи между объектами, а для выражения процесса используют понятия о родителях и потомках. В программировании наследование моделирует связь «это – является» или «это – имеет». Наследование служит для сокращения избыточности кода и суть его заключается в том, что уже существующий интерфейс вместе с его программной частью можно использовать для других объектов. При наследовании могут также проводиться изменения интерфейсов.
4.4 Полиморфизм Полиморфизм означает, что различные объекты используют одинаковую абстракцию, т.е. могут обладать свойствами и методами с одинаковыми именами. Однако обращение к ним будет вызывать различную реакцию для различных объектов. Большое достоинство полиморфизма состоит в том, что при использовании объекта можно вызывать определенное свойство или метод, не заботясь о том, как объект выполняет задачу. Это очень важно при модификации программного обеспечения. Изменения или новшества просто адаптируются к имеющимся компонентам приложения.
4.5 Модуль класса В Visual Basic классы используются в качестве шаблонов объектов. С их помощью во время выполнения можно создавать любое количество объектов одного класса. Внутренняя структура класса передается объекту посредством модуля класса. Таким образом, класс описывает семейство объектов,а каждый экземпляр класса является уникальным представителем этого семейства. При написании программ, для имитации поведения реальных объектах объединяются как принципы действия, так и данные.
объектов,
в
Для создания собственного объекта нужен шаблон. Эти шаблоны в Visual Basic представляют модули классов. С помощью команды Project \ Add Class Module или соответствующе кнопки панели инструментов Visual Basic такой модуль класса можно добавить в проект. После добавления модуля класса появляется пустое окно кода, в котором можно реализовать класс. В проектах типа Standard.EXE классы имеют только одно свойство - имя класса. В среде разработки Visual Basic отдельные файлы с расширением CLS..
все
модули
класса
сохраняются
как
В качестве классов могут также применяться и формы, в частности, если необходимо, чтобы создаваемый объект функционировал как окно. Все описанные здесь действия можно выполнять как с модулем класса, так и с формой. После добавления модуля класса или формы в проект можно создавать свойства и методы. Visual Basic предоставляет и другую возможность создания классов. Если на вкладке Environment диалогового окна Tools \ 0ptions в группе Show Templates For активизировать опцию Class Modules, то при добавлении модуля класса отобразится диалоговое окно Add Class Module. С его помощью можно либо создать пустой модуль класса, либо запустить мастер классов Visual Basic (утилита Class Builder). Для редактирования уже существующих в проекте классов эту утилиту можно вызвать также посредством команды Class Builder Utility меню Add Ins из окна кода Visual Basic. При помощи команды File \ New \ CIass данного мастера можно добавить новый модуль класса. В открывающемся диалоговом окне Class Module Builder следует задать имя класса и, при необходимости, казать ряд других параметров. В списке Based On можно указать имя класса, на котором основан создаваемый класс. На вкладке Attributes можно задать описание модуля класса (комментарий), а также имя справочного файла для данного класса. Чтобы все изменения, выполненные мастером, были перенесены в проект, следует либо выполнить команду Update Project меню Files мастера, либо при завершении работы с мастером утвердительно ответить на вопрос о необходимости сохранения изменений. С помощью мастера, кроме классов, можно создавать собственные коллекции, добавлять к ним сво ства, методы и события.
4.6 Свойства
Чтобы можно было использовать объекты класса (Сlass или Form), необходимо создать соответствующие свойства и методы. Свойства в общем случае предназначены для изменения значений переменных состояния объектов. Например, свойство Text текстового окна позволяет задавать либо считывать значение отображаемой строки. При этом обычно объект не выполняет никаких действий. Свойства, не соответствующие этому правилу (например, CommonDialog1.Action = 1), следует заменять методами, реализующими аналогичные функции (CornmonDialog1.ShowOpen). Есть две возможности реализации свойств в классах: использование процедур свойств, позволяющих контролировать значения свойств, или объявление в классе переменных общего доступа (Public). Однако, переменные, объявленные как Public, не обладают всеми возможностями процедур свойств.
4.7 Процедуры свойств Кроме процедур Sub и Function, в Visual Basic есть и третья категория процедуры Property, с помощью которых можно определять свойства класса. Чтобы процедуры были видимыми вне собственного контейнера, их следует объявлять как Public. Поскольку значения свойств можно как считывать, так и устанавливать, то для одного свойства могут потребоваться две процедуры с одним и тем же именем: одна для чтения, другая для присвоения значения свойства. Чтобы различить их, в заголовке процедуры используется дополнительное ключевое слово (Let или Get). Оператор Property Let В Visual Basic операция присваивания значения переменной имеет следующий синтаксис: [Let] имя_перемнной = выражение Явное использование необязательного ключевого слова Let зависит от стиля программирования, поэтому при присваивании значения переменной оно обычно не указывается. Однако в процедуре присваивания значения свойству использование ключевого слова Let обязательно, так как в этом случае оно указывает, что данная процедура является процедурой задания значения свойства. Public Property Let Property_Name(ByVal vNewValue As Variant) mVariable = vNewValue End Property Переменная vNewValue содержит значение, присваиваемое свойству. При этом тип данных этой переменной должен соответствовать типу данных свойства. Оператор Property Get Процедура считывания ключевого слова Get.
значения
свойства
объявляется
с
использованием
Public Property Get Property_Name () As Variant Property_Name = mVariable End Property Здесь, как и в процедуре Function, возвращаемое значение присваивается имени процедуры. При создании процедуры Property Get следует обратить внимание на то, что она использует тот же тип данных, что и одноименная процедура Property Let. Обычно при определении свойства необходимо задавать обе процедуры. Воспользовавшись командой Add Procedure меню Tools, можно сэкономить время,
поскольку эта команда позволяет создать одновременно обе процедуры свойств (Property Get и Property Let). Оператор Property Set Существует и третий тип процедур свойств - процедура Property Set. Процедура Set используется аналогично Let, но передает не значение свойства, а ссылку на объект. Public Property Set Property_Name (ByVal objNewValue As Object) Set Property_Name = objNewValue End Property В этой связи важную роль играет свойство по умолчанию. Каждый элемент управления имеет такое свойство, которое всегда используется Visual Basic, если имя свойства в коде явно не указано. Text1 = ”Hello” ‘равнозначно Textl.Text =”Hello” vVariable =Text1 В приведенном примере свойству Text текстового окна присваивается определенное значение. Во второq строке это значение считывается. Но если переменной объекта требуется передать сам объект Text1, то строка кода должна выглядеть иначе - при присваивании объектных переменных в Visual Basic вместо неявного ключевого слова Let следует явно использовать ключевое слово Set. vVariable = Text1 ‘Содержимое: ”Hello” Set vVariable = Text1 ‘Содержимое: копия Text1
4.8 Методы Для использования объектов класса (Class или Form) нужны соответствующие свойства и методы. Методы используются для расширения функциональных возможностей объекта. Существует два типа процедур: с возвращаемым значением (синтаксис функции) и без возвращаемого значения (синтаксис оператора). Это также относится и к методам. Например, метод Clipboard.SetText использует синтаксис оператора, а метод Clipboard.GetText - синтаксис функции. При создании методов действуют те же правила, за исключением того, что процедуры Sub и Function следует объявлять как Public. Синтаксис процедуры Для создания метода без возвращаемого значения в модуль класса необходимо добавить процедуру Public Sub, имя которой будет именем метода: Public Sub имя_метода() … End Sub Обращение к такому методу аналогично вызову обычной процедуры. При необходимости процедуре могут передаваться аргументы. Посредством аргументов более точно определяется характер выполняемого действия или передаются обрабатываемые элементы. Синтаксис функции Методы с возвращаемыми значениями реализуются как Public Function, а имя функции становится именем метода. Public Function имя_метода () As тип_данных имя_метода = выражение
End Function Как и в обычной функции, возвращаемое значение присваивается имени функции. Обращение к такому методу аналогично обычному вызову функции. В методах такого типа также могут использоваться аргументы. При этом действуют те же правила, что и в обычных функциях. Мастер классов Создать метод очень просто с помощью мастера классов. Для добавления метода следует в левой части окна мастера классов выбрать соответствующий класс и при помощи команды меню File \ New \ Method или соответствующей кнопки панели инструментов окна мастера открыть диалоговое окно Method Builder. В поле Name следует указать имя метода, в поле Return Data Type - тип данных возвращаемого значения (если метод должен возвращать данные). Если поле Return Data Type оставить пустым, будет создана процедура Sub. Если указать тип данных, будет создана процедура Function В список Arguments посредством кнопки со знаком (+) можно добавить аргумент метода с указанием его имени и типа данных. Если при этом установить флажок ByVal, аргумент будет передаваться по значению. В Visual Basic 6.0 аргумент может быть массивом (Array), массивом параметров (ParamArray, который применяется, если количество передаваемых процедуре аргументов заранее неизвестно), параметром по умолчанию (Default), необязательным параметром (Optional), а также передаваться по значению (ByVal). Кроме того, при использовании аргумента поддерживаются перечисления (Enums). Аргументы, ошибочно добавленные в список Arguments, можно удалить с помощью кнопки удаления. Порядок аргументов можно изменить с помощью двух кнопок со стрелками. Использование Обычно методы содержат намного больше кода, чем процедуры свойств, так как в них выполняется непосредственная обработка данных. Сложные задачи можно разбить на несколько процедур (Sub или Function), которые объявляются как Private, поскольку могут использоваться только внутри класса. Инкапсуляция внутренних данных является большим преимуществом ООП.
4.9 События События - это реакции объекта на действия системы, пользователя или других приложений. Анализ и обработка событий позволяет объекту реагировать на внешние воздействия. Каждый класс имеет набор собственных событий. По умолчанию все классы содержат два события, которые происходят после загрузки и перед выгрузкой объекта. Эти события - Initialize и Terminate. Объекты, определяемые пользователем, могут генерировать собственные события. События создаются в два этапа. Сначала в секции объявлений класса объявляется событие (при необходимости с аргументами), а затем в процедуре внутри класса происходит вызов этого события. Событие, определяемое пользователем, объявляется внутри класса с помощью оператора Event. Аргументы, передаваемые процедуре обработки события, должны указываться в строке объявления события. Для генерации события внутри класса предназначен которому в качестве аргумента передается имя события..
оператор
RaiseEvent,
Контейнер, в котором используется объект, должен содержать процедуру обработки события. До создания процедуры обработки события нужно объявить объект, используя ключевое слово WithEvents. После такого объявления указанный объект будет добавлен в список (Object) окна кода, в результате чего из списка (Procedure) можно будет выбирать
события объекта. Иногда процедуре обработки события требуется передавать некоторые аргументы (например, процедуре обработки события MouseMove передаются параметры состояния кнопок мыши и позиции курсора). Такие аргументы описываются при объявлении события. При вызове оператора RaiseEvent вместе с именем события указываются и значения аргументов, которые обрабатываются в соответствующей процедуре: События могут генерироваться только в том классе, в котором объявлены. События, определяемые Class Module или Form.
пользователем,
применяются
только
в
контейнерах
Мастер классов может помочь и при создании событий. Для создания события в окне мастера выбирается нужный класс, а затем вызывается команда меню File \ New \ Event. В появившемся диалоговом окне следует задать имя события и, при необходимости, его аргументы. Так же, как и при создании методов, с помощью соответствующих кнопок в окне мастера можно создать список аргументов, их типы данных и порядок. В результате работы мастера в модуль класса вставляется соответствующая строка. При создании событий работа с мастером может показаться более хлопотной, чем непосредственный ввод кода в области объявлений. Все остальные действия при создании событий с помощью мастера должны выполняться вручную.
4.10 Объекты, определяемые пользователем После обеспечения использовать.
класса
свойствами,
методами
и
событиями
его
можно
Использовать классы непосредственно в программе нельзя. Внутри приложения используются объекты, созданные на основе класса. На основе одного класса можно создать любое количество объектов – экземпляров класса. В Visual Basic объекты класса создаются с помощью ключевого слова New. Это слово следует использовать при объявлении переменных, например в строке Dim: Dim obj As New Class1 В этом примере создается новый объект класса Class1 с именем obj. В Visual Basic доступ к объектам всегда производится посредством переменных. Поэтому строка New очень похожа на обычное объявление переменной. Новый объект можно создать и по другому, с помощью следующего кода: Dim obj As Class1 Set object = New Class1 При выполнении присваивания объектных переменных всегда нужно использовать оператор Set. При присваивании значений не обязательно указывать оператор Let. При объявлении переменных объекта действуют те же правила в отношении области действия и времени жизни, что и для обычных переменных. Объекты класса обладают всеми свойствами, методами и событиями, которые определены в исходном классе, однако каждый объект класса может иметь различные значения свойств и функционировать независимо от других.. После того, как объектной переменной присвоена ссылка на объект класса, к ней можно обращаться как к обычному элементу управления. Чтобы использовать события объекта, при его объявлении следует применять ключевое слово WithEvents. Однако оно не может применяться вместе с ключевым словом New. Для удаления объектной переменной из памяти необходимо удалить ссылку на объект. Если ссылки на объект не существует, переменная удаляется из памяти. Для удаления ссылки из объектной переменной используется ключевое слово Nothing. Если на используемы объект не ссылаются другие переменные, то Windows удаляет его из памяти. Значение Nothing должно присваиваться посредством оператора Set, как при любом присваивании объектов.
4.11 Каталог объектов Каталогом объектов Visual Basic (Object Browser) удобен для просмотра объектов. С его помощью можно просмотреть все имеющиеся свойства, методы и события. Для открытия окна каталога объектов можно воспользоваться кнопкой панели инструментов Visual Basic. Из списка Project / Library выберите имя проекта. После этого в списке Classes появляются имена всех классов выбранного проекта. Имена всех свойств, методов и событий данного класса отображаются в списке Members of после выбора нужного класса. Свойства отображаются независимо от того, как они были реализованы: как процедуры свойств или как переменные Public. В окне подсказки отображается дополнительная информация, например используемый тип данных. Голубой кружок над пиктограммой свойства указывает, что данное свойство является свойством по умолчанию. Для методов выводится список аргументов с указанием их типа данных, а также типа данных возвращаемого значения. Для событий указываются аргументы и их типы данных. Если при создании элемента с помощью мастера в соответствующем диалоговом окне свойств на вкладке Attributes вы задали описание, введенный текст появится в окне подсказки. Добавить текст описания можно также в окне каталога объектов, щелкнув правой кнопкой мыши на соответствующем элементе списка. В появившемся контекстном меню выберите команду Properties и введите текст описания в диалоговом окне Procedure Attributes. Это диалоговое окно можно открыть и в среде разработки с помощью команды Tools \ Procedure Attributes. Каталог объектов, как правило применяется для поиска объектов, методов или свойств. Если нужный компонент найден, его имя можно скопировать в буфер обмена с помощью кнопки Copy to Clipboard. Если выбранный класс находится в текущем проекте, можно отобразить модуль класса с помощью кнопки View Definition. Если для элемента указан справочный файл и Help Context ID, можно получить соответствующую тему справки с помощью кнопки Help. С помощью диалогового окна Procedure Attributes можно выполнить операции над классом, например скрыть свойство, метод или событие. При использовании каталога объектов внутри проекта также отображаются элементы, объявленные как Private.
4.12 Раннее и позднее связывание Скорость выполнения приложения может зависеть от того, каким образом Visual Basic осуществляет связывание переменных с их объектами. Связывание может быть ранним (Early Binding)или поздним (Late Binding). Раннее связывание осуществляется, указывается конкретный тип данных:
если
при
объявлении
переменной
Dim objVarl As TextBox Dim objVar2 As Class1 Dim objVar3 As Word.Application В приведенном примере при объявлении переменных их типы данных указываются точно. Раннее связывание выполняется быстрее, чем позднее, поэтому рекомендуется использовать его всегда. Позднее связывание выполняется, если определенный тип объекта не указывается. Dim objVarl As Object Dim objVar2 As Variant Dim objVar3 As Control
при
объявлении
переменной
В данном примере типы переменных определяются только при присваивании им конкретного объекта, а при объявлении переменноq указывается только универсальный тип. При таком объявлении при каждом обращении к объекту анализируются все допустимые объекты, а это требует значительных затрат времени. Позднее связывание следует использовать в тех случаях, если при разработке невозможно заранее определить, какие типы объектов будут использоваться.
4.13 События Initialize и Terminate Кроме событий, определяемых пользователем, классы всегда содержат события Initialize и Тегminate, которые являются аналогами событий формы Load и Unload. Событие Initialize класса наступает при первом использовании объекта. В процедуре обработки этого события следует выполнять код, необходимый для инициализации объекта. Это может быть, например, объявление собственных объектов или подключение к серверу базы данных. Объявление переменной с помощью оператора Dim не вызывает наступление события Initialize - это событие вызывается только при первом обращении к свойствам или методам объекта. Как только уничтожаются все ссылки на объект, Windows удаляет этот объект из памяти. В этот момент наступает событие Terminate. Private Sub Commandl_Click() Set obj = Nothing ‘наступает Terminate End Sub Это событие используется для того, чтобы объект мог корректно освободить память, т.е. удалить все внутренние объекты или отсоединиться от внешних источников данных. При создании собственных классов можно легко контролировать наступление событий Initialize и Terminate. Для этого временно на период отладки в модуль класса следует поместить следующий код: Private Sub Class_Initialize() MsgBox ”Инициализация” End Sub Private Sub Class_Terminate() MsgBox “Удаление” End Sub
4.14 Оператор Implements С помощью оператора Implements можно передавать интерфейсы одного объекта другим. Для этого в качестве шаблона используется так называемый абстрактный класс, который не содержит кода, а только задает структуру интерфейса. Абстрактные классы служат не для создания объектов, а для определения набора свойств и методов. Поскольку на основе класса Visual Basic всегда можно создать объекты, даже если модуль класса не содержит кода, то, строго говоря, в Visual Basic нет абстрактных классов. При реализации интерфейса или класса необходимо включить в новый класс или интерфейс все составные части (процедуры, свойства) исходного объекта, объявленные как Public.
В производном классе после применения оператора можно воспользоваться определенными в абстрактном методами.
Implements имя_класса классе свойствами и
Все процедуры абстрактного класса объявляются как Private. Это необходимо для того, чтобы они сами не становились свойствами или методами производного класса. Весь код может находиться либо в абстрактном, либо производном классе. Можно разделить код между двумя классами. Оператор Implements программный код.
позволяет
многократно
использовать
один
и
тот
же
4.15 Обработка ошибок Классы, определяемые пользователем, должны иметь собственные обработчики ошибок. Если внутри класса невозможно устранить ошибку, то эту задачу должна взять на себя вызывающая процедура. Для этого используется объект Err: Err.Raise number [,source ][ ,description ][,helpfile,helpcontext ] Метод Raise использует некоторые именованные аргументы. Аргумент number содержит уникальны код ошибки. Для кодов ошибок, определяемых пользователем, к непосредственному номеру следует прибавить константу vbObjectError. При этом нельзя выходить за пределы области значений переменных типа Long. Аргумент source содержит ссылку на источник ошибки, т.е.на класс. При задании аргумента source следует использовать структуру ProjectName.ClassName. Аргумент description содержит текст, процедуре обработки ошибки этот текст свойством Description объекта Err.
описывающий возникшую ошибку. В можно получить, воспользовавшись
Аргументы helpfile и helpcontext указывают справочный файл и в нем - тему справки. С помощью метода Raise ошибка передается вызывающе должна иметь соответствующий обработчик ошибок.
процедуре,
которая
Реакция на ошибки Реакцию среды разработки на ошибку можно настроить, воспользовавшись вкладкой General диалогового окна Options, которое открывается одноименно командой меню Tools. На вкладке General разработчик может выбрать один из трех вариантов реакции среды разработки на ошибку: •
Break on All Errors - при возникновении ошибки среда разработки переходит в режим прерывания (отладки) независимо от того, имеется или нет активная процедура обработки ошибок, и независимо от того, находится ли ошибочный код в модуле класса.
•
Break in Class Module - возникновение любо необрабатываемой ошибки в модуле класса приводит к переключению среды разработки в режим отладки и выделению строки кода, вызвавшей ошибку
•
Break on Unhandled Errors - если процедура обработки ошибок активна, то возникшая ошибка обрабатывается без переключения среды в режим отладки. Если же такая процедура отсутствует, то происходит переключение среды в режим отладки. Если ошибка произошла в модуле класса, то выполнение программы останавливается в вызывающей процедуре, а не в модуле класса..
Использование Собственные классы можно использовать и для централизованной обработки ошибок. При этом код ошибки передается объекту, определяемому пользователем.
Объект анализирует и обрабатывает ошибку и через возвращаемое значение информирует источник ошибки о необходимости выполнения определенных действий.
4.16 Коллекции Объект Collection - это упорядоченный набор элементов, на который можно ссылаться как на единое целое. Благодаря этому возможно объединение собственных объектов в легко управляемые логические единицы. Некоторые задачи, решаемые с помощью коллекций, можно решить также с помощью массивов или переменных, определяемых пользователем, однако коллекции имеют некоторые преимущества: •
коллекциями можно управлять и они более гибко индексируются;
•
методы коллекций позволяют добавлять и удалять объекты;
•
коллекции требуют меньше памяти;
•
размер коллекций регулируется автоматически (без явного использования оператора ReDim)
Методы и свойства Посредством методов Add и Remove добавляются или удаляются отдельные объекты коллекции. Доступ к конкретному объекту коллекции осуществляется с помощью метода Item. Свойство Count содержит число объектов коллекции. Для добавления объектов в коллекцию используется метод Add. При этом следует указывать имя объекта. Дополнительно можно передавать аргумент key с помощью которого в дальнейшем можно будет обращаться к данному объекту. Collection.Add object [,key ] [,before ] [,after ] Здесь: object - объект, который нужно добавить; key - символьная строка для идентификации объекта; before - номер позиции предыдущего объекта; after - номер позиции последующего объекта. Для удаления объекта из семейства используется метод Remove. При этом для идентификации объекта указывается либо номер позиции, либо аргумент key. С помощью метода Item можно получить доступ к определенному элементу коллекции. Для идентификации этого элемента так же, как и при Remove, используется номер позиции или аргумент key. Семейства представляют собой удобный способ управления большим количеством объектов. Мастер классов Собственные семейства можно создавать также с помощью мастера классов. Для создания семейства в окне мастера классов нужно выполнить команду File \ New \ Collectfon или нажать соответствующую кнопку панели инструментов. На экране появляется диалоговое окно, в котором следует указать имя семейства. Если в проекте уже существуют классы, то один из них можно использовать для создания коллекции объектов конкретного класса. Если проект не содержит классов, семейство создается на основе нового класса. Мастер формирует новый класс, создавая для него все необходимые методы и свойства. Цикл For Each...Next Для работы со всеми элементами семейства можно воспользоваться специальной формой цикла For...Next - For Each...Next. В этом цикле также используется
объектная переменная цикла (счетчик). Каждый элемент в семействе один раз присваивается объектной переменной. Если обработаны все элементы, выполняется автоматически выход из цикла. Хотя такую возможность можно реализовать с помощью свойства Count и цикла For...Next, все же цикл For Each...Next более удобен.