Как выглядят инструкции объявления констант и переменных

Объявление переменных и констант простых типов

В своем развитии Visual Basic прошел сложный путь — от бестипового языка с примитивным способом объявления переменных к структурированному языку с хорошо определенными типами данных и структурами управления. Но рудименты продолжают жить, и потому в языке одновременно существуют разные по идеологии способы определения данных. В частности, переменные можно объявлять или не объявлять, и тогда тип ей будет присвоен по умолчанию или по первой букве имени или по специальному символу объявления типа, которым может заканчиваться имя. Явно объявить переменную можно как в начале блока, так и в том произвольном месте, где возникла необходимость использовать новую переменную. Всеми этими рудиментами пользоваться не следует. Если в начало модуля вставить оператор Option Explicit (Опция «Явно»), то явное объявление переменных в этом модуле становится обязательным. Мы рекомендуем придерживаться следующей стратегии:

Всегда используйте явное объявление типа. Всегда помещайте объявления переменных в начало блока. Включите в Редакторе VBA в меню Tools на вкладке Editor флажок Require Variable Declaration. В этом случае во всех модулях Ваших проектов будет автоматически появляться оператор Option Explicit. Тем самым, Вы принуждаете себя следить за соблюдением правил хорошего тона в программировании.

При объявлении переменной определяется ее тип и область видимости — область, где имя переменной видимо и, значит, возможен доступ к ее значению. Важно понимать, что переменные можно объявлять на двух уровнях — уровне процедуры и уровне модуля . Для объявления переменных используются операторы Dim, Public, Private и Static. Первый можно использовать на обоих уровнях, Public и Private — на уровне модуля, Static — только на уровне процедуры.

Переменные, объявленные на уровне процедуры, называются локальными по отношению к данной процедуре. Их областью видимости является только та процедура, в которой они объявлены. Переменные уровня модуля являются глобальными . Они объявляются в разделе Declarations, который есть у каждого модуля. Область видимости глобальных переменных может распространяться:

• на все процедуры одного модуля, в котором они объявлены; такие глобальные переменные, называемые закрытыми ( Private ), должны быть объявлены на уровне модуля либо оператором Private либо оператором Dim ;
• на весь программный проект — все процедуры всех модулей данного проекта; такие глобальные переменные, называемые открытыми ( Public ), должны быть объявлены оператором Public.

Локальные переменные уровня процедуры могут быть объявлены оператором Static, что делает их статическими. У таких переменных увеличивается время жизни. Обычные локальные переменные рождаются при входе в процедуру, видимы только в ней и «умирают», выходя из процедуры. Это значит, что память под переменные отводится при входе в процедуру, а при выходе она освобождается. Область видимости статических переменных по-прежнему — процедура, но время жизни иное, так как у них не отбирается память при выходе, — она просто становится временно недоступной. Поэтому при повторном входе в процедуру статические переменные восстанавливают те значения, что у них были при последнем выходе. Статические переменные — это хранители информации между многократными вызовами одной и той же процедуры. Чтобы статические переменные имели смысл, необходима первоначальная инициализация переменных, — они должны иметь хоть какие-то значения уже при первом вхождении в процедуру. Вот как VBA инициализирует переменные в момент их объявления:

• 0 — для численных значений;
• пустая строка («») — для строк переменной длины;
• строка, содержащая нули, — для строк фиксированной длины;
• Empty (значение, указывающее на отсутствие инициализации) — для типа Variant ;
• для массивов и записей (типа, определенного программистом), каждый элемент инициализируется в соответствии с указанными правилами.

Синтаксис объявления простых переменных

Объявление простых переменных имеет следующий синтаксис:

{Dim | Private | Public | Static }<имя переменной> [ As <имя типа>]
      [, <имя переменной> [ As <имя типа>]]…

Вначале идет имя оператора, а потом список объявлений переменных, где роль разделителя играет запятая. Каждое объявление связывает имя переменной с ее типом, заданным конструкцией As. Будьте внимательны, VBA неприятно отличается в этом вопросе от других языков программирования. Здесь, как обычно, одним оператором можно объявить произвольное число переменных, но следует в каждом объявлении указывать конструкцию As, иначе переменным без As будет приписан тип Variant. На наш взгляд, то, что одним As нельзя объявить список переменных одного типа, — некий синтаксический «прокол», приводящий, если не к серьезным ошибкам, то к излишнему и не предполагаемому употреблению типа Variant.

Заметьте, есть и приятное отклонение, — имена переменных в VBA можно задать, используя русский алфавит.

Приведем пример, где действуют модули Father и Mother, в каждом из которых объявлены глобальные (общие и закрытые) переменные. В каждом из модулей объявлены две процедуры, взаимно вызывающие друг друга. Отладочная печать в процедурах позволит проследить за изменением значений глобальных, локальных и статических переменных. Вот тексты модулей Father и Mother — объявления глобальных переменных и процедур:

'Option Explicit
Public Fx As Byte, Fz As Integer
Private Fy As Integer

Public Sub Start()
	'Инициализация глобальных переменных
	Fx = 10: Fy = 11: Fz = 12
	Mx = 20: My = 21: Mz = 22
	Father1
End Sub

Public Sub Father1()
	Dim Fz As Byte 'Локальная переменная
	Fx = Fx + 2
	Fy = Mx - 2
	Fz = 1
	Debug.Print "Father1: Fx=", Fx, " Fy =", Fy, "Fz =", Fz
'Вызов процедуры другого модуля
	Mother1
End Sub

Здесь мы приводим тексты модуля Mother:

'Option Explicit
Public Mx As Byte
Private My As Integer

Public Sub Mother1()
	'Объявление статической переменной
	Static Count As Byte
	Count = Count + 1
	Mx = Mx - 2: Fz = My + 2
	Debug.Print "Mother: Статическая переменная Count =", Count
	'Вызов процедуры Father другого модуля или заключительной - Finish
	If Fx < Mx Then Father1 Else Finish
End Sub

Public Sub Finish()
	'Заключительная печать
	Debug.Print "Finish: Fx = ", Fx, "Fy =", Fy, "Fz =", Fz
	Debug.Print "Mx =", Mx, "My =", My, "Mz =", Mz
	'Объявления разных типов и печать значений, полученных при объявлении
	Dim B As Byte, I As Integer, L As Long
	Dim Sng As Single, D As Double, C As Currency
	Dim SF As String * 7, SV As String, Dat As Date
	Dim O As Object, V
	Debug.Print "B =", B, "I=", I, "L=", L
	Debug.Print "Sng =", Sng, "D =", D; "C=", C
	Debug.Print "SF =", SF, "SV =", SV, "Dat=", Dat
	If O Is Nothing Then Debug.Print "Объект не определен"
	If V = Empty Then Debug.Print "Variant переменные не инициализированы"
End Sub

Запустив процедуру Start модуля Father, мы получили такие результаты отладочной печати:

Father1: Fx=	12	Fy =	18	Fz =	1 
Mother: Статическая переменная Count =	1 
Father1: Fx=	14	Fy =	16	Fz =	1 
Mother: Статическая переменная Count =	2 
Father1: Fx=	16	Fy =	14	Fz =	1 
Mother: Статическая переменная Count =	3 
Finish: Fx =16	Fy =	Fz =	2 
Mx =	14	My =	0	Mz =	
B =	0	I=	0	L=	0 
Sng =	0	D =	0	 C=	0 
SF =	SV =	Dat=	0:00:00 
Объект не определен
Variant переменные не инициализированы

Дадим краткий комментарий:

• Процедуры Father и Mother трижды взаимно вызывают друг друга. Статическая переменная Count подсчитывает число сделанных обращений.
• Процедура Father печатает значения глобальных переменных Fx, Fy и локальной переменной Fz. Заметьте, локальное объявление «сильнее» глобального.
• Процедура Finish печатает заключительные значения переменных Fx, Fy, Fz, Mx, My и Mz. Здесь печатается значение глобальной переменной Fz, а значения двух переменных — Fy и Mz — не определены. Дело в том, что Fy — закрытая переменная модуля Father, а Mz вообще не объявлялась. И все же ошибки не возникает, так как действуют объявления по умолчанию и обе эти переменные считаются объявленными в модуле Mother и по умолчанию имеют тип Variant. Именно здесь кроется причина возможных ошибок, во избежание которых мы и советовали включить оператор Option Excplicit. Будь это сделано, — появились бы предупреждающие сообщения. У нас эти опции написаны, но специально закомментированы для демонстрации эффекта их отсутствия. Если их включить, то ошибка сразу встретится в процедуре Start — ведь переменные My и Mz не определены в модуле Father.
• Вторая часть процедуры Finish носит самостоятельный характер, — она демонстрирует объявления всех простых типов и печать значений, получаемых переменными при объявлении. Заметьте, как проверяется неопределенность объекта и пустота значений переменных.

Объявления по умолчанию

Настоятельно рекомендуем: не используйте средств, о которых мы сейчас расскажем. Мы и приводим их в первую очередь для того, чтобы дать подобный совет. Все необъявленные явно переменные по умолчанию считаются объявленными и имеют тип Variant. В VBA есть старомодные средства Бэйсика, позволяющие не объявлять переменную явно, но устанавливать ее тип по первому или последнему символу имени переменной. Имена переменных VBA могут заканчиваться специальным символом, позволяющим установить тип этой переменной:

• % — Integer ;
• & — Long ;
• ! — Single ;
• # — Double ;
• @ — Currency ;
• $ — String.

Есть еще одна возможность определения типа по первой букве имени. С этой целью в язык введена серия операторов DefType (по одному на каждый тип DefBool, DefInt и т. д.), определяющих свой диапазон букв для каждого типа. Если первая буква имени необъявленной переменной входит в тот или иной диапазон, ей приписывается соответствующий тип. Эти операторы устанавливаются на уровне модуля и действуют на все его процедуры.

Концевой символ установления типа сильнее, чем DefType, а тот сильнее стандартного «умолчания» Variant. Но все они — архаизмы, не приличествующие современному стилю программирования.

Константы

Одними переменными не обойтись, — нужны и константы. Для каждого простого типа есть соответствующие ему константы. Синтаксис построения констант задается так, чтобы по ее значению однозначно можно было приписать ей тип. Поэтому в отличие от переменных константы могут не объявляться, не иметь имени и появляться там, где надо, заданные своими значениями.

Но в VBA можно объявлять именованные константы, задавая в момент объявления значение константы и, возможно, ее тип. Вообще объявление константы во многом напоминает объявление переменной. Однако в этот момент задается значение, которое уже нельзя изменить. Рассмотрим синтаксис оператора Const, используемого

[Public | Private] Const <имя константы> [As type] = <константное выражение>

Вот пример определения классической константы:

Public Const pi As Double = 3.141593

Как и переменные, именованные константы можно объявлять на уровне процедуры или модуля. В первом случае используется только ключевое слово Const, во втором — дополнительно можно задать спецификаторы Public или Private, позволяющие объявить константу общей для всех модулей или закрытой. По умолчанию глобальные константы имеют статус Private. У локальных констант, объявленных в процедурах, областью видимости является процедура. Если не определить тип константы, он будет восстановлен по значению константного выражения. Но иногда лучше это делать самому.

Встроенных констант огромное количество. Есть, например, встроенные константы, связанные с тем или иным приложением, например, Excel или Word. Обычно они имеют соответствующий префикс ( xl, wd и т. д.). Но есть и встроенные константы самого VBA. Они позволяют задавать тип календаря, дни недели, цвет, клавиши и могут применяться в конкретной ситуации, скажем, при работе с окном сообщений. Большинство таких констант начинается с префикса vb, например:

vbWhite, vbSunday, vbKeyEscape, vbOKOnly.

5. ПЕРЕМЕННЫЕ И КОНСТАНТЫ

Иногда необходимо запомнить или записать
кое-что на память. Мы для этого пользуемся, например, записной книжкой (простой
или электронной), записями на бумаге, а иногда — зарубками.

При выполнении вычислений или обработке
информации тоже требуется иногда запоминать некоторые промежуточные результаты.
Для каждого из этих результатов выделяется участок памяти компьютера, состоящий
из одного или нескольких байтов (это фундаментальное понятие вычислительной
техники конечно известно читателю). Для того чтобы эти участки памяти можно
было различать, а также иметь возможность сослаться на содержимое некоторого
конкретного участка памяти (ведь не укажешь же на него пальцем), ему
сопоставляют имя. Вот эта пара, включающая участок памяти и сопоставленное ему
имя, и есть переменная.

Итак, переменная – это в некотором смысле
ячейка для хранения информации, например, числа, строки символов. При этом
имеется возможность неоднократно считывать значение переменной, а также
возможность записывать в эту ячейку другое значение. Переменная может изменять
свое значение в процессе выполнения программы. Ее значение может оставаться
неизменным от начала до конца выполнения программы, но принимать разные
значения в разных прогонах программы.

Имена переменных в Visual
Basic должны удовлетворять следующим требованиям:

·       
начинаться
с буквы;

·       
включать
только буквы, цифры, символ подчеркивания (_), который на клавиатуре находится
под тире (-);

·       
содержать
не более 255 символов.

Обратите внимание, имя не может содержать
пробел ( ), точку (.), запятую (,), восклицательный знак (!) или символы (@),
(&), ($), (#). Не следует использовать имена, совпадающие с ключевыми
(зарезервированными) словами языка.

В языке Visual Basic не различаются
строчные и прописные буквы.

Множество возможных значений переменной,
допустимые операции, которые к ней применимы, количество байтов, отведенных для
нее, определяется типом переменной. В каждом языке
программирования определена своя система типов переменных.

К константам относится все то, что
сказано выше о переменных. Но есть одно существенное отличие: константа не
может изменить значение при выполнении программы. Переменные и константы – это данные. Познакомимся с системой типов
данных Visual Basic.

5.1. Основные типы данных Visual
Basic

Табл. 5.1 Основные типы
данных Visual Basic.

* Под записью (Число1ЕЦелоеЧисло2) следует понимать Число1, умноженное на
10, возведенное в степень ЦелоеЧисло2.

Если, например, в программе
имеется переменная типа Integer с именем КоличествоСтудентов, то где-нибудь в программе
можно написать:

КоличествоСтудентов
= 1000

и для всех инструкций, которые появятся после этого,
переменная КоличествоСтудентов будет всегда равна числу 1000 – пока, возможно,
не появится инструкция

КоличествоСтудентов
= 1050

КоличествоСтудентов в этой инструкции является именем переменной, а 1000 в этом
примере – её значением.

Инструкцию КоличествоСтудентов = 1000
называют присвоением: переменная КоличествоСтудентов получает значение, равное
1000.

Эту инструкцию нельзя
понимать в том смысле, что левая часть равна правой части. Присвоение – это
действие, заключающееся в том, что значение правой части записывается в ячейку
памяти, отведенную для хранения значения переменной, имя которой указано слева
от знака равенства в инструкции присвоения. Будет ошибкой записать эту
инструкцию так: 1000 = КоличествоСтудентов

Слева от знака равенства
должна находиться переменная.

          Переменные
типов Byte, Integer, Long, Single, Double, Currency принимают числовые
значения.

          Если
в программе имеется переменная a типа Single, то такой переменной можно
присвоить числовое значение с дробной частью, например: a
= – 62.697

В этой инструкции
присваивания справа от знака равенства находится константа с плавающей точкой.
В Visual Basic для отделения целой части от дробной части применяется символ
(.). Возможен другой способ записи констант с плавающей точкой – с порядком.
Например,
1.5Е–16 означает 1.5*10^-16 (или иначе
0.00000000000000015).

К числовым переменным можно
применять арифметические операции сложения (+), вычитания (–), умножения (*),
деления (/), возведения в степень (^).

Значением переменной типа String может быть символ или
строка символов.

Значением переменной типа Date может быть, дата, время или
дата и время.

Переменная типа Boolean может принимать всего два
значения. Такая переменная может иметь значение True (истина) или значение False (ложь).

Тип Variant является универсальным.
Переменные типа Variant могут принимать числовые значения, значения
символов и строк символов, значение даты, времени и даты и времени. Остальные
типы данных пока комментировать не будем.

Если
UserName
является переменной типа String, тогда можно написать:
UserName = «Иван» (здесь очень важны
кавычки, так как иначе компьютер может принять Иван
за имя переменной). Этот пример показывает, что константа
типа String должна быть заключена
в двойные кавычки.

К строковым переменным и
константам можно применять операцию сцепления, которая обозначается символом
(&) или символом (+). Например, можно написать:

UserName = UserName & » Иванов«

После выполнения этой инструкции переменная UserName будет иметь значение «Иван
Иванов».

Если ДеньРождения
и EndOfTime
являются именами переменных типа Date,
тогда можно записать:

ДеньРождения = #29.10.1970#

EndOfTime = #8:30#

(как
символы выделяют кавычками, так дату или время выделяют символом (#)). Дату и
время можно поместить в одну переменную. Для переменной DateAndTime типа Date может быть записано:

DateAndTime = #13.2.2000 11:30#

5.2. Структура проекта

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

Каждая форма и каждый
модуль проекта имеют главную секцию (General), в которой может быть записан программный
код.

В главной секции могут быть объявлены
константы и переменные.

Наряду с главной секцией форма и модуль
могут включать секции, каждая из которых является объявлением процедуры или
функции.

5.3. Объявление переменных и констант

Если переменная применяется
в проекте, она должна быть объявлена. Существуют следующие уровни объявления
переменных и констант:

·       
Уровень процедуры
(функции). Имя, объявленное в процедуре, действует только внутри этой процедуры
и не действует вне этой процедуры.

·       
Уровень формы. Имя,
объявленное в главной секции формы, действует во всех процедурах этой формы, но
не действует в других формах и модулях.

·       
Уровень проекта.
Имя, объявленное в главной секции модуля с предваряющим словом Public (Общий), действует во всех формах и модулях проекта.

Надо иметь в виду, если при
объявлении переменной тип явно не указан, то будет назначен тип Variant. Такой способ объявления
называется объявлением по умолчанию.

          При
объявлении константы необходимо задать ее имя, тип, область действия и
значение.

Синтаксис объявления
константы:

[Public/Private] Const ИмяКонстанты [As Тип] = Значение

В подобных определениях
синтаксиса прямоугольные скобки [ ] означают, что конструкция, находящаяся
внутри этих скобок, не обязательна. Символ (/) означает, что должно быть
выбрано одно из слов, между которыми он поставлен. Сами же символы ([), (]),
(/) в текст объявления не включаются.

Приведенное определение
синтаксиса означает, что объявление константы начинается с обязательного слова Const (Константа). Перед Const может стоять одно из слов: Private (Локальный) или Public (Общий), задающих область
действия константы. Затем следует имя константы. После имени может стоять слово
As и наименование типа. Затем следует знак равенства и значение
константы.

В определении подчеркнуто
наименование той области действия, которая может быть задана по умолчанию.

В следующем примере в
главной секции модуля описывается глобальная константа Age целого типа, и ей присваивается значение 54.

Public Const
Age As Integer = 54

Допускается также описание
нескольких констант в одной строке. В этом случае, чтобы задать тип данных,
надо указать название типа для каждой константы.

В следующем примере
описываются локальные константы Ag и Wg как Single.

Const Ag As
Single = 3.14, Wg As Single = 2.78

Синтаксис объявления
переменной:

Static/Public/Private/Dim ИмяПеременной [As Тип]

Зарезервированное слово Dim (Размерность) при
объявлении переменных применяется чаще всего.

Статические переменные, описанные на
уровне процедуры со словом Static вместо слова Dim,
сохраняют свои значения даже после выхода из процедуры при повторном входе в
эту процедуру.

Вот пример объявления
переменной типа строки символов:

Dim strName As String

Если не указать тип
переменной, ей будет присвоен тип Variant. При этом следует учитывать,
что переменные типа Variant занимают больше места в памяти и обращение к
ним происходит медленнее.

В одной строке можно
объявить несколько переменных, но при этом следует для каждой указывать имя
типа:

Dim a As Integer, b As Integer, c As Long

Dim e As Integer, f, g

В первой строке объявлены
две переменные типа Integer и одна переменная типа Long. Во второй строке – одна
переменная  типа Integer, а две другие – типа Variant по умолчанию.

При объявлении переменная,
не получает значения, ей только отводится память, а ее значение не определено.

Можно вообще не объявлять
переменные. Однако такая практика является источником ошибок, и ее надо
избегать. Чтобы Visual Basic расценивал любую необъявленную переменную формы
или модуля как ошибочную, в главной секции формы или модуля первой должна
следововать инструкция Option
Explicit.
Эта инструкция налагает требование явного описания всех переменных этой формы
или модуля. Если модуль содержит инструкцию Option Explicit, при попытке использования
неописанного или неверно введенного имени переменной возникает ошибка во время
исполнения программы.

Можно так настроить среду
Visual Basic, что инструкция Option Explicit будет автоматически
помещаться системой Visual Basic в главной секции создаваемой формы или модуля.
Для этого надо выполнить команды меню Tools (Инструменты), затем Options
(Свойства), затем на вкладке Editor (Редактор) установить флажок
в окошке Require Variable Declaration (требовать
объявления переменных) и, наконец, щелкнуть на кнопке ОК. Но это следует
сделать до создания формы или модуля.

5.4. Преобразование и совместимость типов

В этом разделе речь будет
идти о тех ситуациях, когда при выполнении операции или инструкции участвуют
данные разных типов. Например, что произойдет, если переменной целого типа
присваивается числовое значение типа Single.

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

¨     При преобразовании числа с
плавающей точкой в целое происходит округление до ближайшего целого.

¨     При преобразовании целого
числа в число с плавающей точкой дробная часть принимается равной нулю.

¨     В случае преобразования
целого типа в другой целый тип возможна ситуация, когда целый тип с большим
диапазоном значений преобразуется в целый тип с меньшим диапазоном значений.
Если значение, присваиваемое «короткому» типу, выйдет за пределы диапазона его
допустимых значений, произойдет ошибка периода выполнения.

¨     Строковые и числовые типы
совместимы. Можно присвоить числовое значение строковой переменной и наоборот.

Например, не возникнет ошибки периода выполнения при присвоении свойству Caption,
которое имеет тип String, значения 125
переменной типа Integer. Произойдет преобразование целого числового
значения 125 в строку символов “125”.

И наоборот. При присвоении переменной целого типа значения свойства Text
некоторого текстового окна, которое имеет тип String
(пусть, например, в этом текстовом окне набрано три символа 125), произойдет преобразование строки символов “125” в целое число и целочисленная переменная получит значение 125. Однако строка символов должна быть такой, чтобы она могла трактоваться
как число.

Возможно также выполнение арифметической операции, например умножения
(*), когда один или оба операнды являются строкой символов, но при условии, что
их значения, можно интерпретировать как числа. При этом особую осторожность
следует соблюдать с операцией (+), которая в зависимости от контекста может
означать либо операцию сложения, либо операцию сцепления.

 В операции операнд1 + операнд2 символ (+) Visual Basic
будет воспринимать как:

—        
операцию сложения, если оба операнда имеют
какой-либо из числовых типов;

—        
операцию сложения, если один операнд имеет
числовой тип, а второй является строкой символов, значение которой может быть
интерпретировано как число;

—        
операцию сцепления, если один операнд имеет
числовой тип, а второй является строкой символов, значение которой не может
быть интерпретировано как число;

—        
операцию сцепления, если оба операнда имеют
строковый тип независимо от их значений.

Теперь можно приступить к разработке проекта.

5.5. Разработка проекта

1.     Создайте
в корневом каталоге диска d свою рабочую папку.

2.     Запустите Visual Basic. Ознакомьтесь с окном
проекта.

Если
появилось окно New Project, то выберите
Standart EXE (стандартный) 
вкладки New (новый) и щелкните на кнопке Открыть.

3.     Поместите
на открывшейся форме шесть текстовых окон, три надписи и три кнопки. Ваша форма
должна выглядеть так, как на рис. 5.1.

4.    
Щелкните дважды на форме Form1. В открывшемся
окне кода Project1 – Form1 (Code) раскройте список объектов и
выберите главную секцию (General).

5.    
Введите в
главной секции код, указанный далее.

Option
Explicit

‘Требование
явного объявления переменных

‘в пределах
формы Form1

Dim i As Integer

‘Объявлена
переменная i целого типа

Dim r As Single

‘Объявлена
переменная r с плавающей точкой

‘обычной точности

Dim st1 As String, st2 As String

‘Объявлены
переменные st1 и st2 строкового типа

На
примере этого фрагмента программного кода можно увидеть, как документируется
программа с помощью комментариев. Все, что находится в строке правее символа
(‘) рассматривается как комментарий, присутствующий в программном коде, но не
оказывающий влияния на результаты его выполнения.

6.    
Сохраните
проект в своей рабочей папке.

7.    
 Раскройте список
объектов и выберите объект Command1. В окне кода появилась заготовка процедуры Command1_Click.

8.    
Задайте
программный код:

Private Sub Command1_Click()

  i = Text1.Text

  r = Text2.Text

  Label1.Caption
= r + i

End Sub

9.    
Щелкните на
кнопке Start для запуска проекта. В появившемся окне приложения Form1
наберите в поле Text1 значение 2 (предварительно удалив строку Text1), наберите в поле Text2 значение –1,3 (предварительно удалив строку Text2). После этого щелкните на кнопке Command1.  Последнее событие приведет к выполнению
инструкций процедуры Command1_Click и надпись отобразит результат 2+(–1.3). На рис. 5.2 показан вид окна приложения Form1 после
указанных действий.

Обратите внимание, при вводе строки в окне Text2, которая
интерпретируется программой как число с плавающей точкой, для разделения целой
и дробной частей применена не точка, а запятая. Это связано с тем, что
настройкой операционной системы в качестве разделителя целой и дробной части
чаще всего установлена именно запятая. Вид разделителя можно изменить. Для
этого необходимо выполнить команды Настройка
и Панель управления меню
кнопки Пуск панели задач. Затем
следует выбрать Язык и стандарты
и на вкладке Числа  в окне Разделитель
дробной и целой частей числа установить нужный разделитель и щелкнуть
на кнопке ОК. Для защиты от недостаточно квалифицированных пользователей
команда Настройка в учебных компьютерных классах может быть исключена из меню
кнопки Пуск. Поэтому изменить
разделитель целой и дробной частей числа может оказаться проблематично.

Итак,
будем исходить из того, что при записи констант в программном коде следует
применять точку для разделения целой и дробной частей, а во входном потоке при
вводе значений переменных надо применять запятую.

Остановимся
подробнее на существенных, но на первый взгляд не заметных, особенностях
выполнения инструкций процедуры Command1_Click. При
выполнении этих трех инструкций четыре раза осуществляется преобразование типа.

Так при
выполнении инструкции присвоения i = Text1.Text тип String значения свойства Text текстового окна Text1
преобразуется в тип Integer переменной i.

При
выполнении инструкции присвоения r = Text2.Text тип String значения свойства Text текстового окна Text2
преобразуется в тип Single переменной r.

В
инструкции Label1.Caption = r
+ i при выполнении
арифметической операции сложения тип Integer операнда i преобразуется к типу Single операнда r, так как арифметическая операция может быть выполнена над однотипными
операндами, а тип с плавающей точкой старше целого типа.

Наконец,
результат сложения типа Single преобразуется к типу String значения свойства Caption надписи Label1.

10.           
Остановите
выполнение проекта, щелкнув на кнопке End панели инструментов, и
сохраните проект.

11.           
Щелкните два
раза на кнопке Command2. В окне кода появилась заготовка
процедуры Command2_Click.

12.           
Задайте
программный код:

Private Sub Command2_Click()

  st1 =
Text3.Text

  st2 =
Text4.Text

  Label2.Caption
= st1 + st2

End Sub

13.           
Щелкните на
кнопке Start для запуска проекта и в появившемся окне приложения Form1
наберите в текстовом окне Text3 строку Вас (предварительно удалив строку Text3), а также
наберите в текстовом окне Text4 строку илий (предварительно удалив строку Text4). После этого
щелкните на кнопке Command2. Последнее событие приведет к выполнению
инструкций процедуры Command1_Click и надпись отобразит результат Василий операции сцепления, как это показано на рис. 5.3.

Полученный
результат Вас не должен удивлять. В инструкции Label2.Caption = st1 + st2 символ операции (+) воспринимается как символ операции
сцепления, а не операции сложения, поскольку оба операнда st1 и st2 имеют строковый тип. А что произойдет, если
в текстовых окнах задать числа?

14.           
Удалите в
текстовом окне Text3 строку Вас и наберите 25, а также удалите в текстовом окне Text4 строку илий и наберите 15. После этого щелкните на кнопке Command2.
На рис. 5.4 показан результат.

Опять произошло сцепление операндов. Это следовало ожидать, поскольку оба
операнда (свойства Text) имеют строковый тип. Посмотрите, что произойдет, если один операнд
будет иметь строковый, а другой – числовой, например, целый тип.

15.           
Остановите
выполнение проекта, щелкнув на кнопке End панели инструментов, и
сохраните проект.

16.           
Щелкните два
раза на кнопке Command3. В окне кода появилась заготовка
процедуры Command3_Click.

17.           
Задайте
программный код:

Private Sub Command3_Click()

  st1 =
Text5.Text

  st2 =
Text6.Text

  Label3.Caption
= 25 + st1 + st2

End Sub

18.           
Щелкните на
кнопке Start для запуска проекта и в появившемся окне приложения Form1 наберите 2 в текстовом окне Text5
(предварительно удалив строку Text5), а также наберите 3 в текстовом окне Text6
(предварительно удалив строку Text6). После этого щелкните на кнопке Command3.
Последнее событие приведет к выполнению инструкций процедуры Command3_Click и надпись отобразит результат операции, что и показано
на рис. 5.5.

При выполнении вычисления значения выражения 25 + st1 + st2 первой выполняется операция 25 + st1. В этой операции  один операнд
(константа 25) имеет числовой тип, а другой (строка st1) имеет значение, которое может быть интерпретировано как число. Поэтому
здесь символ (+) воспринят как операция сложения. Результат операции сложения (27) тоже имеет числовой тип, поэтому символ (+) в следующей операции 27+3 также воспринят как операция сложения и, в конце концов, получен понятный
результат 30.

19.           
Остановите
выполнение проекта, щелкнув на кнопке End панели инструментов, и
сохраните проект.

20.           
Щелкните два
раза на кнопке Command3. В окне кода появился программный код
процедуры Command3_Click.

Измените порядок следования операндов в инструкции присвоения Label3.Caption = 25 + st1 + st2. Замените ее инструкцией Label3.Caption = st1 + st2 + 25.

21.           
Щелкните на
кнопке Start для запуска проекта и в появившемся окне приложения Form1 снова наберите 2 в текстовом окне Text5
(предварительно удалив строку Text5), а также наберите 3 в текстовом окне Text6 (предварительно удалив строку Text6). После этого щелкните на кнопке Command3. Надпись
отобразит на первый взгляд неожиданный результат вычислений (см. рис. 5.6).

Изменение порядка слагаемых привело к изменению значения
результатов вычислений! Почему? Дело в том, что первой теперь выполняется
операция st1 + st2, в которой символ (+) воспринимается как
операция сцепления, поскольку оба операнда имеют строковый тип.

 Результат
операции соответственно тоже имеет строковый тип и равен “23”.

При выполнении операции “23” + 25 символ (+) будет воспринят, как операция сложения, поскольку один
операнд (константа 25) имеет числовой тип, а другой операнд (“23”) может быть интерпретирован как число.

22.           
Остановите
выполнение проекта, щелкнув на кнопке End панели инструментов, и
сохраните проект.

23.           
Покажите
результат выполнения задания преподавателю.

24.           
Удалите свою
рабочую папку.

Подведем итоги.

          В
Visual Basic
предусмотрено несколько типов для переменных, принимающих числовые значения.
Какой тип применять в каждом конкретном случае? Для ответа на этот вопрос надо
учитывать следующее.

1.       
Тип Variant является универсальным. Его применение делает
программный код более компактным, так как этот тип можно не объявлять – он
предусматривается по умолчанию. Однако каждое данное этого типа занимает в
памяти больше места. А обращение к данным типа Variant происходит медленнее, чем к данным простых типов.

2.       
Арифметические
операции с данными целого типа (Integer, Long) выполняются быстрее, чем с данными с плавающей точкой (Single, Double).

3.       
Арифметические
операции с данными целого типа (Integer, Long) выполняются точно, а с данными с плавающей точкой (Single, Double) — приближенно.

В соответствии с этими соображениями не
рекомендуется применять тип Variant в тех случаях, когда проект должен
выполняться быстро, а также должен занимать мало места в памяти.

Целый тип рекомендуется применять, если
данное может принимать только целые значения (например, количество участников
или номер элемента некоторой последовательности).

Необходимо по возможности избегать
преобразования типа. Неправильная трактовка этого действия приводит к трудно
диагностируемым ошибкам.

5.6. Вопросы для контроля

1.    
Что
общего и чем различаются переменные и константы?

2.    
Что
определяет тип данного?

3.    
Когда
возникает необходимость преобразования типа данного?

4.    
Поясните
синтаксис объявления константы.

5.    
Поясните
синтаксис объявления переменной.

6.    
Как
определяется область действия данного?

7.    
Какова
структура проекта?

8.    
Каковы
результаты операций 2+3, 2+”3”, “2” + “3”?

9.    
Как
зависит от типа числовой переменной точность и скорость выполнения арифметической
операции?

В этом уроке рассмотрим:

1. Структуру программы на языке Паскаль
2. Примеры простейших программ
3. Работу с переменными. Примеры
4. Справочная информация по типам данных
5. Справочная информация по операторам ввода/вывода
6. Справочная информация выражениям и стандартным функциям

Разделы справочной информации внимательно читать не обязательно, к ним стоит обращаться по мере необходимости.

1 Структура программы на Паскаль

PROGRAM имя программы;
(английскими буквами, одно слово. Хотите глубже? То необходимо воспользоваться правилами написания идентификаторов)

USES подключаемые библиотеки (модули);
(дополнительные возможности, их можно подключать к программе в этой строке)

LABEL список меток;
(из одного места программы «прыгать» в другое)

CONST раздел описания констант;
(постоянные величины, их нельзя изменять)

TYPE описание типов переменных;

VAR определение глобальных переменных;
(описание всех переменных величин, которые в программе могут изменяться)

ОПРЕДЕЛЕНИЕ ПРОЦЕДУР;

ОПРЕДЕЛЕНИЕ ФУНКЦИЙ;

BEGIN

основной блок программы

END.

Разумеется, что не все приведенные выше блоки обязательны для использования. Сейчас приведем тот минимум, который необходимо использовать.

Program ex123; 
Begin 
End. 

Данная программа ни чего не делает, так как в ней нет ни одного оператора.

2 Пример программы на Pascal

Hello world на паскаль

Результатом данный программы будет вывод на экран строки «Hello, World!».

Program Hello_World;
Begin
	Write('Hello, World');
End.

Запустите Turbo Pascal и перепишите исходный код программы. Теперь запустите программу, это можно сделать зажав сочетание клавиш Ctrl+F9. Результат выполнения программы всегда можно посмотреть зажав сочетание клавиш Alt+F5.

Тут:

1. Program Hello_World; — это название вашей программы, зачастую его не используют.
2. Все что пишется до первого Begin — это раздел описания. Здесь программа просто сообщает компилятору сведения об используемых объектах и еще некоторую информацию.
3. Основной блок кода, так называемый раздел операторов, всегда начинается с Begin и заканчивается End. (обратите внимание: Begin всегда без точки, а последний закрывающий End. всегда с точкой).
4. Write('Hello, World'); — это первый исполняемый оператор в нашей программе, который сообщает компилятору о том, что необходимо напечатать строку "Hello, World!".

Стоит отметить, что язык Паскаль не чувствителен к регистру символов, т.е. write(), Write(), WRITE(), и даже WrItE() — все это для Паскаля означает одно и тоже.

Вычисление суммы двух чисел на Паскаль

Program Summa; { программа называется Summa }

Const
  A = 23;
  B = 76;

var
  S: integer;

begin
  S := A + B; { сумма чисел A и B }
  writeln('Сумма чисел 23 и 76 равна: S = ', S);
  readln { <-- Ожидание нажатия Enter, после 
   которого программа завершится }
end.

Предлагаю сразу запустить эту программу, а пояснения к ней можно найти ниже…

3 Константы и переменные. Примеры

Переменные в Pascal, служат для хранения некоторых величин. Переменные тождественны идентификаторам, т.е. для того, чтобы в программе объявить переменную необходимо назвать ее.

3.1 Константы

Те переменные, которые не изменяются, называются константами. Различают следующие типы констант:

• Числовые константы (целочисленные и вещественные). Пример:

  const
    N: integer = 12; //число N – целого типа
    S: integer = 5; //число S – целого типа
    pi: real = 3.14; //число «пи» - вещественного 
  

  После объявления каждой величины указывается её тип, а потом присваивается значение. Но предыдущая запись тоже верна, поскольку компилятор Паскаля настроен так, что он автоматически определяет тип постоянной. Но этого нельзя сказать о следующем типе чисел – переменных.

• Символьные константы. Единичный символ, записанный в апострофы:

  'А', 'В'
• Строковые константы. Некоторая произвольная последовательность символов, заключенная в апострофы:

  'Pascal programming language'

Рассмотрим программу «Hello world!» с использованием константы.

Program Hello_World_With_Const;
Uses Crt;

Const hello = 'Привет, ';

Var name:string;

Begin
	ClrScr;
	Write('Введите имя: ');
	Read(name);
	Write(hello, name, '!');
	ReadLn
End.

В данном случае мы объявили константу hello равную значению ‘Привет, ‘. Далее в программе достаточно в нужном месте подставить эту константу. Теперь если нам вдруг понадобиться вместо программы, которая здоровается, сделать программу, которая прощается, достаточно в начале программы поменять «Привет, » на «До свидания, » и программа будет прощаться с пользователем.

Если Вы обратили внимание, то в примере у константы не указан явно не указан тип, такие константы называются Обычными константами. Тип обычных констант определяется по их значению.

Помимо обычных констант существуют Типизированные константы. Тип таких констант объявляется явно:

Const
  Stroka :string = 'Привет';
  Number :Integer = 777;
  Pi :Real = 3.14159;

Дополнительно хочется обратить внимание на апострафы в константах. Если Вам в константе понадобится использовать апострофы, то просто продублируйте их:

Const
  stroka = 'I''m a programmer!';

3.2 Переменные в Pascal

Для хранения данных, полученных от пользователя, в программе вводятся переменные. К примеру для того, чтобы передать программе имя какого-то человека нам нужно в коде программы записать строчку:

Read(name);

Данная строка сообщает нашей программе о том, что нужно получить данные от пользователя и сохранить их в переменную name, которую мы указываем в скобках оператора Read(с англ.: читать).

Хочу обратить Ваше внимание на тот факт, что все идентификаторы(переменные, название программы) в коде Turbo Pascal могут состоять исключительно из символов латинского алфавита (A-Z, a-z), цифр (0-9) и символа нижнего подчеркивания («_»). Также идентификаторы не должны начинаться с цифр.

/* Примеры правильных имен переменных */
    variable
    Variable
    var1
    var_1234
    VARIABLE
/* Примеры не правильных имен переменных */
    -variable
    123Var
    Var-123	

Для целых чисел часто используются два основных типа: Integer и LongInt. Единственным отличием типов переменных, используемых для одного формата данных, — это Диапазон допустимых значений. К примеру для Integer диапазон допустимых значений [-32768, 32767], то есть минимальным значением для переменной типа Integer является число -32768, а максимальным — 32767.

Переменные перед использованием надо объявить в секции var, при этом указывается тип переменных. Например:

var
  N, m: integer;
  Q, r, t: real;

Секция описания переменных всегда стоит после описания констант (постоянных) – сначала идет конструкция const, а потом var.

Теперь попробуем объявить несколько переменных разного типа. Допустим мы хотим знать имя пользователя, его возраст и его рост. Для этого возьмем код программы их первого примера и изменить в соответствии с новыми требованиями.

Program Hello_World_With_Variable;
Uses Crt;

Var name :string;
    years, height :Integer;
Begin
    ClrScr;
    Write('Введите Ваше имя: ');
    ReadLn(name);
    Write('Сколько Вам лет? ')
    ReadLn(years);
    Write('Какой у Вас рост?(в см) ')
    ReadLn(height);
    Write('Привет, ', name, '! Я знаю что тебе ', years, ' лет', ' и твой рост составляет', height, ' см');
    ReadLn
End.

Хочу обратить ваше внимание на 5 строчку кода. Когда у нас есть несколько переменных одного типа, мы можем объявить их в одной строке, описав их через запятую и после последнего поставить знак двоеточия и написать требуемый тип.

4 Справочная информация по типам данных

Типы данных в Паскале определяют возможные значения переменных, констант, выражений и функций. Они бывают встроенными и пользовательскими. Встроенные типы изначально присутствуют в языке программирования, а пользовательские создаются программистом.

По способу представления и обработки типы данных бывают:

• простые
• структурированные
• указатели
• объекты
• процедуры

В этой статье будут рассмотрены лишь, наиболее простые типы данных, так как на начальных этапах обучения, вашей программе будет проще обойтись, например, без файлов и записей, чем без целочисленных или строковых переменных.

4.1 Целочисленный тип

Сюда входят несколько целочисленных типов, которые различаются диапазоном значений, количеством байт отведённых для их хранения и словом, с помощью которого объявляется тип.

Объявить целочисленную переменную можно в разделе Var, например:
Var book: word;

Над переменными этой категории можно выполнять все арифметические и логические операции за исключением деления (/), для него нужен вещественный тип. Также могут быть применены некоторые стандартные функции и процедуры.

4.2 Вещественный тип

В Паскале бывают следующие вещественные типы данных:

Над ними может быть выполнено большее количество операций и функций, чем над целыми. Например, эти функции возвращают вещественный результат:

• sin(x) – синус;
• cos(x) – косинус;
• arctan(x) – арктангенс;
• ln(x) – натуральный логарифм;
• sqrt(x) – квадратный корень;
• exp(x) – экспонента.

4.3 Логический тип

Переменная, имеющая логический тип данных может принимать всего два значения: true (истина) и false (ложь). Здесь истине соответствует значение 1, а ложь тождественная нулю. Объявить булеву переменную можно так:
Var A: Boolean;
Над данными этого типа могут выполняться операции сравнения и логические операции: not , and, or, xor.

4.4 Символьный тип

Символьный тип данных – это совокупность символов, используемых в том или ином компьютере. Переменная данного типа принимает значение одного из этих символов, занимает в памяти компьютера 1 байт. Слово Char определяет величину данного типа. Существует несколько способов записать символьную переменную (или константу):

1. как одиночный символ, заключенный в апострофы: ‘W’, ‘V’, ‘п’;
2. указав код символа, значение которого должно находиться в диапазоне от 0 до 255.
3. при помощи конструкции ^K, где K – код управляющего символа. Значение K должно быть на 64 больше кода соответствующего управляющего символа.

К величинам символьного типа данных применимы операции отношения и следующие функции:

• Succ(x) — возвращает следующий символ;
• Pred(x) — возвращает предыдущий символ;
• Ord(x) — возвращает значение кода символа;
• Chr(x) — возвращает значение символа по его коду;
• UpCase(x) — переводит литеры из интервала

4.5 Строковый тип

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

Var <имя_переменной>: string[<длина строки>];

Каждый символ в строке имеет свой индекс (номер). Индекс первого байта – 0, но в нем храниться не первый символ, а длина всей строки, из чего следует, что переменная этого типа будет занимать на 1 байт больше числа переменных в ней. Номер первого символа – 1, например, если мы имеем строку S=‘stroka’, то S[1]=s;. В одном из следующих уроков строковый тип данных будет рассмотрен подробнее.
Перечисляемый тип данных

Перечисляемый тип данных представляет собой некоторое ограниченное количество идентификаторов. Эти идентификаторы заключаются в круглые скобки, и отделяются друг от друга запятыми. Пример:

Type Day=(Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

Var A: Day;

Переменная A может принимать лишь значения определенные в разделе Type. Также можно объявить переменную перечисляемого типа в разделе Var:

Var A: (Monday, Tuesday);

К данному типу применимы операции отношения, при этом заранее определенно, что Monday<Tuesday<Wednesday т. д. Также можно применять функции succ, pred, ord, процедуры inc и dec, и использовать операцию присваивания: A:=Tuesday;

4.6 Интервальный тип данных

Когда необходимо задать какой то диапазон значений, то в таких ситуациях применяется интервальный тип данных. Для объявления используется конструкция m..n, где m – минимальное (начальное) значение, а n – максимально (конечное); здесь m и n являются константами, которые могут быть целого, символьного, перечисляемого или логического типа. Описываться величины интервального типа могут как в разделе типов, так и в разделе описания переменных.

Общий вид:

TYPE <имя_типа> = <мин. значение>..<макс. значение>;

Пример:

TYPE Cards = 1..36;

5 Pascal. Операторы ввода-вывода

5.1 Ввод данных

Процедура ввода данных с клавиатуры – Read (читать). Ее можно представить так:

Read(<Список ввода>);

В качестве списка ввода выступают имена переменных. Во время выполнения оператора ввода данных программа останавливается и ждет, пока они будут введены. Для завершения ввода необходимо нажать Enter. Если переменных несколько, то они могут вводиться через пробел, либо, введя одну переменную нужно нажать Enter, потом ввести вторую и т. д.

Для перевода каретки после выполнения оператора Read на новую строку, следует прибавить окончание ln:

Readln(<Список ввода>);

Также можно не указывать список ввода:

Readln;

Программа не перейдет к выполнению следующей части до тез пор, пока не выполниться пустой оператор.

5.2 Вывод данных

Для вывода данных в Паскале имеется оператор Write. Для того, чтобы каретка переводилась на следующую строку, к нему прибавляется окончание ln и получается Writeln. В общем виде эти операторы имеют вид:

Write(<Список вывода>);

Writeln(<Список вывода>);

Элементами списка вывода являются величины различных типов, в том числе выражения и строки, отделенные друг от друга запятыми, например:

Write(x, y);

Здесь x и y – параметры, заключенные в круглые скобки. Возможно использование оператора вывода и без параметров:

Writeln; {Курсор переведется на следующую строку}

Недостаточно просто вывести значение на экран, нужно также сделать это как можно корректнее. Допустим нам нужно в одном операторе Write вывести значения нескольких переменных (a=1, b=2, c=3). Пишем:

Write(a, b, c);

После выполнения, на экране действительно отобразятся значения данных переменных, но это понятно компьютеру, а пользователь увидит число 123. Необходимо придать вид выводимым данным, сделать это в Паскале можно двумя способами:

1) Вписать пробел вручную, например:

Write(a, ‘ ’, b, ‘ ’, c);

2) Воспользоваться возможностью форматированного вывода:

Write(a, b:2, c:2);

Двоеточие относиться к переменной, после которой оно следует, и говорит программе, что при выводе (переменной) нужно выделить место, заданное целым числом (в нашем случае это 2), т. е. под значения, хранящиеся в переменных b и c отводиться две клетки, сами они выведутся «прижатыми» к правому краю.

Процедура форматированного вывода может применяться и к другим типам данных, но особого внимания заслуживает вещественный тип. Как известно переменные вещественного типа имеют целую и дробную части, поэтому для них предусмотрена такая форма записи с использованием формата:

Write(32.1012:5:2);

Результат выполнения: 32.101

Формат 5 означает, что всего под число 32.1012 выделено 5 клеток, а 2 – из этих пяти под дробную часть отводиться 2 клетки.

6 Выражения с тандартные функции

6.1 Стандартные функции Pascal

В программировании, довольно часто приходиться выполнять однотипные действия, причем в задачах разного уровня и класса. И для ускорения процесса написания кода эти действия выносят в специальные подпрограммы – стандартные функции. Обращение к такой подпрограмме происходит по ее имени, а в скобках указывается значение аргумента. В следующей таблице указаны те стандартные функции, которые используются в языке программирования Pascal.

6.2 Выражения в Pascal

Выражение состоит из переменных, констант, полей в записях, указателей функций, круглых скобок и знаков операций. Для корректной записи выражений необходимо знать не только как обозначаются те или иные операции, функции и т. п., но также стоит предусмотреть приоритеты их выполнения, математические и логические правила, а также некоторые тонкости самого языка. Для более углубленного изучения выражений, стоит рассмотреть несколько примеров.

1) 12+3*3=21 (12+3)*3=45

Как видите выражения в Pascal, имеют такой же приоритет, как и в математике, а с помощью круглых скобок его можно изменить.

2) (a>1) and (a<=20)

Такое логическое выражение возвращает истину, лишь в том случае, когда истинны оба выражения, т. е. если a входит в диапазон от 1 до 20 включительно. Стоит обратить внимание на скобки, здесь они необходимы для изменения приоритета, так как у операторов сравнения он низший.

3) (a+3>0) and (a+3<15) or (b>1) and (b<10)

Условие вернет истину, тогда когда истинными будут два условия слева или справа от OR, а также если они оба будут истинными.

Логическая операция OR (или) суть дизъюнкция в логики и поэтому имеет следующую таблицу истинности:

Ложь имеет место только когда X и Y ложны (нули). В том случае, чтобы истина возвращалась только тогда, когда одно из условий верно следует применить оператор XOR (исключающее или):

(a+3>0) and (a+3<15) xor (b>1) and (b<10)

4) x^(a) = exp(a*ln(x))

В Pascal нет функции возведения числа в степень (кроме степени 2), поэтому существует два пути:

1 — умножать число само на себя, какое то количество раз;

2 — воспользоваться функциями экспоненты и натурального логарифма.

В этом примере использованы оба варианта, но если степень, в которую необходимо возвести число, достаточно велика, то предпочтение следует отдать второму способу.

Переменные и константы позволяют нам сохранить какие-либо данные в памяти, чтобы, при необходимости, быстро их получить для совершения каких-либо операции над ними.

Как это работает

Сначала мы придумываем какое-нибудь имя для переменной (или константы), например, x-color. Затем связываем её со значением, например, «orange» (или #FF6633 в шестнадцатеричной системе или (255, 102, 51) в RGB). При этом язык программирования записывает «orange» в оперативную память, а в переменную записывается адрес этого участка памяти. В итоге, если мы требуем распечатать значение переменной x-color, компьютер отыскивает эту переменную, смотрит по какому адресу нужно идти в память и забирает оттуда значение «orange» и выводит его.

Константы

Иногда возникает необходимость где-то записать некое неизменяемое значение, чтобы не запоминать его, а затем использовать по необходимости. Например, число π ≈  3.141592653589793. Запишем его в программе и выведем в консоль.

fn main() {
	const PI: f64 = 3.141592653589793;
	println!("Число Пи {}", PI);
}

Результат:
Число Пи 3.141592653589793

В данном примере константа PI имеет тип f64 и ей присваивается значение 3.141592653589793. 

Знак = это специальный оператор присваивания. Не называйте его словом “равно”, иначе потом будете путаться. Для проверки равенства используется двойной знак равно ==.

Общий синтаксис объявления констант:

const NAME_CONST:  type = value;

Имя константы пишется заглавными буквами  с разделением слов символом подчеркивания (SCREAMING_SNAKE_CASE).

Особенности констант

• Константы неизменяемы.
• Значение константы должно быть известно перед запуском программы.

Следующие 2 пункта просто запомните, суть поймете в следующих лекциях:

• Константы существуют в локальной и в глобальной области видимости.
• Константы незатеняемы.

Переменные

Основное отличие переменной от константы в том, что переменная может быть вычислена во время выполнения программы. Например, у нас есть потребность часто использовать в расчетах куб числа π. Для этого мы один раз его вычислим и начнем использовать в расчетах, экономя процессорное время.

fn main() {
	const PI: f64 = 3.141592653589793;
	let pi_cube: f64 = PI * PI * PI;
	println!("Число Пи в кубе{}", pi_cube);
}

Результат:
Число Пи в кубе 31.006276680299816

В данном примере переменная pi_cube, как и константа PI, имеет тип 64-битное число с плавающей запятой.

Общий синтаксис объявления переменных:

а) Объявляем переменную и присваиваем ей значение

let name_variable: type = value;

б) Только объявляем переменную, а значение присваиваем позже:

let name_variable: type;
name_variable = value;

в) Можно одновременно объявить сразу несколько переменных и присвоить им значения:

let (name_variable1, name_variable2): (type1, type2) = (value1, value2);

В некоторых случаях это может быть удобным. Также можно и не указывать типы данных, тогда компилятор определит их самостоятельно.

Имя переменной пишется строчными буквами с разделением символом подчеркивания (snake_case).

Итак, мы посмотрели на переменные, но чем же они отличаются от констант?

Особенности переменных

Переменные отличаются от констант:

• Значение переменной может быть установлено после начала исполнения программы.
• Переменные можно изменять.

Следующие 2 пункта просто запомните, суть поймете в следующих лекциях:

• Переменные существуют только в локальной области видимости.
• Переменные можно затенять.

Пример использования констант и переменных

Давайте напишем программу, которая будет вычислять и выводить в консоль длину окружности. Радиус зададим в переменной в самой программе. Результат округлим до сотых.

fn main() {
	const PI: f64 = 3.141592653589793;
	let radius: f64 = 90.0;
	let circumference: f64 = PI * 2.0 * radius;
	println!(
		"Длина окружности с радиусом {} равна {:.2}",
		radius, circumference
	);
}

Результат:
Длина окружности с радиусом 90 равна 565.49

Это очень простая задача. У нас есть константа числа π , есть радиус окружности и нам остается только вычислить и вывести длину окружности

Полагаю, вы уже обратили внимание на то, что для типа данных float64 необходимо и в самих числах указывать точку. Ноль после точки ставить не обязательно, так просто привычнее.

Для округления в данном случае использовалось форматирование при выводе (ранее давалась ссылка на документацию https://doc.rust-lang.org/std/fmt/).

Изменяемые переменные (Variable Mutable)

По умолчанию переменные неизменяемые. Это необходимо для того, чтобы компилятор, имея гарантии неизменяемости, мог создать более оптимальный машинный код.

В учебных материалах встречаются термины: иммутабельные (immutable – неизменяемые) и мутабельные (mutable – изменяемые) переменные.

Давайте усложним код предыдущей задачи, вычисляя длину окружности повторно, для окружности с другим радиусом. Для красоты отделим объявление переменных от присваивания им значений.

fn main() {
	const PI: f64 = 3.141592653589793;
	let mut radius: f64;
	let mut circumference: f64;
 
	radius = 90.0;
	circumference = PI * 2.0 * radius;
	println!("Длина окружности с радиусом {} равна {:.2}", radius, circumference);
 
	radius = 120.0;
	circumference = PI * 2.0 * radius;
	println!("Длина окружности с радиусом {} равна {:.2}", radius, circumference);
}

Результат:
Длина окружности с радиусом 90 равна 565.49
Длина окружности с радиусом 120 равна 753.98

В данном случае мы изменяли значения переменных потому, что сделали их изменяемыми. Попробуйте убрать слово mut и прочитайте сообщение об ошибке.

Затенение переменных

Давайте возьмем ту же задачу. Переменные сделаем неизменяемыми, но объявим их второй раз.

fn main() {
	const PI: f64 = 3.141592653589793;
	let radius: f64 = 90.0;
	let circumference: f64 = PI * 2.0 * radius;
	println!("Длина окружности с радиусом {} равна {:.2}", radius, circumference);

	let radius: f64 = 120.0;
	let circumference: f64 = PI * 2.0 * radius;
	println!("Длина окружности с радиусом {} равна {:.2}", radius, circumference);
}

Результат:
Длина окружности с радиусом 90 равна 565.49
Длина окружности с радиусом 120 равна 753.98

В данном случае мы вновь объявили переменные с тем же именем. При этом, были созданы новые переменные с такими же именами. Так как сделано в этом примере поступать не следует, но нам следует изучить все возможности языка Rust.

Возможность затенения необходима для написания независимого локального кода в котором мы случайно можем использовать ранее использованные наименования переменных. Дальнейшая глава прольет немного света на то, для чего создан такой механизм.

Область видимости переменных

Область видимости, это область действия переменных или, другими словами, область доступности переменных.

Локальная переменная – переменная, находящаяся внутри блока кода ограниченного фигурными скобками {}. Вне этого блока доступ к переменной невозможен, т.к. после закрывающей фигурной скобки } переменная освобождается, и память, в которой хранилось значение, тоже освобождается.

Глобальная переменная – это относительное понятие, переменная глобальна по отношению к рассматриваемой части кода, если она был объявлена ранее вне этого блока кода.

Лучше посмотреть на примере:

fn main() {
	let x = 5;
	println!("Изначально x равен {x}");
	{
		let x = x * 2;
		println!("Внутри скобок другой x равен {x}");
		let y = 9;
		println!("Внутри скобок y равен {y}");
	}
	println!("За скобками x снова равен: {x}");
	println!("За скобками y недоступен"); // println!("За скобками y равен {y}");
}

Результат:
Изначально x равен 5
Внутри скобок другой x равен 10
Внутри скобок y равен 9
За скобками x снова равен: 5
За скобками y недоступен

Сначала мы создали переменную x и связали её со значением 5 в оперативной памяти компьютера. Далее, внутри вложенных скобок мы создали вторую переменную x, которую связали с вычисленным значением 12. Вторая переменная х затенила первую х и поэтому распечаталось число 12. После выхода из скобок вторая переменная x уничтожается и нам становится доступна первоначальная x, которая равна 5.

Переменная y создана внутри скобок связана с числом 9. Поэтому за пределами скобок y стала недоступна, её память освободилась для дальнейшего использования. Вы можете это проверить раскомментировав примечание в котором производится попытка распечатать y.

Как правильно называть переменные

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

Есть определенные соображения, которыми можно руководствоваться при именовании переменных.

Не рекомендуется использовать транслитерацию русских слов английскими буквами. Лучше уж воспользоваться программой переводчиком.

Однобуквенно или сокращенно называют переменные, чтобы подчеркнуть, что код не имеет практического значения, а читателю следует обращать внимание на сам алгоритм. При этом, есть определенные сложившиеся практики (не являющиеся законом), например, для чисел используют n и m (или num от numeric), координаты называют x, y, z (как это принято в математике), строковые, как правило это s или str, для циклов i и j. Но это крайний случай, лучше даже в учебных примерах использовать осмысленные наименования переменных.

Раньше, когда компьютеры были большие, короткое именование переменных было обосновано малым количеством байт, отведенных для этой цели. Сейчас же вы ограничены только здравым смыслом. Поэтому придумывайте нормальные названия для переменных, чтобы имя соответствовало хранимым в нем данным.

Научится именовать переменные можно читая статьи и на практике. Анализируйте чужой код и создавайте свой. И не бойтесь переименовывать переменные, если вы придумали имя получше. В вашем редакторе кода для этого есть функции автозамены.

Для просмотра заданий и решений, а также публикации своих решений необходимо зарегистрироваться на
сайте.

Всё бесплатно, мы просто хотим с вами познакомиться и понять насколько актуально то, что мы делаем.

© Клют И. А., 2022. Копирование контента возможно только с письменного разрешения автора.

Переменные и константы

Содержание

• 1. Для чего в программе используются константы и переменные?
• 2. Каким образом в C# объявляется константа? Примеры объявление констант.
• 3. Как в программе объявляется переменная? Примеры объявления переменных.
• 4. Пример объявления переменной, которая есть структурой.
• 5. Пример объявления переменной которая есть перечислением.
• 6. Как осуществляется инициализация переменной? Примеры инициализации переменных.
• 7. Как в C# реализуется динамическая инициализация переменных?
• 8. Как в C# описываются неявно типизированные переменные?
• 9. Сколько неявно типизированных переменных можно описывать одновременно?
• 10. Пример описания неявно типизированной переменной, которая есть перечислением.
• 11. Что определяет область действия локальной переменной?
• Связанные темы

Поиск на других ресурсах:

1. Для чего в программе используются константы и переменные?

Константы и переменные есть основными объектами, которые используются в программе. Константы и переменные – это именованные объекты, для которых выделяется память.

Значение константы обязательно устанавливается при ее объявлении в программе.

В отличие от переменной значение константы не может изменяться программно. Если константа уже объявлена, то при попытке присвоить константе какое-нибудь новое значение компилятор выдаст сообщение об ошибке.

Все переменные и константы должны быть объявлены до их применения. Это нужно, чтобы сообщить компилятору о типе данных, который сохраняется в переменной. Если известен тип переменной, то компилятор осуществляет соответствующую компиляцию любого оператора, в котором используется данная переменная.

  ⇑

2. Каким образом в C# объявляется константа? Примеры объявление констант.

Константа объявляется с помощью оператора следующей формы:

const тип имя_константы = значение;

где

const – ключевое слово, которое определяет что именно это есть константа; тип – тип данных, которые сохраняются в константе; имя_константы – имя константы; значение – значение константы, которое есть неизменяемым в программе.

Примеры описания констант.

const decimal m = 333897987.3949M; // константа типа decimal
const double pi = 3.1415; // константа типа double
const bool YES = true; // константа типа bool
const int Max = 255; // константа типа int
const char AnswerYes = 'Y'; // константа типа char
const string Str = "Constant String"; // константа типа string

  ⇑

3. Как в программе объявляется переменная? Примеры объявления переменных.

Переменные объявляются с помощью оператора следующей формы:

тип имя_переменной;

где тип – это тип данных, которые сохраняются в переменной; а имя_переменной – это ее имя.

Объявить переменную можно любого типа, который существует в программе. Тип переменной может быть также типом-значением.

Пример объявления переменной, которая имеет значимый тип.

double d, f; // 2 переменные типа double
int i, j; // 2 переменные типа int
bool answer; // переменная типа bool
char c; // переменная типа char
string s; // переменная типа string

d = 2.939;
f = -29309.39;
i = 50;
j = -300;
c = '=';
s = "This is a text";
answer = false;

  ⇑

4. Пример объявления переменной, которая есть структурой.

В языке C# структура относится к типу-значению а не к типу-классу.

Пример описания переменной, которая есть структурой типа MyPoint. Структура MyPoint определяет координаты точки на плоскости.

...

struct MyPoint
{
  public int x;
  public int y;
};

...

MyPoint mpt; // описание переменной mpt типа MyPoint

// присвоение значений внутренним полям переменной mpt
mpt.x = 20;
mpt.y = -30;

...

  ⇑

5. Пример объявления переменной которая есть перечислением.

В следующем примере объявляется переменная типа Months, которая есть перечислением.

enum Months { January, February, Murch, April, May, Jun,
              July, August, September, October, November, December };
...
Months mn;
Months mn2;
mn = Months.January;
mn2 = mn + 1; // mn2 = Months.February
...

  ⇑

6. Как осуществляется инициализация переменной? Примеры инициализации переменных.

Инициализация позволяет задать начальное значение переменной при ее объявлении.

Общая форма инициализации переменной имеет следующий вид:

тип имя_переменной = значение;

где тип – это тип данных, которые сохраняются в переменной; имя_переменной – это ее имя; значение – это конкретное значение, которое задается при создании переменной.

Примеры инициализации переменных:

int i = -463; // установить начальное значение -463 для переменной i
double d = 2093.9903; // установить значение 2093.9903 для переменной d
float f = -10039.39f;
char c = '%';
short sh = -30;
bool b = true;

Можно осуществлять инициализацию переменных выборочно. Например:

long l1 = 20003909, l2, l3 = 48938938984; // инициализируются переменные l1 и l3
string s, s1 = "Hello ", s2 = "world!", s3 = s1 + s2; // s3 = "Hello world!"

  ⇑

7. Как в C# реализуется динамическая инициализация переменных?

При динамической инициализации переменной в качестве инициализаторов используются не константы (литералы) а выражения. Эти выражения на момент объявления переменной должны быть действительными.

const double pi = 3.1415926535;
double r = 2; // радиус
double s = pi * r * r; // s = 12.566370614
double h = 3, v = s * h; // v = 37.699111842 - объем цилиндра радиуса r = 2 и высоты h = 3

  ⇑

8. Как в C# описываются неявно типизированные переменные?

Начиная с версии C# 3.0 компилятор имеет возможность самостоятельно определять тип локальной переменной. Этот тип определяется на основе значения, которым переменная инициализируется. Значению соответствует некоторый литерал, что описывается согласно синтаксису языка C#.

Такая переменная называется неявно типизированной.

Для объявления неявно типизированной переменной используется ключевое слово var. В этом случае инициализация переменной есть обязательной.

Общий вид описания неявно типизированной переменной:

var имя_переменной = значение;

где

var – ключевое слово; имя_переменной – это имя переменной; значение – это конкретное значение, которое задается при создании переменной.

Примеры описания неявно типизированных переменных:

var pi = 3.1415; // pi - типа double
var r = 3.39948f; // r - типа float
var h = 4393489348934.03290889m; // h - типа decimal
var i = 23; // i - типа int
var j = 38L; // j - типа long
var k = 30920039092UL; // k - типа ulong
var c = '&'; // c - типа char
var s = "C# 4.0"; // s - типа string

// var z = 3.8, y = 9.5; - ошибка: одновременно можно описывать только одну типизированную переменную

  ⇑

9. Сколько неявно типизированных переменных можно описывать одновременно?

Одновременно можно описывать только одну типизированную переменную.

При следующем описании будет ошибка, так как описаны две переменные:

// ошибка!
var z = 3.8, y = 9.5;

  ⇑

10. Пример описания неявно типизированной переменной, которая есть перечислением.

Пример описания неявно типизированной переменной, которая есть перечислением типа DaysOfWeek.

...

enum DaysOfWeek
{
    Sunday, Monday, Tuesday, Wednesday,
    Thursday, Friday, Saturday
};

...

var dw = DaysOfWeek.Saturday; // dw - типа DaysOfWeek

  ⇑

11. Что определяет область действия локальной переменной?

Область действия локальной переменной определяется блоком кода. Блок кода начинается с фигурной открытой скобки ‘{‘ и заканчивается фигурной закрытой скобкой ‘}‘.

...

{
    // область действия локальной переменной

    ...

}

...

Область действия определяет видимость имен констант и переменных без дополнительного уточнения. Также область действия определяет время существования локальной переменной.

В C# область действия определяется классом или методом.

Области действия могут быть вложенными. Если создается кодовый блок, тогда создается и вложенная область действия. В этом случае внешняя область действия охватывает внутреннюю область действия. Это означает, что локальные переменные и константы, которые объявлены во внешней области действия, будут доступны во внутренней области действия:

...

{
    // внешний блок
    int i;
    double d;

    ...
    {
        // внутренний блок

        int z;

        ...

        i = 25;   // есть доступ к переменным i и d
        d = 2329.344;
        z = -209; // z есть доступна только во внутреннем блоке

        ...

    }

    // Ошибка! Переменная z здесь недоступна
    // z = 123;

}

...

  ⇑

Связанные темы

• Базовые типы данных языка C#
• Литералы
• Базовые операторы (арифметические, логические и т.д.)

  ⇑

Объявление (описание) переменных и констант

Переменная
объявляется
(описывается) с помощью ключевых слов
Private,
Public,
Static, Dim.
Чтобы явно указать тип переменной,
используется ключевое слово As.

Примеры
описания простых переменных:

    Private
X

    Public
i As Integer, r As Long, c As Date

    Static
Строка As String

    Dim
Y

    Dim
Z As Single ‘Явный
способ объявления переменной.
   
Самый простой и надёжный.

Примеры
описания индексированных переменных:

    Dim
Массив1() As Integer

    Dim
Массив2(12) As String

    Dim
Массив3(1 to 20) As Single

    Dim
Массив4(1 to 5, 1 to 7) As Byte

Примечание.
Подробности излагаются в параграфе
2.4.6.

Константа
объявляется
с помощью ключевого слова Const.

   
При этом можно указать её тип, область
действия и присвоить ей значение.
   
Синтаксис
объявления:

    Const
<имя
константы> As
<тип>
= <значение>
     или
   
Const
<имя
константы> = <значение>

Если
в константе явно не указан тип данных,
то VBA назначает ей тип, который соответствует
значению выражения.

Примеры:

      Private
Const q = 44,55
     
Public Const pi = 3,1459
     
Static Const QWER=2,54
     
Const y = 34
     
Const Con As Byte = 34

      Const z As Single = -3,8374E-22

      Все
строковые
константы
указываются
в
кавычках.

Примеры:

      Const
prv As String = “Язык
программирования
VBA”
     
Public Const prv= “Язык
программирования
VBA”

Переменные и константы

В
VBA,
как и в других языках программирования
высокого уровня, для хранения значений
используют переменные и константы.

Переменная
–
именованная область памяти, используемая
для хранения значения, которое можно
изменить при выполнении программы.

Переменные
подразделяются на простые и индексированные
(переменные с индексом). Индексированными
переменными являются элементы массивов.
Все подробности о массивах будут
рассмотрены в параграфе 2.4.6.

Константа
–
именованная область памяти, используемая
для хранения фиксированного значения,
которое невозможно изменить при
выполнении программы.

Имена
переменных и констант должны удовлетворять
следующим правилам:

—
первым символом всегда должна быть
буква;

—
в составе имени нельзя использовать
символы: !,
@, &, $, # , пробел;

—
в качестве имени нельзя использовать
ключевые
     (зарезервированные)
слова, входящие в конструкции
    
языка VBA;

—
длина имени не может быть более 255
символов;

—
имя нельзя повторять в пределах области
его видимости
     (действия).

2.2.1.Область действия переменных и констант

Область
действия переменных и констант
определяется с помощью ключевых слов:
Private,
Public и
Static.

Private
–
область действия в пределах конкретного
модуля. После завершения выполнения
модуля память, отведенная под эти
переменные, освобождается.

Public
–
область действия в пределах приложения.

Static
–
область действия в пределах конкретного
модуля и внешних процедур, используемых
в данном модуле. После завершения
выполнения модуля значения этих
переменных сохраняются и могут быть
использованы при повторном выполнении
модуля.

Переменные
и константы, в зависимости от области
действия, подразделяются на глобальные
и
локальные.

Если
переменная или константа описана внутри
процедуры, то она является локальной,
то есть она определена и может
использоваться только в пределах данной
процедуры.

Если
переменная или константа описана вне
процедуры, то она будет глобальной.
Такая переменная или константа может
быть использована в нескольких процедурах.

Типизированные
константы типа «массив»

    При
описании константы типа «массив»
компоненты каждой размерности массива
заключаются в отдельные скобки и
разделяются запятыми. Компоненты,
расположенные в самых внутренних скобках
соответствуют последней (самой правой)
размерности массива.

    Примеры
констант типа «массив»:

одномерный
числовой массив

const

DigVector
: array
[1..7] of
Real = (0.1, 3.25, 21.32, 55, 11.99, 78.1, 4.5);

двумерный
числовой массив

const

DigMatrix
: array
[1. .3,1..2] of
Integer = ( (1,2), (3,4), (5,6) );

    В
результате элементы матрицы DigMatrix
получат такие значение

DigMatrix[l,l]
= 1;

DigMatrix[1,2]
= 2;

DigMatrix[2,1]
= 3;

DigMatrix[2,2]
= 4;

DigMatrix[3,1]
= 5;

DigMatrix[3,2]
= 6;

трехмерный
числовой массив

const

Dig3D
: array
[1..4,1..3,1..2] of
Byte = ( ((1,2),(1,2),(1,2)),

((1,2),
(1,2), (1,2)),

((1,2),
(1,2), (1,2)),

((1,2),
(1,2), (1,2)) );

одномерный
массив символов

const

CharVect1
: array
[1..6] of
Char = (‘P’ ,’A’ , ‘S’ , ‘C, ‘A’, ‘L’) ;

или
более кратко

CharVect2
: array
[1..6] of
Char = ‘PASCAL’;

К
оглавлению

Типизированные
константы типа «множество»

    Синтаксис
описания констант типа «множество»
определяется следующими правилами.

    Каждый
элемент константы типа «множество»
может представлять собой либо отдельную
константу соответствующего типа, либо
интервал значений, состоящий из двух
констант, разделенных символом . . (две
точки).

    Примеры
констант типа «множество»:

type

Digits
= set
of
0..9;

CharDig
= set
of
‘0’..’9′;

const

DigSetl
: Digits = [0, 2, 4, 6, 8];

DigSet2
: Digits = [1..3, 5..7];

CharDigSet1
: CharDig = [ ‘0’ , ‘2’ , ‘4’ , ‘6’ , ‘8’ ] ;

CharDigSet2
: CharDig = [‘0’..’3′, ‘5’..’7′];

CharSet
: set
of
Char = [‘a’..’z’,’A’..’Z’];

Типизированные
константы типа «запись»

    В
описании константы типа «запись»
указываются как значения всех полей
записи, так и их идентификаторы. В
типизированных константах типа «запись»
не допускаются поля файлового типа. В
вариантных константах-записях допускается
указание только того варианта полей,
который соответствует установленной
предварительно константе поля-признака.
Поля указываются в том же порядке, в
котором они следуют в описании типа.

    Примеры
типизированных констант типа «запись».

type

Reс
= record

R
: Real;

В
: Boolean;

C
: Char;

end;

ArrayOfRec
= array
[1..3] of
Rec;

RecOfArray
= record

ArrInt
: array
[1..3] of
Integer;

ArrChar
: array
[1..2] of
Char;

end;

RecOfRec
= record

I
: Integer;

S
: String;

Z
: Rec;

end;

const

RecElem
: Rec = ( R: 3.1415; B: True; С
: ‘*’ ) ;

ArrRec
: ArrayOfRec =

(
( R: 3.1415; B: True; C : ‘*’ ),

(
R: 0.0; B: False; C : ‘$’ ),

(
R: 6.2832; B: True; C : ‘&’ ) );

RecArr
: RecOfArray =

(
Arrlnt: (1,2 ,3); ArrChar: (‘ 1’ , ‘ 2’) ) ;

RecRec
: RecOfRec =

(
I: 32767; S: ‘PASCAL’;

Z:
( R: 3.1415; В: True; С: ‘*’ ) ) ;

34

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #