После того, как вы описали имя процедуры и список ее параметров, можно начинать создание самой процедуры. При этом не забывайте - процедура это маленькая программа, по своим свойствам не отличающаяся от основной. В приведенном примере вы видите, что она имеет свой раздел var, свою конструкцию begin - end. Итак, подведя итоги составим шаблон оформления процедуры, которым вы можете пользоваться, пока не запомните ее синтаксис.
Оформление процедуры
Procedure имя_процедуры (список_параметров: тип);
Const
список_констант_процедуры;
Var
список_переменных_процедуры: тип;
Begin
... тело_процедуры ...
end;
Как видите, все очень просто. Теперь давайте посмортим, как можно написать функцию. Для этого модифицируем нашу программу и поставим задачу следующим образом:
Написать функцию, возвращающую от своей работы сумму двух элементов. Вс остальные условия те же. Начнем?
Составление функций
При написании функции прежде всего стоит вспомнить ее назначение - возвращение от своей работы каких-либо значений. В наше случае - это будет сумма двух чисел, передаваемых как параметры. Что касается параметров - здесь все свойства те же, что и у процедур. Основное отличие функций от процедур - это служебное слово Function, которое идет вместо слова Procedure и возвращение функцией значения.
Последнее реализуется путем простого присваивания какого-нибудь значения самому имени функции. Модифицируем написанную выше программу:
Program P2;
uses Crt;
Function Add(a, b: Integer): Integer;
var
C: Integer;
begin
Add := A + B;
end;
var
N1, N2: Integer;
C: Char;
begin
repeat
{ Очищаем экран }
ClrScr;
{ Читаем переменные }
Write('Введите число N1: ');
Readln(N1);
Write('Введите число N2: ');
Readln(N2);
Writeln;
{ Вызываем нашу процедуру }
Write(Add(N1, N2));
{ Спрашиваем - Выйти? }
Writeln;
Write('Выйти? (Y/N): ');
Readln(C);
until UpCase(C) = 'Y';
end.
Обратите внимание на три главных момента в использовании функций.
1. Функция при описании должна получать свой тип, то есть указывается тип возвращаемого ей значения. Это значит, что если мы задали функции тип Integer, то ей может быть присвоено только целое число, кроме того - при использовании функции в программе мы можем использовать ее только в ситуациях, позволяющих манипулировать с типом Integer.
2. Возвращаемое значение задается простым присваиванием значения имени функции внутри ее.
3. Как и стандартные функции Паскаля, собственные могут быть использованы внутри процедур:
If Add(N1, N2) > 100 then Write('Сумма больше 100!');
Это самые основные моменты в использовании функций. К сожалению, на этом основном материале мне приходиться заканчивать этот выпуск, так как он и без того получился довольно большим. Следующий выпуск планируется Практическим, я постараюсь выпустить его как можно быстрее и опубликовать в нем решения интересных задач, использующих процедуры и функции, а также уточнить некоторые детали, такие как рекурсивность и т.п.
Вопросы - ответы
Вопрос 1. Допустим строковой переменной StrNumber присвоили некоторое значение в виде последовательности чисел, т.е. StrNumber:='231456'; Как записать в переменную Count целого типа результат суммирования данных чисел?
В данной формулировке задачи слова "чисел" следует заменить на слова "цифр", иначе задача не имеет смысла, так как в строке записано единственнео число, в исправленной формулировке задача имеет такое решение:
...............
Sum:=0;
S:=StrNumber;
while(s[0]<>0)do
begin
Val(S[1],i,code);
inc(Sum,i);
delete(s,1,1);
end;
writeln('Сумма равна ',sum);
...............
Проверка на корректность строки здесь не делается.
Вопрос 2. Есть такие процедуры как FindFirst и FindNext. Мне нужно организовать поиск, например, всех архивных файлов (пусть будут ARJ, RAR и ZIP) не только в текущем каталоге, указанном в качестве одного из операндов, но и во всех подкаталогах указанного каталога. Чего-то не пойму как это сделать. Судя по NC, VC и FAR - они уже давно определились с этой задачей. Подскажите где взять стандартное решение или одно из возможных?
Все не так просто, здесь нужно применять реккурсивный обход дерева каталогов. Внесите нужные Вам изменения и ищите наздоровье.
uses dos;
Procedure FileFind(Dir,FindName : PathStr);
{Поиск файлов по маске по всему диску}
Procedure SearchDir(Dir : PathStr);
Var
SRec : SearchRec;
begin
{Поиск файлов по маске}
if Dir[Length(Dir)] <> '\' then Dir := Dir+'\';
FindFirst(Dir + FindName, AnyFile, SRec);
While DosError = 0 do
begin
With SRec do
if Attr and (VolumeID + Directory) = 0 then
WriteLn(Dir + Name);
FindNext(SRec);
end;
{Поиск всех вложенных каталогов, в т.ч. скрытых, системных, r/o}
FindFirst(Dir+'*.*', Directory or ReadOnly or Hidden or SysFile, SRec);
While DosError = 0 do
begin
With SRec do
if (Attr and Directory <> 0) and (Name[1] <> '.') then
SearchDir(Dir+Name);
FindNext(SRec);
end;
end;
begin
SearchDir(Dir);
end;
{------------------------------------------}
{Пример поиска всех .TXT файлов на диске С:}
begin
FileFind('c:\','*.txt');
end.
Итак, сегодня мы продолжим тему программирования на Паскале и в этом выпуске у нас практика. Чем же мы будем заниматься? Вот наш план действий на сегодня:
Новая конструкция - case;
Методы и процедуры работы со строками;
Преобразование типов;
Вот такие задания нам и предстоит выполнить. Насчет программы-калькулятора скажу следующее: на самом деле это подробный разбор программы из прошлого домашнего задания. Было очень много вопросов по этой программе, а многие ею вообще не занимались, решив что это простой калькулятор и уделять внимание ему не стоит. На самом деле вы не правы, если так думаете. Мне кажется вы и сами поймете это, прочитав соответствующий подраздел.
Итак, начнем?
Новая конструкция - CASE
Начнется наша практика с освоения новой конструкции языка - так называемой "консрукции выбора", или case. Для чего служит эта конструкция?
На самом деле ее можно представить как расширение условного оператора If. Case - это конструкция выбора, она проверяет соответсвующий оператор на различные его значения, и выполняет действие (или группу действий) в зависимости от того, чему это значение равно.
Примера ради давайте представим такую ситуацию:
Выводим на экран такие строчки:
1 - Ввести число;
2 - Ввести символ;
3 - Ввести строку;
Выход.
Мы вводим символ (char).
Если символ равен "1", то выполняем Readln(Integer);
Если символ равен "2", то выполняем Readln(Char);
Если символ равен "3", то выполняем Readln(String);
Если символ равен "4", то завершаем программу;
Как Вы напишите такую программу? Первое, что приходит на ум - это использование нескольких условных конструкций If...then...else. Но это совсем не обязательно. Конструкцию If лучше использвать когда у нас проверка переменных происходит именно для сравнения их с каким-либо значением или диапазоном (к примеру: If A > 100 then...), а не для сканирования переменной с несколькими, определенными заранее значениями
(к примеру:
If A = 10 then ..... else
If A = 20 then .... else
If A = 30 then ....; )
Для таких ситуаций и предназначена конструкция case, которая позволяет очень удобно проверять переменную на заранее определенные значения и выполнять различные действия, в зависимости от того, чему эта переменная равна.
Итак, решая приведенную задачу, мы напишем следующее:
Program N1;
uses Crt;
var
C, C1: Char;
I: Integer;
S: String;
Q: Boolean;
begin
repeat
ClrScr;
Writeln('1 - Ввести число;');
Writeln('2 - Ввести символ;');
Writeln('3 - Ввести строку;');
Writeln('4 - Выход.');
Writeln;
Write('Ваш выбор: ');
Readln(C);
case C of
'1': Readln(I);
'2': Readln(C1);
'3': Readln(S);
'4': Q: true;
end;
until Q;
end.
Программа сама по себе мало работоспособная конечно :)), зато демонстрирует использование case. Итак, давате определимся с синтаксисом этой конструкции:
1. Case _переменная_или_выражение_ of
Это - первая строка, показывающая начало конструкции case. Переменная, выражение или функция, которые могут стоять между case и of - это само условие, которое будет проверяться.
2. Значение: begin ... действия ... end;
Это - пара "значение-действие" и является содержимым конструкции. Количество таких пар практически неограничено. Работает это так:
o Если выражение в заголовке case удовлетворяет какому-то значению в паре "значение-действие", то выполняется действие (действия), которые определены для этого значения.
При этом обратите внимание, что если действий для конкретного значения несколько, то все они ограждаются служебными словами begin - end; Если действие одно, то это совсем необязательно, хотя и ошибки тоже не вызовет. Пример:
Program N1;
uses Crt;
var
C, C1: Char;
I: Integer;
S: String;
Q: Boolean;
begin
repeat
ClrScr;
Writeln('1 - Ввести число (100 - выход);');
Writeln('2 - Ввести символ;');
Writeln('3 - Ввести строку;');
Writeln('4 - Выход.');
Writeln;
Write('Ваш выбор: ');
Readln(C);
case C of
'1': begin
Readln(I);
if I = 100 then
begin
Write('Число равно 100!');
Q := true;
end
else Write('Число не равно 100!');
end;
'2': Readln(C1);
'3': Readln(S);
'4': Q := true;
end;
until Q;
end.
3. После всех условий ставится end; - то есть конструкция case имеет собственный закрывающий end, который должен присутсвовать обязательно.
Также конструкция case позволяет использовать внутри себя кроме пар "значение: действие" еще одну интересную возможность, а именно употребление служебного слова else. Раобта его точно такая, как и в случае с if...then...else, то есть формулируется след. образом: "если ничего не совпало, то выполни то, что после else".
Иначе говоря, в случае, если значение выражения или переменной не совпало ни с каким из указанных значений, то выполнится все, что указано после else. Вот модифицированный пример:
............
case C of
'1': begin
Readln(I);
if I = 100 then
begin
Write('Число равно 100!');
Q := true;
end
else Write('Число не равно 100!');
end;
'2': Readln(C1);
'3': Readln(S);
'4': Q := true;
else
begin
Write('Нет такого значения!');
Readln;
end;
end.
Отмечу, что использование else в конструкции case соверешенно не обязательно и зачастую не используется. Чаще всего case создается затем, чтобы действия выполнялись только при соответсвии условия какому-нибудь значению, или не выполнялись совсем. Else наоборот, превращает case в подобие if - то есть получается, что какие-то действия выполняться в любом случае. Однако, это довольно спорный вопрос - на примере вы и сами видите, что else иногда совсем не лишнее. Так что знать и помнить об этой возможности обязательно.
Методы и процедуры работы со строками
Вы уже давно знаете, что к строке можно ображаться как к массиву, работать с отдельными ее символами. Но это далеко не единственная возможность Паскаля по обработке строк. На самом деле существует достаточное количество стандартных процедур, чтобы разрешить практически любую проблему с манипуляцией со строками. А такие проблемы иногда возникают.
К примеру, известная нам функция Length, которая вычисляет длину строки. Разве не удобно ее использовать? По моему, вполне. Но хочется отметить, что по сути Length даже и не относиться к функциям работы со строками (точнее, к функциям по обработке строк), так как она не манипулирует со строкой непосредственно. Вычисление размера, на мой взгляд, это не прямая работа... хотя у каждого есть на этот счет свое мнение, а я должен придержиться сути нашего урока.
Итак, для начала я перечислю все процедуры и функции, имеющиеся в языке Turbo Pascal 7.0, которые служат для обработки строк:
function Copy (S: String; Index: Integer; Count: Integer): String;
function Concat (S1, S2, ....., Sx: String): String;
Из не так уж и много, как видите. Кстати, обратите внимание: начиная с прошлого выпуска вы знакомы с понятием процедуры и функции, поэтому я записываю их с параметрами и указанием типа для функций.
Ну а теперь давайте рассмотрим все эти процедуры в отдельности и заоодно немного с ними попрактикуемся. Найдутся и примеры создания собственных функций.
1. function Copy (S: String; Index: Integer; Count: Integer): String;
Начнем с функции Copy. Эта функция создает из имеющейся строки подстроку. Проще говоря, выделяет какой-то кусок имеющейся строки и возвращает его как результат своей работы. Результат этот как всегда (помните, определение функций?) может быть присвоен переменной, использован в выражении, в процедуре (например, выведен на экран).
Теперь о параметрах. Как вы видите, их у Copy три. Разберем их по отдельности:
S: String;
Этот параметр - исходная строка, то есть та строка, из которой мы будем "вырезать кусок".
Index: Integer;
Номер первого символа, начиная с которого начнется выделение строки. При этом если этот параметр больше реальной длины строки, то функция возвратит пустую строку.
Count: Integer;
Количество символов, которые будут выделены, начиная с номера, задаваемого параметром Index: Integer;
Чтобы показать наглядно работу функции Copy, представьте себе такую строку:
АБВГДЕ
Допустим, мы хотим выделить три символа, начиная со второго, то есть получить такую строку:
БВГ
При использовании Copy для реализации такой задачи давайте напишет следующую программу:
Program N2;
var
S, S1: String;
begin
S := 'АБВГДЕ';
S1 := Copy(S, 2, 3);
Write(S1);
Readln;
end.
Эта программа делает именно то, что нам нужно. Думаю, здесь все понятно и двигаемся дальше.
А дальше, в качестве практики, да и для лучшего восприятия работы этой фукнции я предлагаю самим написать функцию Copy. Разве не интересно иногда задуматься, что там - внутри Turbo PASCAL'я?
Итак, если вы не возражаете, начнем. Что же мы будем делать? Во-первых, задумаемся что представляет собой "выделение подстроки из строки". А это не что иное, как:
Вычисление размера исходной строки;
Если параметр Index больше, чем длина заданной строки, то возвращаем пустую строку - ''; иначе переходим на следующий пункт.
Начиная с символа под номером, задаваемым параметром Index мы будем дополнять временную строку символами из заданной строки, выполняя это столько раз, сколько задано в параметре Count.
В качестве возвращаемого значения присвоим имени функции новую, временную строку.
Что скажете? Ведь действительно, все очень просто. Но однажды написав самостоятельно такую процедуру, вы сразу и до конца поймете работу со строками и их организацию, что, поверьте мне, далеко немаловажно.
Итак, текст программы (назовем новую, нашу функцию My_Copy;):
Program N3;
function My_Copy(S: String; Index: Integer; Count: Integer): String;
var
Temp_S: String;
I: Byte;
begin
Temp_S := '';
{ Проверяем на длину - иначе может получится белиберда }
If Count > Length(S)-2 then Count := Length(S)-2;
{ Если номер меньше, чем длина, то выполняем.
иначе Temp_S так и остается пустой, ее и возвращаем }
If Index < Length(S) then
For I := 1 to Count do
Temp_S := Temp_S + S[Index+I];
My_Copy := Temp_S;
end;
var
S, S1: String;
begin
S := 'АБВГДЕ';
S1 := My_Copy(S, 2, 3);
Writeln(S1);
S := '123456789';
Write(My_Copy(S, 5, 1));
Readln;
end.
Вот и все! Мы написали стандартную процедуру Паскаля! Как видите, это не очень сложно. Надо сказать, что это относиться практически ко всем процедрам Паскаля. Хотя некоторые довольно сложны, но все равно поддаются написанию даже начинающими программистами :))
Вообще, когда я использовал Паскаль в практических целях (не буду кривить душой, сейчас я на нем по больше степени не пишу), у меня был свой модуль, в котором была замена практически для всех стандартных процедур и функций, а также большинства модулей. И пользовался я только ими (правда, некоторые были на Ассемблере). Это, конечно, блажь, но ничего не поделаешь, у меня всегда было желание, особо в детстве, переиначить такие вещи :)))
И что я вам скажу - на первых порах это очень полезно и позволяет глубже разобраться не то чтобы в языке, но в большинстве типов и организации программ точно.
Ну да ладно, вернемся к нашей My_Copy. Как вы видите в конце программы, я использую два варианта ее применения - чтобы лишний раз продемонстрировать использование функции с переменной и использование ее внутри процедуры. Кроме того, саму функцию можно несколько улучшить, точнее оптимизировать - но это уже ваша работа, если будет интересно. :-)
Работает она в соответсвии с приведенным выше алгоритмом, за исключением случая, когда функции необходимо вернуть пустую строку. В описанном алгоритме, как вы можете заметить, проверка идет не на "Если номер символа больше", а "Если номер символа меньше". Но это требует дополнительных проверок. В используемом мной варианте, при правильности условия (Index < Length(S)) пустая строка Temp_S изменяется, иначе она так и остается пустой.
В самом конце функции возвращается значение, то есть My_Copy := Temp_S. К этому моменту временная строка Temp_S уже имеет нужное значение: либо пустая, либо заполненная.
Надеюсь, вы поняли приведенный мной алгоритм? Если нет, то выход один: напишите эту функцию самостоятельно, но уже с проверкой на "Если номер символа больше" и все станет на свои места.
А нам пора двигатсья дальше и мы переходим в новой процедуре - Delete.
Delete - англ. "Удалять". Соответственно, исходя из названия уже понятна работа процедуры. Она удаляет из строки определенную ее часть. Параметры:
S: String;
Исходная строка, в которой будет происходить удаление;
Index: Integer;
Номер первого удаляемого символа. При этом, как и в случае с функцией Copy, если это число больше, чем длина строки, процедура прорабатает вхолостую и символы не удалятся.
Count: Integer;
Число удаляемых символов. Если символом в строке не хватает, то удаляются все оставшиеся.
Работает эта процедура очень просто. Все происходит по принципу:
имеется строка S, допустим, 'Это 1-я строка'.
Хотим удалить из нее (вырезать) символы '1-я'.
Используем Delete(S, 5, 4);
Получаем: 'Это строка'
При этом число 5 (параметр Index: Integer) - это номер символа "1" в текущей строке S. Число 4 - количество символов до начала слова "строка". Вот и вырезаем все это дело :).
Если всмотреться в эту процедуру, то можно увидеть сходство с функцией Copy (или My_Copy:). Обе они вырезают кусок строки - только Copy возвращает его в качестве новой строки, а Delete - выразает его из строки, передаваемой в качестве параметра. Короче, Delete изменяет саму строку.
Ну что, может взять и написать теперь процедуру Delete? Что скажете? Можно? Вот и напишите! В рассылке мы этим пока заниматься не будем, так как загромождать выпуск однотипными исходниками не очень здорово. Но к моменту выхода следующего выпуска я все же выложу эту процедуру на сайте и специально поставлю на нее счетчик скачиваний... судя по его значению и увидим, заинтересовал ли я вас написанием стандартных процедур Паскаля.
Эта процедура производит совершенно обратное действие предыдущей - вставляет подстроку в строку. При этом если новая получившаяся строка больше 255 символов, что, как вы должны помнить, является максимальным размером строки, то она усекается до 255 символов. Разберемся со всеми параметры в отдельности:
Source: String;
Подстрока, которая помещается в строку.
S: String;
Исходная строка, то есть та, в которую будет влеплена строка Source.
Index: Integer;
Позиция в исходной строке S, начиная с которой будет помещена подстрока.
Например, имеется у нас две строки:
S := 'Это строка';
S1 := ' 1я';
... и хотим мы слепить их так, чтобы строка S получилась такой:
S := 'Это 1я строка';
, то есть поместить S1 в S начиная с позиции ... считаем ... с позиции 4. Для того, чтобы получить такой результат с помощью Insert, мы напишем следующее:
Insert(S1, S, 4);
Это можно прочитать по-русски: Вставляем подстроку S1 в строку S, начиная с позиции 4. Видите, как все просто? Кстати, написать самому процедуру Insert тоже совсем несложно. Очень советую! Это несколько отличается то функции Copy и процедуры Delete, поможет разобраться в некоторых нюансах и, возможно, заставит подумать.
А теперь давайте напишем небольшую программку, которая будет делать следующее:
Вводим две строки;
Проверяем: если слить первую строку со второй - не перевалит ли за 255 символов? Если нет, то:
Вводим Integer;
Вставляем в 1ю строку 2ю строку и выводим результат на экран.
Эта программа еще раз продемонстрирует работу процедуры Insert, что совсем не лишнее. Итак, текст программы:
Program N4;
uses Crt;
var
S, S1: String;
I: Integer;
begin
ClrScr;
Write('Введите 1ю строку: ');
Readln(S);
Write('Введите 2ю строку: ');
Readln(S1);
If Length(S)+Length(S1) <= 255 then
begin
Write('Введите позицию вставки: ');
Readln(I);
Insert(S1, S, I);
Write(S);
end
else Write('Слишком длинные строки!');
Readln;
end.
Как вы видите, использование этой процедуры не вызывает труда. Продолжаем дальше.
4. function Pos (Substr, S: String): Byte;
Эта функция предназначена для поиска строки в строке. Она возвращает номер символа, в которой начинается искомая строка, или, если такой строки нет, возвращает 0. Параметры:
Substr: String;
Это искомая строка, то есть та, которую фукнция пытается найти.
S: String;
Это строка, в которой производиться поиск.
Например, мы вводим две строки и нужно проверить, сущетсвует ли в первой введенной строке вторая, и если это верно, то вычислить ее позицию. Для этого мы напишем такую программу:
Program N5;
var
S, S1: String;
I: Integer;
begin
Write('Введите 1ю строку: ');
Readln(S);
Write('Введите 2ю строку: ');
Readln(S1);
I := Pos(S1, S);
If I <> 0 then
Write('Такая строка есть! Позиция: ', I)
else Write('Нет такой строки!');
Readln;
end.
Как вы видите, все очень просто. При этом если ввести в качестве первой строки символы '12345', а в качестве второй - '234', то позиция будет равна 2.
Опять же, как и с пред. процедурами и функциями, советую попробовать написать такую процедуру. Кстати, это уже сложнее - придется учитывать много нюансов и т.п. Напоследок хочу напомнить - если все же будете писать свою фукнцию Pos, не забывайте о оптимизации. Иначе в использовании вашей функции просто не будет смысла.
5. function Concat (S1, S2, ....., Sx: String): String;
Ну об этой функции и говорить особо нечего. Concat - это объединение нескольких строк в одну. Если вы сейчас вспомнили о операции объединения двух строк посредством сложения их знаком "+", то совершенно правильно сделали. Эта функция - абсолютный аналог этой операции. На мой взгляд, использование сложения строк через "+" гораздо лучше, чем использование Concat, так как занимает меньше места в программе, да и вообще... наглядней. Возможно, и работает чуть быстрее, хотя кто знает.
Итак, параметры Concat:
S1, S2, ....., Sx: String;
Список строк, которые будут сложены. Возвращает от своей работы получившуюся строку.
S := S + S1 + S2;
S := Concat(S, S1, S2);
Можно даже смеха ради сделать так:
S := Concat(S + S1, S2);
S := Concat(S, S1 + S2);
.........
Это все про Concat, да и в целом про работу со строками. Это очень интересная тема, я советую вам всеже написать собственные процедуры, хотя бы попробовать. В дальнешем мы еще обязательно вернемся к этим процедурам и функциям, когда будем писать программы, требующие работу со строками. Ну а на сегодня все, переходим к преобразованию типов.
Преобразование типов
Под фразой "Преобразование типов" я понимаю переход из одного типа к другому. К примеру, имеется число типа Integer и нам необходимо перевести его в строку, то есть преобразовать в тип Integer. Или наоборот - имеем строку и нам нужно преобразовать ее в число (иногда очень полезная возможность!). Это и есть преобразование типов.
При этом надо понимать, что на самом деле переменная не меняет свой тип. Это невозможно физически: в памяти компьютера все типы занимают разное количество байтов и изменить его для конкретной переменной невозможно. Преобразование типов сводиться лишь к возможности поместить значение переменной одного типа в переменную другого типа - в том виде, в котором оно этой переменной соответсвует. То есть переводя Integer в String мы всего лишь будем заполнять переменную типа String символами, которые соответсвуют цифрам переменной типа типа Integer.
Давайте теперь вспомним, сколько у нас основных типов. На самом деле всего два символьный и числовой (еще логический - Boolean - но он не основной, фактически это число). Оба они имеют несколько интерпритаций, к примеру сивольные типы это String и Char, а числовые - это Integer, Byte, Real, Single, Word.... При этом массивы и создаваемые пользователем типы (перечисляемые, объекты и т.п.) сюда не относятся, так как это что-то типа "контейнеров", которые содержат все те же основные типы.
Итак, основных типов у нас два. Для их взаимного преобразования в Паскале существует две очень простые процедуры:
procedure Str (X [: M [: N]]; S: String);
Преобразует число в последовательность символов - иначе говоря строку. При этом:
X: Выражение вещественного (Single, Real,...) или целого (Byte, Integer, Word...) типа;
S: Строка типа String, в которую будет записано полученное значение.
M, N: Это параметры, аналогично тем, которые используются в процедуре Write. Могут быть опущены.
procedure Val (S: String; V; Code: Integer);
Преобразует строку символов в числовой тип. Параметры:
S: Строка типа String;
V: Переменная целого или вещественного типа для записи получившегося числа.
Code: Это переменная для указания ошибки, если таковая существует в строке S. При наличии ошибки указывает номер символа в строке, в котором содержится ошибка, в случае отсутсвия таковых устанавливается в 0.
Ну а теперь давайте попрактикуемся в преобразовании типов. Для начала примеры простейшего преобразования:
