Выбор действия (инструкция if)
Выбор действия (инструкция case)
Инициализация одномерного массива
Язык программирования
Среда разработки
Программа PascalNext представляет собой последовательность разделов:
Начало раздела объявления меток обозначается с ключевым словом label, раздела именованных констант - словом const, раздела типов – словом type, раздела глобальных переменных – словом var.
Раздел объявления функций и процедур не имеет особой метки (ключевого слова, обозначающего начало раздела). Он состоит из объявлений (текста) функций и процедур. Объявление функкции начинается ключевым словом function, объявление процедуры – словом procedure.
Радел объявления локальных переменных программы начинается ключевым словом var.
Раздел выполняемых инструкций начинается ключевым begin и заканчивается словом end, за которым находится точка.
В общем случае программа выглядит так:
program Имя()
label
// здесь объявления меток
const
// здесь объявления именованных констант
type
// здесь объявления типов пограммиста
var
// здесь объявления глобальных переменных
// здесть функции и процедуры
var
// здесь объявления локальных переменных
begin
// здесь выполняемые инструкции программы
end.
Программа Pascal Next представляет собой совокупность процедур и функций.
Главная процедура, с инструкций которой начинается выполнение программы, обозначается идентификатором program. Все остальные процедуры обозначаются идентификатором procedure, функции – идентификатором function.
Простейшая программа представляет собой одну единственную процедуру program и в общем случае выглядит так:
program имя()
var
// здесь объявления переменных
begin
// здесь выполняемые инструкции
end.
Пример:
// пересчет веса из фунтов в граммы
program p1()
var
fnt: float; // вес в фунтах
kg: float; // вес в килограммах
begin
write('Вес в фунтах >');
readln(fnt);
kg := fnt * 0.495; // 1 кг = 495 гр
writeln(fnt:6:2, ' фнт. = ', kg:6:3, 'кг');
writeln('Press <Enter>');
readln;
end.
Перед разделом var может быть раздел const (раздел именованных констант), в который программист может поместить объявления констант, используемых в программе.
// пересчет веса из фунтов в граммы (вариант 2)
program p1()
const
K = 0.495; // коэф. пересчета из фунтов в кг
var
fnt: float; // вес в фунтах
kg: float; // вес в килограммах
begin
write('Вес в фунтах >');
readln(fnt);
kg := fnt * K;
writeln(fnt:6:2, ' фнт. = ', kg:6:3, 'кг');
writeln('Press <Enter>');
readln;
end.
Программа Pascal Next может содержать как многострочные, так и однострочные комментарии.
Многострочный комментарий – текст, заключенный в фигурные скобки.
Однострочный комментарий – текст от следующих подряд двух символов "слеш" до конца строки.
Пример:
{ это многострочный
комментарий }
{ это тоже многострочный комментарий }
// это однострочный комментарий
integer – целые числа в диапазоне -2 147 483 648 ... 2 147 483 647
float - положительные и отрицательные числа в диапазоне от 1.5x10-38 до 3.4x1038
string – строка символов длинной до 128 символов
тип, объявленный программистом
Все переменные программы должны быть объявлены в разделе var той процедуры или функции, в которой они используются.
Инструкция объявления числовой переменной целого или вещественного типа в общем случае выглядит так:
имя: тип;
где:
имя – имя переменной;
тип – тип данных.
Примеры:
sum: float;
k: integer;
Допускается одной инструкцией объявить несколько переменных одинакового типа, например:
a,b,c: float;
Инструкция объявления строковой переменной в общем виде выглядит так:
имя: string[длина];
где:
длина – максимальное количество символов, которое может вместить переменная.
Максимальное допустимое значение параметра длина при объявлении строки – 128.
Пример:
name: string[25];
Допускается одной инструкцией объявить несколько переменных одинакового типа, например:
firstName, lastName: string[12];
При объявлении строковой переменной можно использовать целую именованную константу.
Например, если в разделе const объявлена целая именованная константа LN, то объявление переменных firstName и lastName может быть таким:
firstName, lastName: string[LN]; // LN – целая именованная константа
В качестве имени переменной можно использовать любую, начинающуюся с буквы и состоящую из букв и чисел последовательность символов. Помимо букв и чисел имя переменной может содержать символы ?подчеркивание?.
Пример:
amount: integer;
x1: float;
month_salary: float;
annual_income: float;
first_name: string[20];
Компилятор Pascal Next не различает прописные и строчные буквы, т.е. нечувствителен к регистру записи идентификаторов. Таким образом, например, идентификаторы first_name, FIRST_NAME и First_Name обозначают один и тот же объект (переменную).
В качестве имен переменных (и других объектов программы) нельзя использовать зарезервированные слова языка программирования, а также имена встроенных процедур и функций.
Числовые константы записываются обычным образом.
Примеры целых констант:
123
-45
0
Примеры вещественных констант:
5.0
27542.15
25.7
-34.05
0.0
Строковая константа представляет собой заключенную в одинарные кавычки последовательность любых символов.
Примеры строковых констант:
'Hello, World!'
'Bart Simpson'
'(C) Nikita Kultin, 2021'
' '
''
'100'
'99.5'
Помимо обычных символов, строка (строковая константа) может содержать специальную последовательность символов \n.
Пример:
'Hello,\nWorld!'
'1. Алюминий\n2. Сталь\n3. Медь'
Последовательность \n при выводе строки на экран трактуется как команда продолжить вывод символов, следующих за последовательностью \n, с начала следующей строки.
Например, три инструкции
writeln('Корни уравнения:')
writeln('x1=', x1:6:2);
writeln('x2=', x2:6:2);
можно заменить одной
writeln('Корни уравнения:\nx1=', x1:6:2, '\nx2=', x2:6:2);
Именованные константы должны быть объявлены в разделе const программы, процедуры или функции, в которой они используются.
Объявление именованной константы выглядит так:
Имя = Значение;
Пример:
const
Copyright ='(c) Nikita Kultin, 2021'; // строковая именованная константа
PI = 3.1415925; // вещественная именованная константа
HB = 7; // целая именованная константа
NL = 25; // целая именованная константа
После объявления именованная константа может использоваться в программе как обычная константа, в том числе в разделе объявления переменных.
Пример использования именованных констант при объявлении переменных:
matrix array[1..HB,1..HB] of float; // HB – именованная константа
students array[1..HB] of string[NL]; // HB, NL – именованные константы
name: string[NL]; // NL – именованная константа
Пример использования именованных констант в коде:
sq := PI*r*r; // PI – именованная константа
for i:=1 to HB do // HB – именованная константа
for j:=1 to HB do
matrix[i,j]:=0;
end;
end;
В Pascal Next нет логического (boolean) типа данных, однако, его легко можно смоделировать, определив в программе целые именованные константы TRUE (истина) и FALSE (ложь) со значениями 1 и 0 соответственно. После этого, вместо переменных логического типа можно использовать переменные целого типа, трактуя их как логические.
Пример:
program p()
const
// "логические" константы
TRUE = 1;
FALSE = 0;
HB = 10;
var
a:array[1..HB] of integer; // массив чисел
r: integer; // число, которое надо найти в массиве
found: integer; // признак, что число есть в массиве (найдено)
i: integer;
begin
for i:= 1 to HB do
a[i] := Random(HB);
end;
write('Number list: ');
for i:= 1 to HB-1 do
a[i] := Random(HB);
write(a[i]:3,',');
end;
write(a[HB]:3);
r:= Random(HB);
writeln('Search: ',r);
found := FALSE; // пусть число не найдено
i:= 1;
repeat
if a[i] = r then
found := TRUE; // число найдено
else
i:=i+1;
end;
until( found = TRUE) OR (i > HB);
writeln('i=',i);
if found = TRUE then
writeln('Found!');
else
writeln('Not found!');
end;
write('Press <Enter>');
readln;
end.
Вывод информации на экран (в окно консоли) выполняют инструкции write и writeln.
В общем виде инструкции вывода информации в окно консоли записываются так:
write(список_вывода);
writeln(список_вывода);
где:
список_вывода – разделенные запятыми имена переменных, строковые константы или выражения.
Примеры:
write(sum);
write('Press <Enter>');
writeln('x1=', x1, ' x2=', x2);
writeln(pound,' фунтов =', pound*0.453, ' кг.');
Помимо обычных символов, строка (строковая константа) может содержать специальную последовательность \n, которая при выводе строки на экран трактуется как команда продолжить вывод символов, следующих за последовательностью \n, с начала следующей строки.
Пример:
writeln('x1=', x1, '\nx2=', x2);
В строке вывода после имени переменной или выражения через двоеточие можно задать формат вывода значения.
Для целых и строковых значений формат задает ширину поля вывода - количество позиций на экране, которое резервируется для вывода значения переменной.
В общем виде форматированный вывод целых и строковых значений задается так:
имя:n
где:
имя – имя переменной , значение которой надо вывести на экран;
n – ширина поля вывода (целая константа).
Форматированный вывод вещественных значений в общем виде задается так:
имя:n:m
где:
имя – имя переменной;
n – ширина поля вывода (целая константа);
m - количество цифр дробной части.
Примеры:
writeln('x1=', x1:9:3, 'x2=', x2:9:3); // x1 и x2 – вещественного типа
writeln(name:15, salary:12:3); // переменная name строковая, salary - вещественная
writeln(pound:5:2,' фунтов =', pound*0.453:6:3, ' кг.'); // выражение pound*0.453 вещественного типа
Помимо обычных символов, строковая константа в инструкции вывода может содержать специальную последовательность \n, которая при выводе строки на экран трактуется как команда продолжить вывод символов, следующих за последовательностью \n, с начала следующей строки.
Пример:
writeln('x1=', x1:9:3, '\nx2=', x2:9:3);
Ввод данных с клавиатуры обеспечивает инструкция readln, которая в общем виде записывается так:
readln(имя);
где:
имя – имя переменной, значение которой надо получить от пользователя во время работы программы.
Примеры:
readln(name);
readln(salary);
ВНИМАНИЕ! При вводе вещественных значений в качестве десятичного разделителя следует использовать точку. Если при вводе вещественного значения вместо точки будет введена запятая, ошибка (исключение) не возникает, но дробная часть будет отброшена.
Инструкция присваивания выглядит так:
имя := выражение;
где:
имя – имя переменной или элемента массива;
выражение – выражение, значение которого присваивается переменной или элементу массива.
Выражение состоит из операндов и операторов. Операнды это – объекты, над которыми выполняется действие, операторы – символы, обозначающие действия.
В качестве операнда выражения могут использоваться константы, переменные, элементы массивов, функции.
Примеры:
n := 0;
k := k + 1;
a[i] := b[i];
densyty := mat[i].density;
n := Random(100);
s := s + c[j];
m := sum / k;
name := 'James Bond';
firstName := Substr(name,1,p);
Арифметические операторы:
| Оператор | Действие | Тип операндов | Тип выражения |
| + | сложение | integer, float | integer – если оба операнда integer; float – если один из операндов float |
| - | вычитание | integer, float | integer – если оба операнда integer; float – если один из операндов float |
| * | умножение | integer, float | integer – если оба операнда integer; float – если один из операндов float |
| / | деление | integer, float | float |
| DIV | целая часть частного | integer | integer |
| MOD | остаток от деления как целое | integer | integer |
Оператор + применим к операндам строкового типа. Результат применения оператора "сложение" к операндам строкового типа – конкатенация строк-операндов.
Значение выражения вычисляется слева направо, при этом следует учитывать, что операторы умножения и деления имеют более высокий приоритет, чем операторы сложения и вычитания.
Для задания нужной последовательности вычисления значения выражения следует использовать скобки.
Пример:
R = (R1 * R2)/(R1 + R2);
Выбор действия в зависимости от выполнения некоторого условия реализуется при помощи инструкции if.
Инструкция выбора одного из двух возможных вариантов действия записывается так:
if условие then
// здесь инструкции, которые должны быть выполнены,
// если условие выполняется (истинно)
else
// здесь инструкции, которые должны быть выполнены,
// если условие НЕ выполняется (ложно)
end;
Пример:
if t = 1 then
r := r1+r2;
else
r := r1*r2/(r1+r2);
end;
Если при выполнении условия надо выполнить некоторое действие, а в случае, если условие не выполняется, это действие надо пропустить и перейти к следующей инструкции программы, то инструкция if записывается так:
if условие then
// здесь инструкции, которые будут выполнены,
// если условие выполняется (истинно)
end;
Пример:
if a[i] < a[i+1] then
b:=a[i];
a[i]:=a[i+1];
a[i+1]:=b;
end;
Выбор действия в зависимости от значения переменной или выражения целого типа можно реализовать при помощи инструкции case.
Инструкция case в общем виде записывается так:
саsе селектор of
d_1 : do
// здесь инструкции, которые будут
// выполнены, если значение выражения селектор
// принадлежит диапазону d_1
end;
d_i : do
// здесь инструкции, которые будут
// выполнены, если значение выражения селектор
// принадлежит диапазону d_i
end;
else do
// здесь инструкции, которые будут
// выполнены, если значение выражения-селектора
// не принадлежит ни одному из указанных диапазонов
end;
end;
где:
селектор – переменная или выражение целого типа;
d_i – диапазон.
Диапазон задается так:
k1 .. k2
где
k1 и k2 – целые неотрицательные константы, удовлетворяющие условию k1 <= k2.
Если k1 = k2, то место диапазона можно указать целую константу.
Если между do и end, находящихся после else, нет ни одной инструкции, т.е. в случае, если значение селектора не принадлежит ни одному из указанных диавпазонов никаких действий выполнять не надо, инструкция case записывается так:
саsе селектор of
d_1 : do
// здесь инструкции, которые будут
// выполнены, если значение выражения селектор
// принадлежит диапазону d_1
end;
d_i : do
// здесь инструкции, которые будут
// выполнены, если значение выражения селектор
// принадлежит диапазону d_i
end;
end;
Примеры:
case month of
3..5: do
season := 'spring';
end;
6..8: do
season := 'summer';
end;
9..11: do
season := 'atumn';
end;
else : do
season := 'winter';
end;
end;
case n of
1: do
title :='Aluminium';
density := 2.71;
end;
2: do
title :='Cooper';
density := 8.94;
end;
3: do
title :='Steel';
density := 7.86;
end;
end;
Множественный выбор (выбор одного действия из нескольких возможных) можно реализовать при помощи вложенных инструкций if или инструкции case
Приведенные ниже инструкции показывают, как можно реализовать выбор одного действия из четырех возможных вариантов при помощи инструкций if.
if условие1 then
// здесь инструкции, которые будут выполнены,
// если условие1 истинно
else
if условие2 then
// здесь инструкции, которые будут выполнены,
// если уловие1 ложно, а условие2 истинно
else
if условие3 then
// здесь инструкции, которые будут выполнены,
// если условия условие1 и условие2 ложны, а условие3 истинно
else
// здесь инструкции, которые будут выполнены,
// если ни одно из условий условие1, условие2 или условие3
// НЕ выполняется
end;
end;
end;
Пример:
if ( n = 1) then
density := 2.7;
else
if ( n = 2) then
density := 7.6;
else
if ( n = 3) then
density := 8.7;
else
writeln('Неправильный номер материала');
end;
end;
end;
Условие это – выражение логического типа, которое может принимать одно из двух значений: Истина или Ложь.
Различают простое и сложное условия.
Простое условие в общем виде записывается так:
op1 оператор_сравнения op2
где:
op1 и op2 – сравниваемые операнды, в качестве которых могут выступать константы, переменные, функции или выражения.
Операторы сравнения:
| = | равно |
| > | больше |
| >= | больше или равно |
| < | меньше |
| <= | меньше или равно |
| != | не равно |
Примеры простых условий:
a[i+1] < a[i]
d != 0
pos(' ', st) = 1
name = 'simpson'
Сложное условие в общем виде записывается так:
усл1 логический_оператор усл2
где:
усл1 и усл2 – выражения логического типа, в качестве которых могут выступать простые или сложные условия.
Логические операторы:
| AND | логическое И |
| OR | логическое ИЛИ |
| NOT | логическое НЕ |
Примеры сложных условий:
x >= x1 AND x <= x2
NOT((x < x1) OR (x > x2))
sum >=1000 and sum <10000
name = 'Bart' OR name = 'Homer'
Инструкция цикла for в общем виде записывается так:
for сч := start to finish do
// инструкции, которые надо выполнить несколько раз
end;
где:
сч – счетчик циклов (переменная целого типа);
start и finish – выражения целого типа (в простейшем случае – целые константы), определяющие, соответственно, начальное и конечное значение счетчика циклов.
Примеры:
for i:=1 to 10 do
writeln(i:2, ' Hello, World!');
end;
for i:=1 to n do
writeln(i:2, ' Hello, World!');
end;
Инструкция цикла while (цикл с предусловием) в общем виде записывается так:
while условие do
// здесь инструкции, которые будут выполняться до тех пор,
// пока условие истинно
end;
где:
условие – простое или сложное условие выполнения инструкций, находящихся между словами do и end.
Пример:
i := 1;
while i <= 10 do
writeln(i:2, ' Hello, World!');
i := i + 1;
end;
Инструкция цикла repeat (цикл с постусловием) в общем виде записывается так:
repeat
// здесь инструкции, которые будут выполняться до тех пор,
// пока условие ложно
until условие;
где:
условие – простое или сложное условие завершения цикла (прекращения выполнения инструкций, находящихся между словами repeat и until).
Пример:
i := 1;
repeat
writeln(i:2, ' Hello, World!');
i := i + 1;
until i > 10;
Инструкция goto (безусловный переход) в общем виде записывается так:
goto метка
где:
метка – идентификатор инструкции, к которой необходимо выполнить переход.
Метка представляет собой любую начинающуюся буквой и состоящую из букв и цифр строку.
Метка записывается перед инструкцией, к которой надо выполнить переход, и отделяется от этой инструкции двоеточием.
Метка должна быть объявлена в разделе объявления меток в той процедуре или функции, в которой она используется. Начало раздела объявления меток помечает ключевое слово label.
Раздел объявления меток предшествует разделу объявления констант или, если раздел const отсутствует, разделу объявления переменных.
Пример:
// вычисление НОД - наибольшего общего делителя двух целых чисел
program p1()
label
m1,m2;
var
a,b: integer; // числа
n: integer; // НОД
begin
a:=12;
b:=18;
writeln('a=',a:2,' b=',b:2);
m1: if a = b then
n:=a;
goto m2;
end;
if a > b then
a:= a-b;
goto m1;
else
b:= b-a;
goto m1;
end;
m2: writeln('Наибольший общий делитель:', n);
write('Press <Enter>');
readln;
end.
Объявление одномерного массива в общем виде выглядит так:
имя: array[1..HB] of тип;
где:
имя – имя массива
HB – верхняя граница диапазона индекса массива (количество элементов массива)
тип – тип элементов массива (integer, float, string или тип-запись)
Внимание! Максимальное допустимое количество элементов одномерного массива 255
Примеры:
Salary: array[1..15] of float; // массив вещественных чисел
nPacients: array[1..31] of integer; // массив целых чисел
Students: array[1..25] of strings[15]; // массив строк
materials: array[1..10] of Material; // массив записей
Допускается одной инструкцией объявить несколько массивов одинакового типа и размера, например:
gold, silver, bronze: array[1 ..10] of integer; // три массива целых чисел
students_1, students_2: array[1 .. 30] of string[25]; // два массива строк
При объявлении одномерного массива в качестве верхней границы диапазона индекса можно использовать целую именованную константу.
Например, если в разделе const объявлены целые именованные константы HB и NL, то объявление массива students может быть таким:
Students: array[1..HB] of strings[NL]; // HB и NL – целые именованные константы
Именованные константы, использованные в инструкции объявления массива, удобно использовать в инструкциях его обработки.
Например:
for i:=1 to HB do
writeln(Students[i]);
end;
Если в программе объявлен тип-массив, то объявление одномерногомассива может выглядеть так:
имя: тип-массив;
где:
имя – имя массива;
тип-массив – объявленный в разделе type программы тип-массив.
Пример:
type
vector = array[1..10] of float; // vector – тип-массив
var
v1: vector; // v – переменная типа vector,
// т.е. одномерный вещественный массив
Внимание! При работе с большим количеством массивов или с массивами большой размерности следует учитывать, что суммарный размер данных (памяти, занимаемой переменными программы, в том числе и массивами) и кода программы не может превышать 64K.
Объявление двумерного массива в общем виде выглядит так:
имя: array[1..NR,1..NC] of тип;
где:
имя – имя массива;
NR – количество строк (row - строка) - верхняя граница диапазона индекса строки массива;
NC – количество столбцов (column - столбец) - верхняя граница диапазона индекса столбца массива;
тип – тип элементов массива (integer, float, string или тип-запись).
Внимание! Максимальное допустимое количество строк и количество столбцов двумерного массива 255.
Примеры объявления двумерных массивов:
// двумерный массив целых чисел (25 строк, 12 столбцов)
Salary: array[1..25,1..12] of integer;
// двумерный массив вещественных чисел (5 строк, 8 столбцов)
Matrix: array[1..5,1..8] of float;
// двумерный массив строк (100 строк, 2 столбца)
dictionary: array[1..100,1..2] of string[20];
Допускается одной инструкцией объявить несколько массивов одинакового типа и размера, например:
// два двумерных массива вещественных чисел
Matrix1, Matrix2: array[1..5,1..8] of float;
При объявлении двумерного массива в качестве верхних границ диапазонов индексов можно использовать целые именованные константы.
Например, если в разделе const объявлены целые именованные константы NR и NC, то объявление массива matrix может быть таким:
Matrix: array[1..NR,1..NC] of float;// NR и NC – целые именованные константы
Именованные константы, использованные в инструкции объявления массива, удобно использовать в инструкциях его обработки.
Например:
for i:=1 to NR do
for j:=1 to NC do
matrix[i,j]:=0;
end;
end;
Если в программе объявлен тип-массив, то объявление двумерного массива может выглядеть так:
имя: тип-массив;
где:
имя – имя массива;
тип-массив – объявленный в разделе type программы тип-массив.
Пример:
type
matrix = array[1..3, 1..5] of float; // matrix – тип-массив
var
m1: vector; // m1 – переменная типа matrix,
// т.е. двумерный вещественный массив
Внимание! При работе с большим количеством массивов или с массивами большой размерности следует учитывать, что суммарный размер данных (памяти, занимаемой переменными программы, в том числе и массивами) и кода программы не может превышать 64K.
В начале работы программы элементы числовых массивов имеют нулевое значение, элементы строковых массивов - значение "пустая строка".
Если программе нужен массив, значение элементов которого отличаются от значений "по умолчанию", необходимо выполнить инициализацию массива.
Инициализация массива это – присваивание требуемых значений всем элементам массива.
Инициализацию массива можно выполнить, указав в инструкции объявления массива список инициализации.
Инструкция объявления и инициализации одномерного массива выглядит так:
name: array[1 .. N] of type = list;
где:
name – имя массива;
N – количество элементов массива (целая или целая именованная константа );
type – тип массива (integer, float или string);
list – список констант. Тип констант должен соответствовать типу массива, а их количество – размеру массива.
Примеры:
material: array[1..4] of string[10] = 'Aluminum','Cooper','Gold','Steel';
density: array[1..4] of float = 2.71, 8.94, 19.32, 7.86;
При инициализации float массива в списке инициализации допускается использовать целые константы.
При инициализации символьного массива, в случае если дина строковой константы в списке больше длины строки, указанной в инструкции объявления массива, соответствующий элемент массива будет инициализирован "обрезанной" строкой.
Например, если инструкция объявления массива выглядит так
material: array[1..4] of string[6] = 'Aluminum','Cooper','Gold','Steel';
то элемент material[1] будет инициализирован значением 'Alumin'.
Инструкция объявления и инициализации двумерного массива выглядит так:
name: array[1..NR, 1..NC] of type = list;
где:
name – имя массива;
NR и NC – количество строк и столбцов массива (целые или целые именованные константы);
type – тип массива (integer, float или string);
list – список констант. Тип констант должен соответствовать типу массива, а их количество – количеству элементов массива. В списке инициализации сначала указывают значения для первой строки массива, затем для второй и так далее.
Примеры:
frasi: array[1..4, 1..3] of string[12] =
'buongirno','ciao','grazie',
'good day','good by','thank you',
'добрый день','до встречи','спасибо',
'Buenos dias','adios', 'gracias';
matrix: array[1..3, 1..4] of float = 1.5, 2.5, 3.0, 0.0,
3.7, 2.0, 6.2, 1.7,
0.0, 0.0, 0.0, 0.0;
При инициализации float массива в списке инициализации допускается использовать целые константы.
При инициализации символьного массива, в случае если дина строковой константы больше длины строки, указанной в инструкции объявления массива, то соответствующий элемент массива будет инициализирован "обрезанной" строкой.
Масив, объявленного программистом типа, можно использовать в качестве параметра функции или процедуры.
Массив передается в функцию (процедуру) по ссылке. Это значит, что функция (процедура) может изменить значения элементов массива.
Объявление функции (процедуры) выглядит обычным образом.
Объявление параметра-массива в объявлении функции (процедуры) выглядит так:
var имя: тип
где:
var – ключевое слово, показывающее, что парамерт передается в функцию (процедуру) по ссылке;
имя – имя массива;
тип – тип-массив, объявленный программистом.
Пример:
Program p1()
const
N=5;
type
TVector = array[1..N] of integer;
// ввод массива с клавиатуры
procedure GetVector(var v: TVector, k: integer)
var
i: integer;
begin
for i:=1 to k do
write(i:2,'>');
readln(v[i]);
end;
end;
// возвращает сумму элементов массива
function SumVector(var v: TVector, k: integer): integer
var
i: integer;
sum: integer;
begin
sum:= 0;
for i:=1 to k do
sum :=sum + v[i];
end;
return sum;
end;
var
v : TVector;
sum: integer;
i: integer;
begin
GetVector(v, N); // ввод массива
write('Массив: ');
for i:=1 to N-1 do
write(v[i]:3, ',');
end;
writeln(v[N]:3);
sum := SumVector(v, N);
writeln('Сумма элементов массива: ', sum:5);
writeln('Press <Enter>');
readln;
end.
Объявление функции программиста выглядит так:
function Имя (параметры): тип
var
// здесь объявления локальных переменных
begin
// здесь инструкции функции
return значение;
end;
где:
Имя – имя функции;
параметры – объявление параметров функции;
тип – тип значения функции;
значение – значение функции.
Объявление каждого параметра функции выглядит так:
имя_параметра: тип
Пример функции:
// Функция CylinderVolume вычисляет объем цилиндра.
Function CylinderVolume(d: integer, len: integer):float
const
PI = 3.1415926;
var
volume: float;
begin
volume := PI*(d/2)*(d/2)*len;
return volume;
end;
Параметры, которые указываются в инструкции вызова функции, называются фактическими. Параметры передаются в функцию по значению. В качестве фактического параметра может использоваться выражение, тип которого соответствует типу формального параметра. В простейшем случае, в качестве фактического параметра может использоваться константа или переменная. Если формальный параметр функции вещественного типа, то в качестве фактического параметра можно использовать выражение как вещественного, так и целого типа.
// примеры вызова функции
v := CylinderVolume(diam, len); // параметры - переменные
v := CylinderVolume(20, 1000); // параметры - константы
v := CylinderVolume(d – 2*w, len); // параметры – выражение и переменная
Чтобы функция стала доступна другой функции или процедуре, в том числе главной процедуре программы (program), ее объявление (текст) надо поместить в текст программы перед той процедурой или функцией, которая ее использует.
Пример:
// Вычисление объема полого цилиндра
// Функция CylinderVolume вычисляет объем цилиндра.
Function CylinderVolume(d: integer, len: integer):float
const
PI = 3.1415926;
var
volume: float;
begin
volume := PI*(d/2)*(d/2)*len;
return volume;
end;
// программа, использующая функцию CylinderVolume
Program P1()
var
diam: integer; // диаметр
wal: integer; // толщина стенки
len: integer; // длина
volume: float; // объем
begin
writeln('Объем полого цилиндра');
write('Диаметр, мм >');
readln(diam);
write('Толщина стенки, >');
readln(wal);
write('Длина, мм >');
readln(len);
// объем в мм куб.
volume := CylinderVolume(diam,len) - CylinderVolume(diam-2*wal,len);
// объем в см куб.
volume := volume / 1000;
writeln('Объем полого цилиндра', volume:9:2, ' см.куб.');
write('Press <Enter>');
readln;
end.
Объявление процедуры программиста выглядит так:
procedure Имя(параметры)
var
// здесь объявления локальных переменных
begin
// здесь инструкции процедуры
end;
где:
Имя – имя процедуры;
параметры – объявление параметров процедуры.
Объявление каждого параметра выглядит так:
имя_параметра: тип
Пример:
// процедура Line выводит в окно консоли n раз строку st
procedure Line(n:integer, st: string)
var
i: integer;
begin
for i:=1 to n do
write(st);
end;
writeln;
end;
// примеры вызова процедуры
Line(k,'-');
Line(25, ch);
Параметры, которые указываются в инструкции вызова процедуры, называются фактическими. Параметры передаются процедуру по значению. В качестве фактического параметра может использоваться выражение, тип которого соответствует типу формального параметра. В простейшем случае, в качестве фактического параметра может использоваться константа или переменная. Если формальный параметр функции вещественного типа, то в качестве фактического параметра можно использовать выражение как вещественного, так и целого типа.
Чтобы процедура стала доступна другой функции или процедуре, в том числе главной процедуре программы (program), ее объявление (текст) надо поместить в текст программы перед той процедурой или функцией, которая ее использует.
Pascal Next поддерживает рекурсивные функции.
Пример рекурсивной функции и ее использования:
// функция Factorial вычисляет факториал числа n
function Factorial(n: integer): integer
var
f: integer;
begin
if n = 1 then
f:=1;
else
f:= n*Factorial(n-1);
end;
return f;
end;
// значения факториала чисел от 1 до 12
program p28()
var
i: integer;
begin
for i:=1 to 12 do
writeln(i:2, ' - ', Factorial(i));
end;
write('Press <Enter>');
readln;
end.
Глобальными или общими называют переменные и структуры данных (массивы), которые объявлены вне процедуры или функции, но к которым у процедуры или функции есть доступ.
Глобальные переменные обычно используют для обеспечения доступа процедурам и функциям к общим данным.
Для того чтобы процедура или функция получила доступ к переменным программы, ее объявление надо поместить в объявление программы, после раздела объявления переменных.
Внимание! Вкладывать процедуры и функции можно только в программу (в процедуру program). Внутрь процедуры или функции поместить другую процедуру или функцию нельзя.
Пример:
program p29()
const
HB = 10;
var
// здесь глобальные переменные
c: array[1..HB] of integer;
function SumArr(m: integer, n: integer): integer
var
i: integer;
sum: integer;
begin
sum:=0;
for i:= m to n do
sum := sum + c[i]; // массив с - глобальный
end;
return sum;
end;
// инициализация массива случайными числами
procedure InitArr()
var
i: integer;
begin
for i:=1 to HB do
c[i]:= Random(10);
end;
end;
// основная программа
var
// к этим переменным у функции Sum и
// процедуры Init доступа нет
sum: integer;
i: integer;
begin
InitArr(); // инициализация массива
sum := SumArr(1,HB); // вычислить сумму элементов массива
for i:=1 to HB-1 do
write(c[i]:3,','); // массив с - глобальный
end;
writeln(c[i]:3);
writeln('\nSum=',sum);
write('\nPress <Enter>');
readln;
end.
При чтении данных из файла для преобразования строки в целое или вещественное значение следует использовать соответственно функции StrToInt и StrToFloat.
При записи данных в текстовый файл для преобразования численного значения в строку следует использовать функции IntToStr или FloatToStr.
Доступ к текстовому файлу обеспечивает объект типа Text.
Функции работы с файлами
| Функция | Описание | Пример |
reset(имя_файла) |
Открывает текстовый файл для чтения. Возвращает дескриптор файла (дескриптор) или -1, если имя файла задано неправильно (в указанной папке файла нет, неправильно указано имя файла). | DataFile:='C:\Temp\dat.txt'; f:=reset(DataFile); |
readstring(дескриптор) |
Читает строку из текстового файла. Для преобразования строки в число следует использовать функции StrToInt или StrToFloat | name:=readstring(f); |
eof(дескриптор) |
Конец файла. Возвращает -1, если достигнут конец файла | while eof(f) != -1 do // здесь инструкции чтения // и обработки данных end; |
rewrite(имя_файла) |
Открывает текстовый файл для перезаписи. Возвращает дескриптор файла (если файла нет, то он будет создан). | DataFile:='C:\Temp\dat.txt'; f:=rewrite(DataFile); |
append(имя_файла) |
Открывает текстовый файл для добавления. Возвращает дескриптор файла или -1, если указанного файла нет. | DataFile:='C:\Temp\dat.txt'; f:=append(DataFile); |
writestring(дискрипто, строка); |
Записывает в текстовый файл строку символов. Для преобразования численного значения в строку следует использовать функцию IntToStr или FloatToStr | n:=100; k:=32.5; writestring(f,IntToStr(n)); writestring(f,FloatToStr(k)); writestring(f, name); |
close(дескриптор) |
Закрывает открытый файл | close(f); |
Имя файла может быть полным (включать путь к файлу) или коротким. Короткое имя файла предполагает, что файл данных находится в том же каталоге, в котором находится выполняемый (exe) файл программы.
При запуске программы из среды разработки необходимо указывать полное имя файла.
Путь к файлу, находящемуся в папке Документы следует записывать так:
c:\users\user_name\documents
где user_name – имя пользователя, в системе.
Например, если имя пользователя nikita, то полное имя файла data.txt, находящегося в папке Документы, выглядит так:
c:\users\nikita\documents\data.txt
Если файл находится на рабочем столе, то его имя следует записывать так:
c:\users\user_name\desktop\fille
где user_name – имя пользователя, в системе.
Например, если имя пользователя nikita, то полное имя файла data.txt, находящегося на рабочем столе, выглядит так:
c:\users\nikita\desktop\data.txt
Программист может объявить свой тип данных (запись или тип-массив) и использовать их в программе также, как и стандартные типы данных.
Объявление типа должно находится в разделе type программы, который в общем случае следует за разделом объявления констант (начинается словом const) и предшествует разделу объявления переменных (начинается словом var).
const
// здесь объявления именованных констант
type
// здесь объявления типов
var
// здесь объявления переменных
Пример:
const
N = 10;
NR = 3;
NC = 5;
type
// TMaterial - тип-запись
TMaterial = record
title: string[15]; // название материала
density: float; // плотность материала
end;
// TMatrix - тип-массив
TMatrix = array[1..NR, 1..NC] of float;
var
aMaterial: TMaterial; // запись
TablMaterials : array[1..N] of TMaterial; // массив записей
m1: TMatrix; // двумерный массив
Запись, представляет собой структуру данных, которая, в общем случае, может состоять из элементов (полей) разного типа.
В общем виде объявление типа-записи выглядит так:
Имя = record
Поле_1: Тип_1;
Поле_2: Тип_2;
...
Поле_n: Тип_n;
end;
где:
Имя — имя типа-записи;
record — слово языка программирования, означающее, что далее следует объявленияполей записи;
Поле_i и Тип_i — имя и тип i-го поля записи.
Замечание. В сообществе Pascal-программистов принято правило - имена типов, объявляемых программистом, должны начинаться буквой T (первая буква слова Type - тип).
Примеры:
type
TMaterial = record
title: string[15]; // название материала
density: float; // плотность материала
end;
TBook = record
Title: string[40]; // название
Autor: string[20]; // автор
Price: float; // цена
end;
TPoint = record
x: integer;
y: integer;
z: integer;
end;
После объявления типа-записи можно обычным образом объявить переменную-запись или массив записей .
Примеры:
var
material: TMaterial;
book: TBook;
point: TPoint;
books: array[1..100] of TBook;
TablMaterials: array[1..10] of TMaterial;
Доступ к полям записи осуществляется по имени. Чтобы получить доступ к полю записи, надо указать имя переменной-записи и имя поля, отделив имя поля от имени переменной-записи точкой.
Примеры:
weight := volume * material.density;
writeln('Материал: ', material.title, 'Плотность: ', material.density:6:2);
writeln(book.Autor);
writeln(book.Title);
writeln(book.Price:6:2);
Доступ к полям записи-элемента массивазаписи осуществляется путем указания номера элемента массива и имени поля, которое указывается после закрывающей скобки через точку.
Примеры:
weight := volume * TablMaterials[k].density;
for i:=1 to n
writeln(books[i].Title:40, books[i].Author:20, books[i].Price:7:2);
end;
Объявление типа-массива выглядит так:
имя = array[1..HB] of тип;
или
имя = array[1..NR, 1..NC] of тип;
где:
имя – имя типа-массива;
HB – верхняя граница диапазона изменения индекса одномерного массива (целая или целая именованная константа);
NR и NC – соответственно количество строк и столбцов двумерного массива (целая или целая именованная константа);
тип – тип элементов массива (integer, float, string или тип-запись).
Замечание. В сообществе Pascal-программистов существует правило - имена типов, объявляемых программистом, должны начинаться буквой T (первая буква слова Type - тип).
Примеры:
type
TVector = array[1..N] of float;
TList = array[1..15] of string[25];
TMatrix = array[1..N, 1..M] of float;
TBooks = array[1..100] of TBook; // тип "массив записей TBook"
TablMaterials = array[1..10] of TMaterial; // тип "массив записей TMaterial"
После объявления типа-массива можно обычным образом объявить массив, используя объявленный тип.
Примеры:
var
list1: TList; // одномерный массив строк
v1: TVector; // одномерный вещественный массив
m1, m2: TMatrix; // двумерные вещественные массивы
tablmat: TablMaterials; // одномерный массив записей
Sqrt (x) – квадратный корень
Sin(r) - синус, r – угол в радианах
Cos(r) - косинус, r – угол в радианах
Tg(r) - тангенс, r – угол в радианах
Arctg(x) - арктангенс, x – тангенс
Round(x) - округление
Trunc(x) – целая часть вещественного
Abs(x) - абсолютное значение
Random(n) – случайное число в диапазоне 1..n
Length(строка) – дина строки
Функция Length возвращает количество символов строки, указанной в качестве параметра.
Pos(подстрока, строка) – позиция подстроки в строке
Функция Pos возвращает позицию первого вхождения подстроки в указанной строке. Если строка не содержит указанную подстроку, то функция возвращает ноль.
name := 'Bart Simpson';
p := Pos('Simpson ', name);
Substr(строка, номер_символа, дина) – подстрока
Функция Substr возвращает подстроку указанной строки. Параметр номер_символа задает позицию первого символа требуемой подстроки (начало подстроки), параметр дина – количество символов подстроки. Если длина строки меньше чем значение параметра номер_символа, то функция возвращает пустую (не содержащую ни одного символа) строку. Если длина строки такова, что получить подстроку указанной длинны нельзя, то функция возвращает правую часть строки, начиная от символа с указанным номером.
Пример использования строковых функций Length, Pos и Substr:
program p1()
var
name: string[15];
lastName: string[15];
firstName: string[15];
p: integer; //позиция пробела в имени
begin
name := 'Bart Simpson';
writeln('Name: ', name);
p:= Pos(' ', name);
if p !=0 then
firstName := Substr(name, 1, p-1);
lastName:= Substr(name, p+1, Length(name)-p);
else
firstName := name;
lastName:='';
end;
writeln('First Name: ', firstName, ' Last name: ', lastName);
readln;
end.
UpCase(строка) – строка, преобразованная к верхнему регистру
Функция UpCase возвращает строку, преобразованную к верхнему регистру.
Пример:
name := UpCase(name);
LowCase(строка) – строка, преобразованная к нижнему регистру
Функция LowCase возвращает строку, преобразованную к нижнему регистру.
Пример:
name := LowCase(name);
Функция IntToStr(x) возвращает строковое представления выражения целого типа, указанного в качестве ее параметра.
Функция StrToInt(st) преобразует строку-изображение целого числа в число, соответствующее строке-параметру. Если строка-параметр не является правильным изображением целого числа (содержит символы, отличные от цифр), то функция возвращает 0.
Функция FloatToStr(x) возвращает строковое представления выражения вещественного типа, указанного в качестве ее параметра.
Функция StrToFloat(st) преобразует строку-изображение вещественного числа в число, соответствующее строке-параметру. Если строка-параметр не является правильным изображением вещественного числа (содержит символы, отличные от цифр или десятичного разделителя), то функция возвращает 0.
Функции даты и времени:
getDay()
getMonth()
getYear()
getDayOfWeek()
getTime()
Функция getDay() возвращает порядковый номер дня текущего месяца.
Функция getMonth() возвращает порядковый номер месяца года.
Первый месяц года – январь, нумерация с единицы.
Пример:
program p1()
var
day: integer;
month: integer;
monthName: array[1..12] of string[10] =
'январь','февраль','март','апрель','май','июнь',
'июль','август','сентябрь','октябрь','ноябрь','декабрь';
begin
day := getDay();
month := getMonth();
writeln('Сегодня ', day, ' ', monthName[month] );
write('Press <Enter>');
readln;
end.
Функция getYear() возвращает порядковый номер года.
Пример:
program p1()
var
day: integer;
month: integer;
year: integer;
begin
day := getDay();
month := getMonth();
year := getYear();
writeln('Сегодня ', day, '-', month, '-', year);
write('Press <Enter>');
readln;
end.
Функция getDayOfWeek() возвращает порядковый номер дня недели.
Первым днем недели считается воскресенье. Дни недели нумеруются с нуля.
Пример:
program p1()
var
dayOfweek: integer;
weekDay: array[1..7] of string[11] =
'воскресенье', 'понедельник', 'вторник', 'среда',
'четверг', 'пятница', 'суббота';
begin
dayOfweek:= getDayOfWeek();
writeln('Сегодня ', weekDay[dayOfWeek + 1]);
write('Press <Enter>');
readln;
end.
Функция GetTyme() возвращает количество секунд от начала текущих суток.
Пример:
program p1()
var
time: integer;
hour: integer;
min: integer;
sec: integer;
begin
time := getTime();
Writeln('Секунд от начала суток: ', time);
hour:= time div 60 div 60;
min:= (time - hour*3600) div 60;
sec:= time- hour*3600 - min*60;
writeln('Сейчас ', hour, ':', min, ':', sec);
writeln('Press <Enter>');
readln;
end.
Зарезервированные слова языка программирования Pascal Next:
and array begin case const div do else end float for function goto if integer label | mod not or procedure program record repeat return string then to type until var while |
Основные отличия синтаксиса Pascal Next от "классического" Pascal:
| Pascal | Pascal Next | |
| Комментарий |
|
|
| Оператор сравнения "не равно " | <> |
!= |
| Инструкция if | if условие then begin действие_1 end else begin действие_2 end; |
if условие then действие_1 else действие_2 end; |
| Инструкция case | case селектор of диапазон_1: begin действие_1 end; диапазон_2: begin действие_2 end; else begin действие_k end; end; |
case селектор of диапазон_1: do действие_1 end; диапазон_2: do действие_2 end; else do действие_k end; end; |
| Цикл for | for i:=start to fin do begin действие end; |
for i:=start to fin do действие end; |
| Цикл while | while условие do begin действие end; |
while условие do действие end; |
| Цикл repeat | repeat действие until условие; |
repeat действие until условие; |
| Возможность объявления именованных констант | Есть | Есть |
| Возможность объявления пользовательского типа | Есть | Есть: запись тип-массив |
При первой компиляции программы компилятор Pascal Next создает текстовый файл (rs), и помещает в него шаблон информации о программе (название программы, версия программы, авторские права и др.). В процессе компиляции информация из rs-файла помещается в rsrc секцию .exe файла. Это дает пользователю возможность получить информацию о программе (содержимом exe-файла), увидеть, как называется программа, кто является разработчиком, кому принадлежат авторские права, номер версии.
Информация о содержимом exe-файла отображается в окне Свойства, которое появляется на экране в результате щелчка правой кнопкой мыши на имени файла и выбора из контекстного меню команды Свойства.
rs-файл, генерируемый компилятором:
Company=
Description=
Version=1.0.0.3
Copyright=(C) , 2021
ProductName=
ProductVersion=1.0.0.1
Программист может изменить содержимое .rc файла, чтобы информация, помещаемая в exe-файл, соответствовала разрабатываемой программе.
Пример rs-файла, после внесения изменений:
Company=MyCompany
Description=Pound tо gram converter
Version=1.0.0.1
Copyright=(C) Nikita Kultin , 2021
ProductName=Weight converter
ProductVersion=1.0.0.1
Внимание! При записи информации в rs-файл следует использовать буквы латинского алфавита.