TURBO PASCAL

Новости

Программы   

Turbo Pascal 

Игры

Документация   

Странности

FAQ

Ссылки

Форум

Гостевая книга

Рассылка

Благодарности

Об авторе

 

 

Урок первый,

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

 

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

Синтаксис языка,

или внешнее устройство

Комментарии,

или то, что многие игнорируют

Совершенно необходимой частью каждой программы (за исключением элементарных и плохо написанных) являются комментарии. Pascal поддерживает два способа выделения комментариев:

(* Комментарий,выделенный первым способом *)
{Комментарий, выделенный вторым способом}

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

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

Структура программы,

или главный порядок

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

{ часть объявления имени программы: }
Program NameOfProgram;
{ часть объявления списка подключаемых модулей: }
Uses {список модулей через запятую };
{ часть объявления констант: }
Const
{список констант и их значений через ; };
{ часть объявления типов пользователя: }
Type
{список типов пользователя через ; };
{ часть объявления переменных: }
Var
{список переменных и их типов через ;};
{ часть основной программы }
Begin {точка входа}
{операторы основной программы}
End. {основная точка выхода и конец программы}

Части Program и Uses не являются обязательными, однако должны быть первыми и единственными в программе. Const, Type и Var частей в программе может существовать множество, их порядок не нормируется и определяется требованиями программирования. Часть основной программы всегда является последней, признаком ее завершения является ключевое слово End с точкой после него. Любая информация после завершения основной части игнорируется компилятором.

Идентификаторы,

или имена

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

Каждое данное (каждый элемент данных) может (и должен) иметь определенное имя (идентификатор). То же самое относится и к каждому типу данных, и к процедурам, и к функциям. Идентификатором на Pascal'e считается любая последовательность из не более чем 126 символов, состоящая из букв латинского алфавита, цифр и символа "_", причем первым символом должна быть буква. Большие и маленькие буквы не различаются. Идентификаторы, у которых одинаковы первые 63 символа, считаются идентичными.

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

Стандартные типы данных

Для того, чтобы правильно обрабатываться компилятором языка, каждый элемент данных должен иметь некоторый определенный тип. Рассмотрим типы данных, стандартно обрабатываемые на Pascal'e. В основном групп типов девять (самих типов - море):

  1. целочисленные:
    Integer : 2 байта со знаком;
    ShortInt: 2 байта со знаком;
    Longint: 1 байт со знаком;
    Word: 2 байта без знака;
    byte: 1 байт без знака.
  2. дробные:
    Real: 6 байт;
    Single: 4 байтa;
    Double: 8 байт;
    Extended: 10 байт;
    Comp: 8 байт
  3. логические:
    Boolean: 1 байт;
    WordBool: 2 байта;
    ByteBool: 1 байт;
    LongBool: 4 байта;
  4. символьные:
    Char: 1 байт;
    String: от 1 до 255 байт + байт длины;
  5. указатели:
    Pointer: 4 байтa, нетипизированный указатель;
    ^<имя_типа>: 4 байта, типизированнный указатель;
  6. массивы - несколько однотипных элементов, объединенных одним именем; доступ к элементам производится по их номерам (индексам);
  7. записи - несколько разнотипных элементов, объединенных одним именем; доступ к элементам производится по их уникальным "подименам";
  8. множества - несколько однотипных элементов, объединенных одним именем, причем элементы не повторяются; доступ к элементам производится через специальные функции;
  9. файлы - несколько элементов, объединенных одним именем и расположенных вне оперативной памяти; доступ к ним производится с помощью специфических процедур и функций;
  10. типы, определяемые программистом, - поименованные структуры из некоторых стандартных типов (эти типы не являются стандартными).

 

Следует отметить, что диапазон значений числовых типов определяется их размером и наличием знака для целочисленных типов, а для дробных - размером и спецификацией IEEE. Так к примеру диапазон переменной типа байт - от минус двух в седьмой до плюс двух в седьмой без единицы (-128..127). Логические переменные могут принимать значения False и True (ложь и истина соответственно), символьные - любое из значений ASCII набора, строки - набор символов ASCII длиной от 0 до указанной длины (максимально - 255).

Типы (д) - (и) и строковые типы относятся к так называемым сложным типам (потому как одним именем объединено несколько элементов).

Переменные,

или реализация типов

Элементы данных (в данном случае переменные; речь о константах - позже) простых типов описываются так:

<имя_переменной> : <имя_типа>;

Переменные типа "массив элементов типа ..." объявляются следующим образом:

<имя_переменной>: Array [нижняя_граница .. верхняя_граница] Of <имя_типа>;

при этом доступ к элементам производится через индексы: i-й элемент массива K есть K[i]. (Показано для одномерных массивов - линейной последовательности элементов, в принципе возможно описание двумерных массивов - матриц элементов, трехмерных - кубов из элементов, etc., до семимерных, для которых удобоваримого названия нет. Добавление дополнительного измерения к описанию массива производится добавлением после запятой пары "нижняя_граница .. верхняя_граница")

Переменные типа "запись" объявляются следующим образом.

<идентификатор>: Record <имя_поля>: <тип>;
[<имя_поля>: <тип>;]
End;

Доступ к полям записи производится так. "Поле pole переменной f" есть f.pole.

Нестандартные типы

или типы, определяемые программистом

Рассмотрим способы определения программистом собственных типов. Для того, чтобы объявить собственный тип, программист должен в Type-части (то есть после ключевого слова Type) написать сначала имя типа, а затем, после символа "=", его определение, то есть структуру. Как правило, программисты определяют собственными типами записи, массивы, объекты или типизированные указатели:

Type
TMyArray = Array[4..18] Of Real;
PMyArray = ^MyArray;
TMyRecrd = Record I: Integer;
C: Word;
S: String[4];
End;

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

Операторы

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

Все действия производятся с помощью операторов. Операторы делятся на два типа: простые и составные. К простым относятся:

  1. пустой оператор:
    ;
  2. оператор присваивания:
    <переменная> := <выражение>;
  3. оператор условия:
    If <логическое условие> Then
     <оператор1>
    [Else <оператор2>];
  4. оператор множественного выбора:
    Case <переменная> Of     <значение1>: <оператор1>;
    [<значениеN>: <операторN<;]
    [Else <оператор>;]
    End;
  5. оператор параметрического цикла:
    For <переменная> := <начальное_значение> To <конечное_значение> Do
     <оператор>;
  6. оператор цикла с предварительной проверкой условия:
    While <логическое условие> Do     <оператор>;
  7. оператор цикла с постфиксной проверкой условия:
    Repeat <оператор>;
    [<оператор>;]
    Until <логическое условие>;
  8. вызов процедуры.

 

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

Составным оператором называется любой набор простых и составных операторов, начинающийся с Begin и оканчивающийся End.

В описании простых операторов <оператор> означает оператор любого типа - простой либо составной. Однако следует помнить, что если при выполнении условия (или в теле цикла) необходимо выполнять несколько действий, применение составного оператора обязательно. Также следует отметить, что любой оператор - простой или составной - должен оканчиваться точкой с запятой, за исключением тех случаев, когда он находится перед ключевым словом Else условного оператора или непосредственно перед словом End.

Выполнение простых операторов

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

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

Оператор присваивания выполняется стандартным образом: <переменной> в левой части присваивается значение предварительно вычисленного <выражения>. Выражением могут служить:

  1. константа;
  2. переменная;
  3. вызов функции;
  4. правильно построенный набор из предыдущих элементов, объединенных операциями.
Тип выражения должен соответствовать типу переменной в левой части оператора присваивания или мочь быть приведенным к этому типу. Операции в последнем пункте зависят от типа вычисляемого выражения - арифметические (+ - * / mod div), логические (And, Or, Not, =), строковые (+), etc.

 

Также стандартным образом выполняется оператор условия. При равенстве логического выражения True, выполняется <оператор1>, в противном случае выполняется <оператор2>, если таковой наличествует.

Оператор множественного выбора выполняется следующим образом. Значение <переменной> последовательно сравнивается со <значениями>, указанными в теле оператора и при равенстве выполняется соответствующий <оператор>. Если все сравнения прошли безуспешно и существует Else часть оператора, то выполняется ей принадлежащий оператор.

Оператор параметрического цикла выполняется следующим образом. В первую очередь переменной (называемой параметром цикла) присваивается начальное значение. Затем производится сравнение значения параметра цикла с конечным значением. Если значение параметра больше конечного значения, цикл считается завершенным. В противном случае выполняется <оператор> (называемый телом цикла), после чего параметр цикла увеличивается на 1. Затем все повторяется начиная с этапа сравнения.

У параметрического цикла есть разновидность: если вместо слова To написать DownTo, то параметр цикла будет не увеличиваться, а уменьшаться на 1, и, соответственно, условием окончания цикла будет достижение параметром цикла конечного значения.

Как правило, в целях придания хорошего стиля в программировании не рекомендуют изменять значение параметра цикла внутри тела цикла. Однако, большинство языков не запрещают делать этого, правда при работе с Borland Pascal в этом случае следует очень внимательно следить за тем, чтобы по окончании выполнения какого-либо повтора тела цикла значение параметра цикла было точно равно (а не просто больше) следующему за конечным значению, в противном случае правильного результата достичь довольно сложно.

Оператор цикла с предварительной проверкой условия выполняется так. До первого выполнения оператора (i.e. тела цикла) вычисляется значение логического условия. Если условие принимает значение True, то выполняется тело цикла и вновь вычисляется значение логического условия, в противном случае оператор считается выполненным (цикл завершается). Следует заметить, что изменение значения логического условия - личное дело программиста.

Оператор цикла с постфиксной проверкой условия выполняется, в известном смысле, наоборот. Сначала выполняется <оператор> (тело цикла), затем вычисляется логическое условие. При равенстве его False цикл повторяется. Изменение значения логического условия также лежит на программисте.

Следует напомнить, что цикл While может не выполнится ни разу, а цикл Repeat выполнится как минимум один раз.

Процедуры и функции,

или как структурировать программы

Часто повторяющиеся участки программы, да и просто функционально законченные фрагменты кода, рекомендуется выделять в процедуры. Объявление процедуры производится в любой части программы до ее первого использования (и, конечно, до начала основной программы) следующим образом.

Procedure <имя процедуры> [(<список_параметров>)];
[Var часть]
[Const часть]
Begin {тело процедуры}
[<операторы>]
End;

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

[Var] <имя формального параметра>: <тип параметра>

разделенных точками с запятой, где именем параметра является идентификатор, с которым ассоциируется значение фактически переданного процедуре параметра (именно значение, а не переменная, передаваемая в качестве параметра), а типом параметра - стандартный или ранее определенный тип. Если перед именем параметра стоит ключевое слово Var, то изменение данного параметра в теле процедуры приведет к изменению значения переменной, переданной в качестве параметра.

Вызов процедуры производится так:

<имя процедуры> [(<список фактических параметров>)];

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

Аналогичным образом выполняются функции. Объявление функции выглядит так:

Function <имя_функции> [(<список_параметров>)]: тип_результата;
[Var часть]
[Const часть]
Begin {тело функции}
[<операторы>]
End;

Единственным отличием функций от процедур является возможность возврата некоторого значения. Указание конкретного значения, возвращаемое функций, производится путем присваивания в теле функции идентификатору имени функции данного значения. Естественно, что таких присваиваний может быть несколько, при этом значение возвращаемое функцией будет зависеть от того, какое из таких присваиваний было произведено последним. В Turbo Pascal, начиная с версии 7.0 возможен вызов функции без использования возвращаемого ею значения - аналогично процедуре. Так как при возврате значение функции находится, за редким исключением, в регистрах процессора, накладываются ограничения на типы результатов, возвращаемых функциями. Функции могут возвращать значения простых типов и строки.

Первая программа,

или с чего начинают все всегда и везде

Собственно, прочитав этот текст вы имеете представление о восьмидесяти процентах синтаксических структур на Pascal'е. Осталось набрать стандартную первую программу

Program Hello; {привет, значит}
Var I: Integer;
Begin
 WriteLN('Hello, World!');
Write('Enter the integer number, please ');
ReadLN(I);
WriteLN('You entered number greater than ', I-1, ', namely ', I);
End.

Стоит обратить внимание на разницу в выполнении WriteLN и Write.

 

На первую страницу

Rambler's Top100 Rambler's Top100
PROext: Top 1000

(с)Все права защищены

По всем интересующим вопросам прошу писать на электронный адрес

Hosted by uCoz