Существует несколько способов передачи параметров в подпрограмму
Передача параметров по значению. Формальному параметру присваивается значение фактического параметра. В этом случае формальный параметр будет содержать копию значения, имеющегося в фактическом, и никакое воздействие, производимое внутри подпрограммы на формальные параметры, не отражается на параметрах фактических. Так, если в качестве фактического параметра будет использована переменная, и внутри подпрограммы значение соответствующего формального параметра будет изменено, то фактический параметр останется без изменений.
int func1(int x) { x=x+1; return x; }
Передача параметров по ссылке. В формальный параметр может быть помещён сам фактический параметр (обычно это реализуется путём помещения в формальный параметр ссылки на фактический). При этом любое изменение формального параметра в подпрограмме отразится на фактическом параметре — оба параметра во время вызова подпрограммы суть одно и то же. Параметры, передаваемые по ссылке, дают возможность не только передавать параметры внутрь подпрограммы, но и возвращать вычисленные значения в точку вызова. Для этого параметру внутри подпрограммы просто присваивается нужное значение, и после возврата из подпрограммы переменная, использованная в качестве фактического параметра, получает это значение.
void func2(int &x) { x=x+1; }
Передача параметров по имени. В формальный параметр может быть помещено произвольное выражение. При этом вычисление этого выражения произойдёт внутри подпрограммы в тот момент, когда потребуется его значение. Если это значение фигурирует несколько раз, то и вычисляться оно будет тоже несколько раз. Параметры, передаваемые по имени, дают возможность писать довольно универсальные подпрограммы. Такой способ передачи параметров используется, к примеру в языках Алгол или Алгол 68.
Передача параметров через стек. Это фактически разновидность передачи параметра по значению «с ручным приводом», в данном случае отсутствует понятие формальных и фактических параметров. Все параметры лежат на стеке, причём их типы, количество и порядок не контролируются компилятором. Данный подход реализован в языке Форт.
Язык программирования может предоставлять возможность передавать параметры в подпрограммы либо только по значению (так сделано в языке Си), либо по значению и по ссылке (это реализовано в Паскале, Аде, C++), либо по имени и значению (это реализовано в языках Алгол и Алгол 68). В последних двух случаях для различения способов передачи параметра используются отдельные синтаксическая конструкции (в Паскале это ключевое слово var при описании параметра). В действительности, если язык содержит понятие ссылки (указателя), то можно обойтись и без передачи параметра по ссылке (её всегда можно смоделировать, описав параметр типа «ссылка»), но эта возможность удобна, так как позволяет работать с формальным параметром-ссылкой без разыменования, а также повышает надёжность и безопасность программы.
На параметры, передаваемые по ссылке, накладываются естественные ограничения: фактический параметр, подставляемый на место такого параметра при вызове, обязан быть переменной (то есть иметь адрес), а в языках со строгой типизацией — ещё и иметь в точности такой же тип данных.
Виды подпрограмм
В языках программирования высокого уровня используется два типа подпрограмм: процедуры и функции.
Функция — это подпрограмма специального вида, которая, кроме получения параметров, выполнения действий и передачи результатов работы через параметры имеет ещё одну возможность — она может возвращать результат. Вызов функции является, с точки зрения языка программирования, выражением, он может использоваться в других выражениях или в качестве правой части присваивания. Подробнее см. в статье Функция (программирование).
Процедура — это независимая именованная часть программы, которую после однократного описания можно многократно вызвать по имени из последующих частей программы для выполнения определенных действия.
Подпрограммы, входящие в состав классов в объектных языках программирования, обычно называются методами. Этим термином называют любые подпрограммы-члены класса, как функции, так и процедуры; когда требуется уточнение, говорят о методах-процедурах или методах-функциях.
Билет 33
Тип String (строка) в Турбо Паскале широко используется для обработки текстов. Этот тип является стандартным и во многом похож на одномерный массив символов Array [0..N] of Char. Значение N соответствует количеству символов в строке и может меняться от 0 до 255. Символы, входящие в строку, занимают позиции с 1 до N. Начальный байт строки с индексом 0 содержит информацию о ее длине, т.е. это символ с кодом, равным длине строки.
Можно, также описывать переменные типа String[K], где K - целое число не больше 255. Так определяются строки с длиной не больше K. Этот тип уже не является стандартным. С символами строки можно работать как с элементами массива из символов, но в отличие от массивов, строки можно вводить целиком, сравнивать друг с другом и сцеплять операцией "+".
Сравнение строк выполняется посимвольно в соответствии с их кодами до первого несовпадения. Если одна из строк закончилась до первого несовпадения, то она считается меньшей. Пустая строка меньше любой строки. ПРИМЕР: Сравнение строк.
'abcd' > 'abcD' { 'd'>'D' }
'abcd' > 'abc' { 'd'>'' }
'abc' < 'axxc' { 'b'<'x' }
'abcd' = 'abcd'
Переменная строкового типа (String) может рассматриваться как массив элементов символьного типа (Char). Например, если в программе определены переменные S: string; C: char; и задано S:='Москва', то S[1]='М', S[2]='о' и т. д. и возможно присвоение, например: C:= S[1]; Таким образом строка может рассматриваться как линейный массив символов. Элементы массива, составляющие строку можно переставлять местами и получать новые слова, например:
for i:= 1 to N div 2 do
begin
C:= S[i];
S[i]:= S[N-i+1];
S[N-i+1]:= C
Writeln(S);
end; { исходное слово выведется справа налево: "авксоМ" }
Здесь N:= ord(S[0]); - число символов в переменной "S" хранится в переменной S[0]. Функция "ord" преобразует символьный тип в целый. N div 2 - количество перестановок для слова из "N" символов. В переменной "C" запоминается значение i-го элемента, который меняется с элементом, симметричным относительно середины строки.
Можно производить поиск и замену заданного символа в строке, например:
for i:=1 to N do if S[i]=' ' then writeln ('найден символ пробел');
for i:=1 to N do if S[i]='/' then S[i]:='\'; {замена символа "/" на "\"}
Заменяя или переставляя символы в строке по определенной схеме (закону) можно зашифровать строку. Для дешифровки используется, как правило, схема обратной перестановки или замены символов. Например:
for i:=1 to N do S[i]:= chr(ord(S[i])+2);
{преобразование исходных символов в символы с кодом большим на две единицы}
Напомним, что все используемые в MS-DOS символы имеют ASCII коды от 0 до 255. Здесь удобно также использовать функции Pred(C); и Succ(C);
Существует ряд стандартных функций и процедур для работы со строками.
• Функция Length(s) выдает длину строки s.
• Функция Concat(s1,s2,..,sn) возращает строку s1+s2+..+sn.
• Функция Copy(s,p,k) возвращает фрагмент строки s, который начинается в позиции p и имеет длину k.
• Функция Pos(s1,s) ищет первое вхождение подстроки s1 в строку s и возвращает номер первого символа s1 в строке s или 0 если не нашли.
• Процедура Delete(s,p,k) удаляет из строки s фрагмент, который начинается в позиции p и имеет длину k.
• Процедура Insert(s,s1,p) вставляет в строку s подстроку s1, начиная с заданной позиции p.
Турбо паскаль позволяет производить преобразования числовых значений в строковые и наоборот. Для этого используются процедуры Str(X:n:d,S) и Val(S,X,e). Первая получает их числа X строку S с изображением этого числа, в которой не менее n символов и из них d знаков после запятой. Параметры n и d необязательные. Вторая процедура получает из строки S число X. При успешном результате e=0.
ПРИМЕР: Работа со строками.
var s,x,y,z : string;
begin
x := 'turbo';
y := 'pascal';
z := x+' '+y; { z='turbo pascal' }
s := ''; { пустая строка }
for c:='a' to 'z' do s:=s+c; { s='abcd..xyz' }
writeln(s);
end.
Билет 35
Файл - это упорядоченная последовательность однотипных компонентов, расположенных на внешнем носителе. Файлы предназначены только для хранения информации, а обработка этой информации осуществляется программами. Использование файлов целесообразно в случае:
долговременного хранения данных ;
доступа различных программ к одним и тем же данным;
обработки больших массивов данных, которые невозможно целиком разместить в оперативной памяти компьютера.
В Паскале определены текстовые файлы, типизированные и нетипизированные. Файл, не содержащий ни одного элемента, называется пустым. Создается файл путем добавления новых записей в конец первоначально пустого файла. Длина файла, т.е. количество элементов, не задается при определении файла.
Все файлы должны быть описаны в программе либо в разделе переменных VAR, либо в разделе типов TYPE. Под чтением файла понимают ввод данных из внешнего файла, находящегося на диске, в оперативную память машины. Запись в файл - вывод результатов работы программы из оперативной памяти на диск в файл.
Работа с файлами выполняется следующими процедурами:
Assign – устанавливает связь между именем файла в программе (файловой переменной ) и физическим именем файла, принятым в ОС.
Reset - открывает существующий файл для чтения.
Rewrite – создает и открывает новый файл для записи на внеш нем устройстве (если файл ранее существовал, вся предыдущая информация из него стирается).
Close - закрывает открытый файл.
Для определения конца файла используется стандартная встро енная функция EOF (файловая переменная), которая принимает значение True, если достигнут конец файла, и значение False в противном случае.
Текстовые файлы
Текстовые файлы – файлы на диске, состоящие из символов ASCII. Для разделения строк используются символы «конец строки». Текстовые файлы являются файлами с последовательным доступом. В любой момент времени доступна только одна запись файла. Другие записи становятся доступными лишь в результате последовательного продвижения по файлу. Текстовые файлы внутренне разделены на строки, длины которых различны. Для разделения строк используется специальный маркер конца строки. Объявляются текстовые файлы переменной типа text. Обрабатывать их можно только последовательно и с помощью процедур и функций:
Readln (f , st )- чтение строки st из файла f и переход на начало следующей ;
Writeln (f, st )- запись строки st в файл f и маркера конца строки ;
Append (f ) - процедура, открывающая файл f для добавления строк в конец файла;
Eoln (st )- логическая функция, результат выполнения которой равен TRUE, если достигнут маркер конца строки st.
Пример 1. Создать текстовый файл, в который записать 3 предложения. Прочитать этот файл, вывести его содержимое на экран. Определить длину каждого предложения.
Program File_text;
var
f1 : text;
st : string;
n: byte;
begin
assign (f1, 'file1.txt'); {связать с файлом file1.txt файловую переменную f1 }
rewrite (f1); { создать новый файл с именем file1.txt }
writeln ( f1, 'Очень полезно изучать'); { записать предложения в файл}
writeln ( f1, ' всем студентам ');
writeln (f1, ' язык Pascal ');
close (f1); { закрыть файл для записи }
reset (f1); { открыть файл для чтения }
while not eof (f1) do { пока не конец файла f1}
begin
readln (f1, st); {читаем строку из файла f1 }
writeln(st); { выводим на экран }
n:= length (st); {определяем длину строки }
writeln (' длина =',n);
end;
close (f1); { закрыть файл для чтения}
end .
Типизированные файлы
Типизированные файлы – это файлы, состоящие из нумерованной последовательности объектов (записей) любого типа. С такими файлами можно работать в режиме прямого доступа, при котором выполняется непосредственное об ращение к любой записи файла. Каждая запись файла имеет свой номер, начиная с 0 и т.д.
Процедуры и функции обработки файлов:
1) Write и Read- записывают и читают информацию из указанного файла и перемещают указатель файла к сле дующей записи.
2) Seek (файловая переменная, номер записи); процедура перемещения указателя на запись файла с заданным номером.
3) Truncate (файловая переменная); процедура, усекающая файл по текущей позиции указа теля файла, т.е. все записи, находящиеся после указателя фай ла, удаляются.
4) Функция Filesize (файловая переменная); имеет тип Integer и определяет размер файла, т.е. число записей.
5) Функция Filepos (файловая переменная); имеет тип Integer и возвращает текущую позицию указателя файла.
Для добавления записей в конец файла используются процедуры:
Readln (a );
Seek (f, filesize (f));
Write (f, a);
При этом указатель устанавливается за конец файла, т.к. нуме рация записей начинается с нуля. После чего с помощью Write можно добавлять записи. Открывать файл можно только проце дурой Reset (f).
Для того, чтобы в режиме произвольного доступа считать, а затем изменить значение записи, следует выполнить два вы зова процедуры Seek.Один вызов перед операцией Read, а другой - перед операцией Write (т.к. Read после чтения записи переместит указатель к сле дующей записи).
Пример: Cоздать файл из списка 10 студентов с их оценками ( номер, Ф.И.О. и три оценки). Вывести его содержимое на экран, изменить фамилию студента с номером, введенным с клавиатуры, заново прочитать файл.
Program file;
Type
wed = record {Тип wed включает 3 поля: n, fio, bal}
n : byte ; fio : string[15] ;
bal : array [1..3] of byte; {Поле bal – массив из 3 оценок }
end;
Var spisok : wed ; {Запись spicok типа wed}
sp : file of wed; {Файл записей типа wed}
procedure vvod; { процедура создания файла}
var i,j:byte;
begin
{ оператор assing находится в основной прграмме }
rewrite ( sp); {открытие файла для записи}
with spisok do
For i:=1 to 10 do begin
n:=i;
writeln (' Введите фамилию - ', i ); readln (fio);
writeln (' Введите 3 оценки ', fio ); For j:= 1 to 3 do readln ( bal [j] );
write (sp , spisok); { запись в файл информации о студенте}
end;
close (sp); { закрытие файла для записи }
end;
procedure print; { процедура чтения и печати всего файла }
var j : byte;
begin
reset ( sp); {открытие файла для чтения}
writeln (‘ Список студентов: ‘);
while not eof (sp) do
with spisok do
begin
Read (sp, spisok); {чтение данных из файла}
write (n,' ',fio); {вывод записи на экран}
For j:= 1 to 3 do write (' ', bal [j] );
writeln ;
end;
readln;
close (sp) ;
end;
procedure work;
var num: integer;
begin
reset ( sp); {открытие файла для чтения}
writeln ('номер= '); readln (num);
seek (sp, num-1); {поиск записи с указанным номером (нумерация записей с 0)}
read (sp,spisok);{чтение и перемещение указателя к сле д. записи}
write ('fio='); writeln (spisok.fio);
seek (sp,filepos(sp)-1); {возвращение к изменяемой записи }
writeln (‘ Введите новую фамилию’ ); readln (spisok.fio);
write (sp, spisok); {запись в файл измененной записи}
close (sp);
end;
begin {начало основной программы}
assign (sp,'Vedom.DAT'); {связать файловую перем-ю sp с файлом Vedom.dat}
vvod; print; {процедуры создания и чтения файла}
work; print; {корректировка и чтение измененного файла}
readln
end.
Типы файлов Турбо Паскаль
Турбо Паскаль поддерживает три файловых типа:
текстовые файлы;
типизированные файлы;
нетипизированные файлы.
Доступ к файлу в программе происходит с помощью переменных файлового типа. Переменную файлового типа описывают одним из трех способов:
file of тип - типизированный файл (указан тип компоненты);
text - текстовый файл;
file - нетипизированный файл.
Примеры описания файловых переменных:
var
f1: file of char;
f2: file of integer;
f3: file;
t: text;
Билет36
Числовые типы данных Pascal-Паскаль
Наиболее распространенные в математике числовые типы – это целые числа, которые представляют бесконечное множество дискретных значений, и действительные числа, которые представляют неограниченный континуум значений.
Описание числовых типов данных (целые) Паскаля
В пределах одного языка могут быть реализованы различные подмножества множества целых чисел. Диапазон возможных значений целых числовых типов зависит от их внутреннего представления, которое может занимать один, два или четыре байта. Так, в Паскале 7.0 используются следующие целые числовые типы данных:
Числовые типы данных (ЦЕЛЫЕ ТИПЫ) Паскаля
С целыми числовыми типами данных Паскаля можно выполнять следующие операции:
Арифметические:
сложение(+);
вычитание(-);
умножение(*);
остаток от деления (mod);
целая часть от деления (div);
возведение в степень;
унарный плюс (+);
унарный минус (-).
Операции отношения:
отношение равенства (=);
отношение неравенства (<>);
отношение меньше (<);
отношение больше (>)
отношение не меньше (>=);
отношение не больше (<=).
При действиях с целыми числовыми типами данных тип результата будет соответствовать типу операндов, а если операнды относятся к различным целым типам, - типу того операнда, который имеет максимальную мощность (максимальный диапазон значений). Возможное переполнение результата никак не контролируется (это важно!), что может привести к ошибкам.
Особое внимание следует уделить операции деления целых числовых типов данных. В Паскале допускается две операции деления, которые соответственно обозначаются ‘/’ и div. Нужно знать, что результатом деления ‘/’ является не целое, а вещественное число (это справедливо, даже если вы делите 8 на 2, т.е. 8/2=4.0). Деление div – это целочисленное деление, т.е. тип результата целый.
Описание числовых типов данных (действительные) Паскаля
К вещественному числовому типу данных относится подмножество вещественных чисел, которые могут быть представлены в так называемом формате с плавающей запятой и фиксированным числом цифр. С плавающей точкой каждый числовой тип данных представляется в виде двух групп цифр. Первая группа цифр называется мантиссой, вторая – порядком. В общем виде числовой тип данных в форме с плавающей точкой может быть представлено так: X= {+|-}MP{+ | -} r, где M – мантисса числа; r – порядок числа (r – целое число); P – основание системы счисления. Например, для десятичного основания представление 2Е-1 (здесь Е – основание десятичной системы счисления) будет иметь вид: 2*10-1=0.2, а представление 1.234Е5 будет соответствовать: 1.234*105=123400.0.
В Паскале используются следующие типы вещественных чисел, которые определяют произвольное число лишь с некоторой конечной точностью, зависящей от внутреннего формата вещественного числа:
При описании вещественной переменной типа real в памяти компьютера будет создана переменная размерностью 4 байта. При этом 3 байта будут отданы под мантиссу, а один – под порядок.
Над действительными числовыми типами данных можно выполнять следующие операции:
Арифметические:
сложение (+);
вычитание(-);
умножение(*);
деление(/);
возведение в степень;
унарный плюс (+);
унарный минус (-).
Операции отношения:
отношение неравенства (<>);
отношение меньше (<);
отношение больше (>);
отношение не меньше (>=);
отношение не больше (<=).
Как видим, Паскаль характеризуется богатой гаммой вещественных типов, однако доступ к числовым типам данных single, double и extended возможен только при особых режимах компиляции. Эти числовые типы данных рассчитаны на аппаратную поддержку арифметики с плавающей точкой и для их эффективного использования в состав ПК должен входить математический сопроцессор.
Особое положение в Паскале занимает числовой тип данных comp, который трактуется как вещественное число без экспоненциальной и дробной частей. Фактически, comp – это «большое» целое число со знаком, сохраняющее 19..20 значащих десятичных цифр. В то же время числовой тип данных comp в выражениях полностью совместим с другими вещественными типами: над ним определены все вещественные операции, он может использоваться как аргумент математических функций и т.д.
О преобразовании числовых типов данных Паскаля
В Паскале почти невозможны неявные (автоматические) преобразования числовых типов данных. Исключение сделано только для типа integer, который разрешается использовать в выражениях типа real. Например, если переменные описаны следующим образом:
Пример
Var X : integer; Y: real;
то оператор
Пример
Y := X+2;
будет синтаксически правильным, хотя справа от знака присваивания стоит целочисленное выражение, а слева – вещественная переменная, компилятор сделает преобразование числовых типов данных автоматически. Обратное же преобразование автоматически типа real в тип integer в Паскале невозможно. Вспомним, какое количество байт выделяется под переменные типа integer и real: под целочисленный тип данных integer выделяется 2 байта памяти, а под real – 6 байта. Для преобразования real в integer имеются две встроенные функции: round(x) округляет вещественное x до ближайшего целого, trunc(x) усекает вещественное число путем отбрасывания дробной части.
В языке Паскаль определены следующие арифметические типы данных: целочисленные типы - Byte, ShortInt, Word, Integer и LongInt; вещественные типы - Single, Real, Double и Extended; и не совсем вещественный тип Comp. Характеристики этих типов приведены в таблице 1 (запись 1.5e-45 означает 1.5, умноженное на 10 в степени -45, это общепринятое в языках программирования обозначение для вещественных чисел - константа с плавающей точкой).
Таблица 1
Арифметические типы данных
Название типа Диапазон допустимых значений
Количество
верных цифр
Размер
в байтах
Byte 0...255 - 1
ShortInt -128...127 - 1
Word 0..65535 - 2
Integer -32768...32767 - 2
LongInt -2147483648...2147483647 - 4
Single 1.5e-45...3.4e+38 7-8 4
Real 2.9e-39...1.7e+38 11-12 6
Double 5.0e-324...1.7e+308 15-16 8
Extended 3.4e-4932...1.1e+4932 19-20 10
Comp -9.2e18...9.2e18 8 8
Типы Byte и Word используются для целых величин без знака, типы ShortInt, Integer и LongInt - для целых со знаком, типы Single, Real, Double и Extended - для вещественных величин. Тип Comp может содержать только целые числа от -2 63 +1 до +263-1, но эти числа хранятся в вещественном формате, поэтому тип Comp считается вещественным. С данными типа Comp можно обращаться так же, как с данными других вещественных типов, но дробная часть числа при этом автоматически отбрасывается.
Целые числовые константы записываются в языке Паскаль в десятичном виде или в 16-ричном виде, 16-ричная константа начинается с символа $ и содержит 16-ричные цифры : 0-9,A-F. Например, число 255 можно записать как $FF. Числовые константы по умолчанию имеют тип Integer или LongInt. Вещественные константы записываются либо с фиксированной точкой, например, -1.234, либо с плавающей точкой, например, -1.234E-5 или 555е12.
В программе, как правило, приходится использовать переменные арифметических типов. Каждая такая переменная (и переменная любого другого типа) в языке Паскаль должна быть обязательно описана, т.е. должен быть явно указан ее тип. Описание переменных в общем случае имеет вид:
VAR имя , ... , имя : тип ; имя , ... , имя : тип ; ...
Здесь имя - имена переменных (идентификаторы), тип - типы переменных, VAR - ключевое слово, означающее, что после него следуют описания переменных. Переменные одного типа можно описать совместно, разделив их имена запятыми, а можно описывать и каждую переменную отдельно. Точка с запятой означает окончание описания переменных данного типа. Слово VAR может повторяться в программе сколько угодно раз. Выбор типа для той или иной переменной определяется назначением этой переменной. Пусть, например, переменная i служит счетчиком (индексом) элементов некоторой последовательности, причем известно, что количество элементов не может превосходить 100. Мы можем описать переменную i любым целочисленным типом, но правильный выбор - Byte или ShortInt, любой другой тип будет избыточным. Всегда следует выбирать типы переменных осознанно; если вы не понимаете, какой тип должна иметь ваша переменная, вероятнее всего, эта переменная в программе не нужна. Для вещественных переменных чаще всего используется тип Real, являющийся основным вещественным типом в Паскале, поэтому мы везде будем писать Real для вещественных переменных, хотя это может быть и другой вещественный тип.
Пусть в программе нам необходимы переменные b1,b2,b3,b4 типа Byte, переменные i,j,k типа Integer и переменные r1,r2 типа Real. Их можно описать, например, так:
VAR b1,b2,b3,b4 : Byte;
i,j,k : Integer;
r1,r2 : Real;
или так :
VAR b1 : Byte;
i,j,k : Integer;
VAR r1 : Real;
VAR b2,b3,b4 : Byte;
r2 : Real;
Эти описания эквивалентны.
Всякая переменная обладает четырьмя атрибутами: именем, типом, адресом и значением. Имя переменной есть идентификатор, т.е. последовательность символов; тип переменной определяет ее свойства, диапазон допустимых значений и размер памяти, необходимый для размещения этой переменной; адрес переменной указывает на место в памяти, где размещается ее значение; переменная всегда имеет некоторое значение, даже если вы ничего не сделали, чтобы определить это значение. В последнем случае говорят, что переменная не определена; это значит, что ее значение не известно нам заранее (ни в коем случае не следует думать, что неопределенные переменные имеют нулевые значения - это не так).
Каким же образом определить значение переменной ? Для этого используется оператор присваивания:
имя:= выражение;
Здесь мы встречаемся с двумя новыми понятиями - оператор и выражение. Оператор - это минимальная осмысленная конструкция в языке Паскаль, вся программа - это последовательность операторов. Оператор всегда заканчивается символом ";", кроме одного единственного оператора END. Допускаются пустые операторы ";" , не выполняющие никаких действий. Выражение - это конструкция, состоящая из одного или нескольких операндов и, возможно, знаков операций, и имеющая некоторое значение. Операндами могут быть константы, переменные и другие выражения, т.е. вы можете строить сколь угодно сложные выражения. Мы не знаем пока никаких знаков операций, но предположим, что знак + означает операцию сложения (это так и есть). Запишем несколько выражений:
1 (константа есть частный случай выражения);
b1 (переменная есть частный случай выражения);
25+1E3
b1+4.25+r2
Теперь мы можем присвоить переменной ее значение:
i:=-11; j:=22+i; k:=i+j+177;
Наряду с переменными в Паскале есть и другие именованные объекты - это константы (отличайте их от числовых констант, которые не имеют имени, а лишь значение). Константы бывают двух видов - нетипизированные и типизированные. Нетипизированные константы описываются, так же, как и переменные в разделе описаний, в виде :
CONST имя=значение; имя=значение; ...
Здесь имя - идентификатор, значение - вообще говоря, некоторое выражение, которое может включать и именованные константы, описанные выше, но только не переменные. Запишем несколько примеров:
CONST C=-155;
D=C+100;
E=1E2+C+D;
CONST F=D+1;
CONST G=C+F;
Нетипизированные константы, описанные в разделе описаний, вы можете затем использовать в разделе операторов в выражениях, но изменить их значения невозможно. Не совсем удачное название "нетипизированные" означает не отсутствие у констант типа - любая константа имеет совершенно определенный тип, который определяется ее значением, - а лишь то обстоятельство, что при описании таких констант тип не указывается явно. В нашем примере константы C,D,F и G имеют тип Integer, а константа E - тип Real. Второй класс именованных констант - типизированные константы, описание которых имеет вид:
CONST имя:тип=значение; имя:тип=значение; ...
Эти константы вы можете использовать так же, как и нетипизированные, но можете и изменять их значения (например, с помощью оператора присваивания) подобно переменным. Типизированные константы можно, с небольшими оговорками, рассматривать как переменные, которым присвоено начальное значение. Приведем пример :
CONST t:Word = $FFFF; b:Byte = 11; r:Real = 1.23E-16; z:Integer = 0;
BEGIN t:=t-1; END.