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

1. Общая структура программ в ТП 7.0
Программы, написанные на языке программирования ТП 7.0, строятся в соответствии с правилами, представляющими собой несколько расширенные и "ослабленные" правила синтаксиса стандартного Паскаля. Но эти "ослабленные" правила (т.е. порядок размещения в тексте программы различных смысловых блоков) должны неукоснительно соблюдаться при написании программы. Любую программу, написанную на ТП 7.0, можно условно разделить на три основные части:

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

2. Раздел объявлений и соглашений

PROGRAM Заголовок программы;
{$ ... } Глобальные директивы компилятора;
USES Подключаемые библиотеки;
LABEL Подраздел объявления глобальных меток;
CONST Подраздел объявления глобальных констант;
TYPE Подраздел объявления глобальных типов;
VAR Подраздел объявления глобальных переменных;

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

3. Раздел текстов процедур и функций
В этом разделе записываются подпрограммы, осуществляющие сложные действия, которые необходимо произвести неоднократно на разных этапах выполнения программы. Подпограммы бывают двух типов: прjцедуры (PROCEDURE) и функции (FUNCTION). И те и другие пребставляют собой программы в миниатюре:

PROCEDURE (FUNCTION) Заголовок процедуры (функции);
LABEL Подраздел объявления локальных меток;
CONST Подраздел объявления локальных констант;
TYPE Подраздел объявления локальных типов;
VAR Подраздел объявления локальных переменных;
BEGIN Раздел текстов подпрограмм.
END; Основной блок процедуры или функции;Они могут иметь все те же разделы, что и основная программа, в частности, раздел локальных процедур и функций, вызываемых только в педелах данной подпрограммы.

Раздел основного блока программы:
BEGIN {Основной блок программы}
{текст программы}
END.
В этом разделе содержится смысловая часть программы.

4. Заголовок программы
Со строкой заголовка Вы уже знакомы. Она состоит из зарезервированного слова PROGRAM и имени программы. В Турбо Паскале эта строка не обязательна, и ее можно без ущерба исключить. Но правила хорошего тона в программировании требуют задания некоторого имени программы, чтобы уже при первом знакомстве можно было получить хоть какую-нибудь информацию об ее назначении. Однако не стремитесь привести здесь всю известную Вам информацию о программе - для этих целей можно воспользоваться дополнительными комментариями. Обычно в заголовке достаточно указать имя и версию программы. Следующее за оператором PROGRAM имя является идентификатором и обладает всеми его свойствами. В частности, внутри тела программы не могут быть объявлены объекты, имя которых совпадает с именем программы.

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!

Типы переменных
Тип переменной задает вид того значения, которое ей присваивается и правила, по которым операторы языка действуют с переменной, например:
Если переменные A и B целочисленного типа, то программа:
A:=3.14;
B:=2.71;
WRITELN(A,’ ‘,B,’ ‘,A+B);
Выведет на экран строку: “3.14 2.71 5.85”
Если же они строкового типа, то программа:
A:=’3.14’;
B:=’2.71’;
WRITELN(A,’ ‘,B,’ ‘,A+B);
Выведет: “3.14 2.71 3.142.71”, так как оператор сложения просто добавит строку B в конец строки A.
Тип константы определяется способом записи ее значения:
Const
C1=17;
C2=3.14;
C3='A';
C4=False;
C5=C2+C1;
Можно использовать выражения. Выражения должны в качестве операторов содержать только константы, в том числе ранее объявленные, а так же знаки математических операций, скобки и стандартные функции.
В Паскале предопределены следующие простейшие типы переменных:
BYTE - целое число от 0 до 255, занимает одну ячейку памяти (байт).
BOOLEAN - логическое значение (байт, заполненный единицами, или нулями), true, или false.
WORD - целое число от 0 до 65535, занимает два байта.
INTEGER - целое число от –32768 до 32767, занимает два байта.
LONGINT - целое число от –2147483648 до 2147483647, занимает четыре байта.
REAL - число с дробной частью от 2.9*10-39.до 1.7*1038, может принимать и отрицательные значения, на экран выводится с точностью до 12-го знака после запятой, если результат какой либо операции с REAL меньше, чем 2.9*10-39, он трактуется как ноль. Переменная типа REAL занимает шесть байт.
DOUBLE - число с дробной частью от 5.0*10-324.до.1.7*10308, может принимать и отрицательные значения, на экран выводится с точностью до 16-го знака после запятой ,если результат какой либо операции с DOUBLE меньше, чем 5.0*10-324, он трактуется как ноль. Переменная типа DOUBLE занимает восемь байт.
CHAR - символ, буква, при отображении на экран выводится тот символ, код которого хранится в выводимой переменной типа CHAR, переменная занимает один байт.
STRING - строка символов, на экран выводится как строка символов, коды которых хранятся в последовательности байт, занимаемой выводимой переменной типа STRING; в памяти занимает от 1 до 256 байт – по количеству символов в строке, плюс один байт, в котором хранится длина самой строки. При обьявлении переменной строкового типа можно заранее указать ее длину в байтах – X:
MyString:STRING[X];
При присвоении этой переменной строки длиннее X, присваиваемая строка будет обрезана с конца после X-того символа.
Размер (Size) переменной типа STRING в памяти можно узнать следующим способом:

Size:=SizeOf(MyString);
Функция SizeOf() возвращает Размер (Size), занимаемый переменной, служащей параметром. Параметром может служить и тип переменной; строка:
Writeln(SizeOf(STRING));
Выведет на экран число 256, так как по умолчанию под все строки отводится по 256 байт.
Кроме того, можно узнать, сколько символов в строке (индекс последнего непустого символа в строке):
Size:=Ord(MyString[0]);
Используется ибращение к нулевому элементу (символу) строки, в котором хранится ее длина, но MyString[0] – значение типа CHAR, тоесть символ, код которого равен длине строки, нужный нам код – число возвращает функция Ord()Таким же образом можно обратиться к любому N – тому элементу строки:
MyChar:=MyString[N];
{MyChar:CHAR}
ARRAY[a..b,c..d,….] OF “тип элемента”;массив некоторой размерности, содержащий элементы указанного типа.Диапазоны индексов для каждого измерения указываются парами чисел или констант, разделенных двумя точками, через запятую (a..b,c..d). После OF записывается тип элементов массива. В памяти массив занимает место, равное: (b-a)*(d-c)*..* SizeOf(“тип элемента”). Размер (Size) массива не может превосходить 65536 байт.
Обращение к элементам массива происходит следующим образом:
X:=MyArray[a,b,c,..];
При этом переменная X должна быть того же типа, что и элементы массива или приводимого типа. Число индексов (a,b,c,..) должно быть равно числу обьявленных при описании измерений массива.

О приводимости типов
В Паскале существуют ограничения на присвоение значений одних переменных другим. Если переменные которую и которой присваивают одного типа, то никаких проблем не возникнет. Но если они разных типов, присвоение не всегда может быть произведено. Это связано стем, что при таком присвоении необходимо отсечь часть информации, а какую – компьютер “не знает”.
Проблема возникает при следующих присвоениях:
I:=J; {I:INTEGER; J:REAL}
A:=B; {A:CHAR; B:STRING}
В то же время, такие присвоения будут выполнены вполне корректно:
J:=I;
B:=A;
При этом переменная J примет значение с нулевой дробной частью, а B – станет строкой, содержащей один символ – из A.
В первом же случае, можно поизвести следующие операции:
I:=Trunc(J); {функция trunc() возвращает целую часть аргумента}
I:=Round(J); {round() – округляет аргумент стандартным способом}
Кроме рассмотренного случая может существовать множество других, но наиболее общее правило таково: следить за однозначностью присвоения с потерями информации и не удивляться, а экспериментировать переделывать программу, если компилятор выдает сообщение о невозможности присвоения.

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!

Простые и структурные типы данных

1. Перечисляемый и ограниченный типы
Ранее рассматривались простые стандартные типы данных (Integer, Boolean,Char ...) - порядковые типы, то есть к переменным этих типов применимы Succ и Pred. Real - не порядковый тип.
В Паскале разрешено введение новых типов. Секция Type располагается между секцией констант и секцией переменных. Введение своих типов повышает "читабельность" программ.
Например: Месяцы.
Type
Month = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
Var
M: Month;
Максимальная мощность перечисляемого типа - 256 значений, поэтому перечисляемый тип фактически задаёт подмножество типа Byte.
В Паскале отсутствуют средства, которые бы позволяли осуществить непосредственный ввод - вывод переменных перечисляемого типа, однако можно вывести код: Write(Ord(M)).
Кроме того применимы операции сравнения:
If (M > FEB) And (M < JUN) Then
Write ('Весенний месяц');
Следует иметь ввиду, что упорядоченность элементов перечисляемого типа определяется порядком их следования. Самый левый элемент имеет минимальное значение, правый - максимальное.
Пример:
процедура, в которой переменной перечисляемого типа присваивается значение, в зависимости от введенного дня недели; если введённые символы ошибочны, возвращается соответствующее сообщение.
Program DAY (Input, Output);
Type
  DayOfWeek = (Sun, Mon, Tue, Wen, Thu, Fri, Sat);
Var
  D: DayOfWeek;
  Well: Boolean;
Procedure Read_WD (Var I: DayOfWeek;Well: Boolean;);
Var
  C: Char;
Begin
  Read(C);
  Well:= False;
  Case C Of
    "S": Begin
    Readln(C);
    Case C Of
      "U": Begin
      I:= Sun;
      Well:= True;
    End;
    "A": Begin
    I:= Sat;
    Well:= True;
    End;
  End;{Of Case}
  "M": Begin
    Well:= True;
     I:= Mon;
      End;
  "T": Begin Readln(C);
  Case C Of
   . . . . . . . . .
  End;
  "W": Begin
    Well:= True;
    I:= Wen;
  End;
  "F": Begin
    Well:= True;
    I:= Fri;
  End;
End;
End;
Begin
  Read_WD(D, Well);
  If Not Well Then
  Writeln ('Ошибка');
End.
Кроме перечисленного типа можно вводить ограниченные или интервальные типы.
Пример:
Type
Year = 1900..2000;
Letter = "A".."Z";
Левая и правая константы задают диапазон значений и их называют соответственно верхней и нижней границей ограниченного типа.
Константы в определении ограниченного типа должны относиться к одному и тому же базовому типу (целому, символьному, порядковому). Базовый тип констант определяет допустимость операций над данными ограниченного типа.
Пример:
Type
  Days = (Mo, Tu, We, Th, Fr, Sa, Su);
  WeekEnd = Sa..Su;
Var
  W: WeekEnd;
. . . . . . . . . . . .
Begin
. . . . . . . . . . . .
  W:= Sa;
. . . . . . . . . . . ,
Так как тип-диапазон наследует все свойства базового типа, но с ограничениями, связанными с его меньшей мощностью, то Ord(W) вернёт значения S , в то время как Pred(W) приведёт к ошибке.
И перечисляемый и ограниченный типы относят к простому типу.
Простой тип - это такой тип, который в некоторый момент времени хранит только одно значение.
Структурированные типы данных - совокупность связанных данных и множество правил, определяющих, как их организацию так и способ доступа к элементам данных.
Массив - это упорядоченный набор переменных одного типа.
Массив содержит фиксированное число компонент, которое задаётся при определении переменных типа массива. Тип компоненты массива может быть любым. Каждый элемент масива имеет свой индекс. Тип индекса - простой, поэтому все элементы массива могут быть перебраны при помощи операторов цикла.
Описание (description) массивов:
Var
  Mas: Array [1..15] Of Real.
  Work: Array [(Mon, Tue, Wed)] Of Integer.
  B: Array ['A'..'Z'] Of Boolean.
  C: Array [1..3, 1..5] Of Real.
  D: Array [(Black, White)] Of 11..20.
В Паскале многомерный массив можно описать как одномерный:
Type
   Mas = Array [1..3] Of Array [1..5] Of Integer;
Var
   A, B: Mas;
   C: Array [1..3, 1..5] Of Integer;
{такая же структура но определена как двумерный массив}
URL (ссылка) на элемент матрицы А, лежащий на пересечении I-той строки и J-ого столбца выглядит следующим образом A[J]; законно и такое обращение A[2]:= B[1], для массива такая запись не верна. Все элементы структурированных типов допускают A:= B (исключение - переменные файлового типа).
Можно использовать комформант - массивы. Массивы с переменными границами в Турбо-Паскале использовать нельзя. Нельзя, также и сравнивать массивы:
If A = B Then ...
В Турбо-Паскале предварительно определены два массива Mem и Port.

2. Символьные строки
Переменную типа Packed Array [0..N] of Char принято называть [i]символьной строкой.
Строка - это упакованный массив, компоненты которого имеют тип Char и тип индекса имеет нижнюю границу равную одному. К строкам применимы все 6 операций отношений, но строки при этом должны иметь равную длину.
В Турбо-Паскале введён тип данных String вместо описанного Packed Array of Char.
Операции с Char:
'5' < '25' {ошибка, так как разные длины строк}
'Var' = 'Var' {верно}
Var
Age: String [3];
Begin
Age:="тринадцать"; {Лишние символы после "и" усекаются}

3. Множества
Паскаль позволяет оперировать с множествами как с типами данных.
Пример:
Type
  Symbolset = Set Of ' ' .. '_';
  Color = (White, Blue, Red);
  Colorset = Set Of Color;
  T1= Set Of 0..9;
Var
  C: Color;
  Colset: Colorset;
  T: Integer;
  Tset: T1;
Множества - наборы однотипных объектов, каким-либо образом связанных между собой. Характер связей лишь подразумевается программистом и никак не контролируется Турбо-Паскалем. Максимальное количество элементов множества - 256.
Два множества считаются эквивалентными тогда и только тогда, когда все элементы их одинаковы, причём порядок следования элементов безразличен.
Описание (description):
<имя типа> = Set Of <базовый тип>, где <базовый тип> есть любой порядковый тип кроме Word, Integer, Longint. Для задания множества используется конструктор множества (((: : =))). Список спецификаций элементов множества, отделяемых друг от друга запятыми; список обрамляется [ ]. Спецификациями элементов могут быть константы или выражения базового типа, а так же тип - диапазон того же базового типа:
Type
   Digitchar = Set Of '0'..'9';
   Digit =Set Of 0..9;
Var
  S1, S2, S3: Digitchar;
  S4, S5, S6: Digit;
begin
  . . . . . . . . . . . . . . . .
  S1 : = ['1', '2', '3'];
  S2 : = ['3', '2', '1'];
  S3 : = ['2', '3'];
  S4 : = [0..3, 6];
  S5 : = [4, 5];
  S6 : = [3..9];

Операции над множествами:
* пересечение (S4*S6 = [3,6]; S4*S5 = [4]) +объединение (S4+S5 = [0, 1, 2, 3, 4, 5, 6]) -разность, содержит элементы из 1-го, которые не принадлежат второму (S6-S5 = [3, 6, 7, 8, 9]) =проверка эквивалентности (S4=S4 = true; S5=S4 = false) <>проверка неэквивалентности (S4<&gtS4 = false; S5<&gtS4 = true) <=проверка вхождения (True если 1-е содержится во втором). >=(наоборот). inпроверка принадлежности.

Пример:
Алгоритм получение простых чисел.
Const
  N = 100;
Type
  Set_Of_Num = Set Of 1..N;
Var
  N1, Next, I: Word;
  Begset, Primerset: Set_Of_Num;
Begin
  Begset:= [2..N];
  Primerset:= [1];
  Next:=2;
  While Begset <> [ ] Do
   Begin
   N1:= Next;
     While N1 <= N Do
      Begin
      Begset:= Begset - [N1];
      N1:= N1 + Next;
      End;
   Primerset:= Primerset + [Next];
  Repeat
    Inc(Next);
  Until (Next In Begset) Or (Next > N);
  End;
  For I:=1 To N Do
    If I In Primerset Then
  Write(I: 8);
  Writeln;
End.
Итак, над множествами допустимы четыре операции:
• объединение (+)
• пересечение (*)
• разность (-) (содержит элементы из 1-го, которых нет во 2-ом).
• операция in - позволяет определить, принадлежит элемент множеству или нет.
В программе множество задаётся в виде списка элементов, заключённого в квадратные скобки:
Colset:= [White, Red];
Colset:= [ ];
Tset:= [1, 7, 5];
Tset:= [0 ... 3, 6, 9];
Tset:= [8 Mod4, 15 Div 5];
Можно использовать операции сравнения.

Пример: из файла вводится текст, содержащий символы от "+" до "[". Требуется рассчитать символы текста в порядке кода ASCII (из повторно встречающихся выводить только один):
Program Sort
Var
  S: Char;
  Sets: Set Of '+'..'[';
  I: '+'..'[';
Begin
  Sets:= [ ];
  Read(S);
  While Not Eof Do
  Begin
     While Not Eof Do
     Begin
       Sets: = Seets + [S];
       Read(S);
     End;
  End;
  Writeln;
  For I: ='+' To '[' Do
   If I In Sets Then
  Write (I);
  Writeln;
End.

4. Записи
Запись - наиболее общий и гибкий структурированный тип в Паскале.
Запись состоит из фиксированного числа компонентов, называемых полями, которые могут быть различных типов. Этим запись существенно отличается от массива, все компоненты которого должны быть одного и того же типа и доступ к компонентам осуществляется не по индексам (номерам), а по именам.
Пример:
Type
  Date = Record
    Year: Integer;
    Month: 1..12;
    Day: 1..31;
  End;
  Book = Record
    Title: String [40];
    Author: String [50];
    Entry: Date;
  End;
Var
  D1: Date;
  B: Book;
В Паскале разрешено использовать массивы записей. Записи также можно использовать в качестве компонент файлов. Однако поля записи не могут быть файлового типа. Чтобы обратиться к отдельной компоненте записи необходимо задать имя записи, за ним точку и сразу за точкой написать название нужного поля.

Пример1:
D1.Day:=25;
B.Author:= "Levy";
B.Entry.Year:= 1980;
а можно и
B. Entry: = 1980; так как Year первое поле Date.

Пример2: В памяти находится массив из 1000 элементов, каждый из которых имеет тип записи Book. Определить количество книг, год издания которых меньше или равен 1600 году. Для каждого из таких элементов массива распечатать название книги, имя автора, год издания:
Program Rarity;
Type
Date = Record
. . . . . . . . . . .
End;
Book = Record
. . . . . . . . . . .
End;
Var
  S, I: Integer;
  Mas: Array[1..1000] Of Book;
Begin
  S:= 0;
  For I:= 1 To 1000 Do
    If Mas.Entry.Year <= 1600 Then
    Begin
      Write (Mas[i].Title,}' , ',Mas[i].Author,',' , ',Mas[i].Entry.Year: 6);
      S:= S+1;
    End;
   Writeln ('Число Книг' , S: 4);
End.

Оператор присоединения With.
Можно сократить длинные обозначения элементов записи:
[i]With имя записи Do оператор.
Оператор With открывает область действия, содержащую имена полей указанной переменной типа записи так, что эти имена фигурируют в качестве имён переменных. Кроме экономии места при написании программ, оператор With экономит так же время при выполнении программы, так как URL (ссылка) на запись подготавливается только один раз.
Пример:
With B Do
Begin
  Title: = ' ... ';
  Author:= ' ... ';
End;

эквивалентно

B.Title: = ' ... ';
B.Author:= ' ... ';

5. Запись с вариантами
Вариантная часть начинается со слова Case. Это означает, что в записях можно задавать тип, содержащий определения нескольких вариантов структуры. Различие может касаться как числа компонент, так и их типов. Запись может содержать только одну вариантную часть (экономия памяти). Вариантная часть сама может содержать варианты (вложения).

Пример:
Type
  N = String [20];
  Status = (Женат, Вдов, Разведён, Холост);
  Date = Record
     Mo: 1..12;
     Day: 1..31;
     Year: Integer;
  End;
  Person = Record
    Name: N;
    Sex: (Муж, Жена);
    Birth: Date;
    Case Ms: Status Of
    Женат, Вдов: (MDate: Date);
    Разведён: (Date: Date; First: Boolean);
    Холост: (Indept: Boolean);
  End.
Замечательная особенность - наложение в памяти вариантных полей, то есть дополнительная возможность преобразования типов:
Var
  M = Record
  Case Byte Of
    0: (By: Array[0..3] Of Byte);
    1: (Wo: Array[0..3] Of Word);
    2: (Lo: Longint);
  End;
. . . . . . . . . . . . . .
With M Do
Begin
  Lo: . . . . . .;
  If By [3] = 2 Then ... ;
Case Of, открывающее вариантную часть не имеет ничего общего с ветвлением Case Of; в данном случае это директива компилятору, сигнализирующая о том, что последующие поля нужно разместить начиная с одной и той же ячейки памяти, поэтому, если изменяется одно из полей - вариантов, изменяются и все остальные. Поле выбора должно быть порядкового типа.
В Турбо-Паскале, в отличие от классики, переменной, описанной в поле ключа выбора, можно присваивать значения, но это ни как не влияет на выбор поля. Значения констант выбора могут быть произвольными и даже повторяющимися. Вместо поля выбора можно иставить лишь идентификатор какого - либо типа, но в таком случае в программе невозможно будет узнать, каким из альтернативных полей используется память, а значит и то, значение какого типа там лежит, но это не всегда и нужно.

Пример:
Type
  Rec1 = Record
    A: Byte;
    B: Word;
  End;
  Rec2 = Record
    C: Longint;
    Case X: Byte Of
      1: (D: Word);
      2: (E: Record);
      Case Boolean Of
        3: (F: Rec1);
        3: (G: Single);
        '3': (C: Word);
      End;
    End;

Var
  2: Rec2
   . . . . . . . . . .
R.X: = 255;
If R.E.G = 0 Then
  Writeln (0K)
Else
  Writeln (R.E.G);

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

6 Совместимость и преобразования типов
Турбо-Паскаль - типизированный язык, следовательно, все применяемые операции определены только над операндами совместимых типов.
Два типа считаются совместимыми, если
• оба они есть один и тотже тип.
• один тип есть тип-диапазон второго типа.
• оба они являются типами-диапазонами одного и того же базового типа.
• один тип есть строка, а другой - строка или символ.
• оба они есть процедурные типы с одинаковым типом результата (для типа-функции), одинаковым количеством параметров и одинаковым типом взаимно соответствующих параметров.
В Турбо-Паскалевской программе данные одного типа могут преобразовываться в данные другого, явным или неявным образом.
При явном преобразовании используются специальные функции Ord, Trunc, Round, Chr, Ptr (преобразует четырёхбайтный целочисленный аргумент к типу-указателю).
Преобразование может достигаться применением идентификатора (имени) стандартного типа, или определённого пользователем типа, в качестве идентификатора функции преобразования к выражению преобразуемого типа (так называемое автоопределённое преобразование типов). Например, допустимы следующие вызовы функций:

Type Mytype = (A, B, C, D);
. . . . . . . . . . . . . . . . .
Mytype (2);
Integer (D);
Pointer (Longint (A) + $FF);
Char (127 Mod C);
Byte (K);
При автоопределённом преобразовании типа выражения может произойти изменение длины его внутреннего представления (уменьшение или увеличение).
В Турбо-Паскале есть ещё один явный способ: в ту область памяти, которую занимает переменная некоторого типа, можно поместить значение выражения другого типа, если только длина внутреннего представления вновь размещаемого значения в точности равна длине внутреннего представления переменной. С этой целью вновь используется автоопределённая функция преобразования типов, но уже в левой части оператора присваивания:

Type
  Byt = Array [1..2] Of Byte;
  Int = Array [1..2] Of Integer;
  Rec = Record
    X: Integer;
    Y: Integer;
  End;
Var
  VByt: Byt;
  VInt: Int;
  VRec: Rec;
Begin
  Byt (VInt[1])[2]:= 0;
  Int (VRec)[1]:= 256;
End.

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

• выражение из целых и вещественных приводится к вещественным
• одна и та же область памяти трактуется попеременно как содержащая данные то одного, то другого типа.
Совмещение данных может произойти при использовании записей с вариантами, типизированных указателей, содержащих одинаковый адрес, а также при явном размещении данных разного типа в одной области памяти (используется Absolute - за ним помещается либо абсолютный адрес, либо идентификатор ранее определённой переменной).
Абсолютный адрес - пара чисел, разделённых двоеточием - первое - сегмент, второе - смещение.
Пример:
B: Byte Absolute $0000:$0055;
W: Longint Absolute 128:0;
Если за Absolute указан идентификатор переменной, то происходит совмещение в памяти данных разного типа, причём первые байты внутреннего представления данных будут располагаться по одному и тому же абсолютному адресу:
Var
X: Real;
Y: Array [1..3] Of Integer Absolute X;

7 Типизированные константы
Описываются в разделе констант: <идентификатор> : <тип> = < значение >
В ходе выполнения программы можно присваивать другие значения. При повторном входе в блок (процедуру или функцию), в котором объявлена типизированная константа, переинициализации не происходит и она сохраняет то значение, которое имела при выходе из блока. Могут быть любого типа, кроме файлов. Нельзя так же объявить типизированную константу-запись, если хотя бы одно её поле файлового типа. Нельзя использовать в качестве значения при объявлении других констант или границ типа-диапазона.
Примеры:
1. Типизированные константы простых типов и типа String:
Type
Colors = (White, Red, Black);

Const
{Правильные объявления}
Cyrrcol: Colrs = Red;
Name: String = 'Ку-Ку';
Year: Word = 1989;
X: Real = 0.1;
Min: Integer = 0;
Max: Integer = 10;
Days: 1..31 = 1;
Answer: Char = 'Y';

{Неправильные объявления}
Mars: Arrray [Min..Max] Of Real;
A,B,C: Byte = 0;
X: Real = Pi;

Var
Namef: String [22] = 'Prog.Pas';

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

Type
Colors = (White, Red, Black);
Const
Colstr: Arrray [Colors] Of String [5] = ('White', 'Red', 'Black');
Vector: Array [1..5] Of Byte = (0, 0, 0, 0, 0);
При объявлении массива символов можно использовать то обстоятельство, что все символьные массивы и строки в Турбо- Паскале хранятся в упакованном формате,.поэтому в качестве значения массива-константы типа Char допускается указывать символьную строку:
Const
Digit: Array [0..9] Of Char = ('0','1','2','3','4','5','6','7','8','9');
Digchr: Aray [0..9] Of Char = ('0123456789');
При объявлении многомерных - множество констант, соответствующее каждому измерению заключается в дополнительные круглые скобки и отделяется от соседей множества запятыми.
Множество констант с максимальной глубиной вложения связывается с изменением самого правого индекса массива.
Пример - вывести на экран три строки с монотонно увеличивающимися целыми числами:
Var
  I, J, K, L: Integer;
Const
  Matr: Array [1..3, 1..5] Of Byte = ((0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13, 14));
  Cube: Array [0..1, 0..1. 0..2] Of Integer = (((0, 1, 2),(3, 4, 5)), ((6, 7, 8),(9, 10, 11)));
  Mas4: Array [0..1, 0..1, 0..1, 0..1] Of Word = ((((0, 1), (2, 3)), ((4, 5), (6, 7))), (((8, 9),
  (10, 11)), ((12, 13), (14, 15))));
Begin
  {Циклы и Writeln}
End.
Количество переменных в списке констант должно строго соответствовать объявленной длине массива по каждому измерению.

3. Типизированные константы-записи.
<идентификатор>:<тип> = (<список значений полей>)
<тип> - предварительно объявленный тип записи.
<список значений полей > - список из последовательностей следующего вида: имя поля, двоеточие и константа; элементы списка отделятся друг от друга точкой с запятой.
Пример:
Type
Point = Record
    X,Y: Real;
  End;
Vect = Array [0..1] Of Point;
Month = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
Date = Record
    D: 1..31;
    M: Month;
    Y: 1900..1999;
End;
Const
  Orign: Point = (X: 0; Y: -1);
  Line: Vector = ((X: -3.1; Y: 1.5), (X: 5.9; Y: 3.0));
  Someday: Date = (D: 16; M: Mar; Y: 1989);
Для записей с вариантными полями указывается только один из возможных вариантов констант:
Type
  Forma = Record
    Case Boolean Of
    True:
    (Place: String [40]);
    False:
    (Country: String [20];
    Port: String [20];
    Date: Array[1..3] Of Word;
    Count: Word)
  End;
Const
  Con1: Forma = (Country: 'Россия';
  Port: 'Москва';
  Date: (16,3,89);
  Count: 10);
  Con2: Forma = (Place: 'Петрозаводск');

4. Типизированные константы множества.
Значение типизированной константы множества задаётся в виде правильного конструктора множества:
Type
  Days = Set Of 1..31;
  Dige = Set Of '0'..'9';
  Error = Set Of 1..24;
Const
  Workdays: Days = [1..5, 8..12, 15..19, 22..26, 29, 30];
  Evendigits: Dige = ['0', '2', '4', '6', '8'];
  Errorflag: Error = [ ];

5. Типизированные константы указатели.
Единственным значением типизированной константы указателя может быть только Nil:
Const
Pr: ^Real = Nil;
P: POINTER = Nil;

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!

Динамическая память

Все глобальные переменные и типизированные константы размещаются в одной непрерывной области оперативной памяти, которая называется сегментом данных. Длина сегмента определяется архитектурой процессора 8086 и составляет 64 Килобайта (65536 байт), что может вызвать определённые трудности при описании и обработке больших массивов данных. С другой стороны объём стандартной памяти - 640 Килобайт. Выход - использовать динамическую память.

Динамическая память - это Оперативная память (ОЗУ) ЭВМ, предоставляемая Турбо-Паскалевой программе при её работе, за вычетом сегмента данных (64 К), стека (обычно 16 К) и собственно тела программы. По умолчанию Размер (Size) динамической памяти определяется всей доступной памятью ЭВМ и, как правило, составляет не менее 200 - 300 Кбайт.

Динамическую память обычно используют при:
1. обработке больших массивов данных;
2. разработке САПР;
3. временном запоминании данных при работе с графическими и звуковыми средствами
ЭВМ.

Размещение статических переменных в памяти осуществляется компилятором в процессе компиляции.
Динамические переменные - размещаются в памяти непосредственно в процессе работы программы. При динамическом размещении заранее неизвестны ни тип, ни количество размещаемых данных, к ним нельзя обращаться по именам, как к статическим переменным. Турбо-Паскаль представляет средство управления динамической памятью: указатели.

Указатель - это переменная, которая в хранит качестве своего значения адрес байта памяти.
В 8086 адреса задаются совокупностью двух шестнадцатиразрядных слов - сегмента и
смещения. Сегмент - участок памяти, имеющий максимальную длину 64 К и начинающийся к физического адреса, кратного 16 (то есть 0, 16, 32, 48 и т.д.). Смещение - указывает, сколько байт от начала сегмента нужно пропустить, чтобы обратиться по нужному адресу. Фрагмент памяти в 16 байт называется параграфом. Сегмент адресует память с точностью до параграфа, а смещение - с точностью до байта.

Каждому сегменту соответствует непрерывная и отдельно адресуемая область памяти. Сегменты могут следовать в памяти один за другим, или с некоторыми интервалами, или, наконец, перекрывать друг друга. Таким образом любой указатель по своей внутренней структуре представляет собой совокупность двух слов (типа Word), трактуемых как сегмент и смещение. Указатель адресует лишь первый байт типа данных.

Справка: процессор 8086.
8086 имеет 16 - битовые регистры, всего 14 штук, из них:

• 12 - регистры данных и адресов;
• 1 - указатель команд (регистр адреса команды);
• 1 - регистр состояния (регистр флагов).

Регистры данных и адресов делятся на три группы:
• регистр данных;
• регистр указателей и индексов;
• регистр сегментов.

Процессор 8086 всегда генерирует 20-ти бытовые адреса за счёт добавления 16-ти битового смещения к содержимому регистра, умноженному на 16:
физический адрес = смещение + 16 * регистр сегмента.
Вместо умножения на 16 содержимое регистра сегмента используется так, как если бы оно имело четыре дополнительных нулевых бита:
пусть:
   смещение = 10H
   регистр сегмента = 2000H
тогда:
0000000000010000(смещение)0010000000000000(0000)(номер блока)00100000000000010000(физический адрес)
физический адрес = 20010H

У 8086 адрес ячейки задаётся номером блока и смещением, что обусловлено тем, что команды 8086 и её данные должны располагаться в разных частях памяти (в разных сегментах). Если требуется адресоваться к данным, то потребуется адресация блока памяти, с которого начинается сегмент данных (из регистра сегмента данных) и позиция желаемой ячейки в этом сегменте (смещение).

В дополнение к области памяти 1 Мбайт, 8086 может адресоваться к внешним устройствам через 65536 (64 К) портов ввода-вывода. Имеются специальные команды ввода-вывода, позволяющие иметь непосредственный доступ к первым 256 (от 0 до 255) портам. Другие команды позволяют получить косвенный доступ к порту с помощью занесения идентифицирующего его номера (0 - 65535) в определенный регистр данных. Подобно ячейке памяти любой порт может быть 8 или 16- битовым.

Распределение памяти IBM PC.
• 16 - старших байт - команды начальной загрузки системы.
• Первые 1024 ячейки - вектора прерываний.

Типы прерываний.
Существуют 2 вида прерываний - одни можно игнорировать, другие обязательно обслужить как можно скорее.
8086 может распознать 256 различных прерываний, каждому из них однозначно соответствует код типа (целое число от 0 до 255). Код используется в качестве указателя ячейки в области памяти с младшими адресами (область векторов прерываний).

[LEFT]1. Объявление указателей[/LEFT]
Как правило, в Турбо-Паскале указатель связывается с некоторым типом данных (типизированные указатели).
Type
  PerPnt = ^PerRec;{указатель на переменную типа PerRec}
  PerRec = Record
    Name: String;
    Job: String;
    Next: PerPnt;
  End;
Var
  P1: ^Integer;
  P2: ^Real;
Внимание! При объявлении типа PerPnt мы сослались на PerRec, который ещё не был объявлен, это связано с тем, что существует исключение из правил для указателей, которые содержат ссылку на ещё неописанный тип данных. Это исключение сделано не случайно, так как динамическая память позволяет использовать организацию данных в виде списков (каждый элемент имеет в своём составе ссылку на соседний элемент - обратите внимание на поле Next).
В Турбо-Паскале можно объявлять указатель и не связывать его с конкретным типом данных:
Var
  PP: Pointer;
Указатели такого рода называют нетипизированными. В них удобно размещать данные, структура которых меняется по ходу работы.
В Турбо-Паскале можно передавать значения только между указателями, связанными с одним и тем же типом данных.

Var
  P1,P2: ^Integer;
  P3: ^Real;
  PP:Pointer;
Begin
  P1:= P2; {- верно}
  P1:= P3; {- неверно}
но можно сделать так:
  PP:= P3;
  P1:= PP;
так как ограничение не распространяются на нетипизированные указатели. Но подобные операции часто путают программиста и чреваты смысловыми ошибками.
[RIGHT][/RIGHT]
[LEFT]
2. Выделение и освобождение динамической памяти[/LEFT]
Вся динамическая память – пространство ячеек, называемое кучей. Физически куча располагается в старших адресах, сразу за программой. Указатель на начало кучи храниться в предопределенной переменной HeapOrg, конец - FreePtr, текущую границу незанятой динамической памяти указывает указатель HeapPtr. Для выделения памяти под любую переменную используется процедура New. Единственным параметром является типизированный указатель:

Var
  I,J: ^Integer;
  R: ^Real;
Begin
  New(I); {под I выделяется область памяти,}
  {адрес первого байта этой области помещается в I}
End.
После выполнения этого фрагмента указатель I приобретёт значение, которое перед этим имел указатель кучи HeapPtr, а HeapPtr увеличится на два (т.к. он типа Integer); New(R) - вызовет смещение указателя на 6 байт. После того как указатель приобрёл некоторое значение, то есть стал указывать на конкретный байт памяти, по этому адресу можно разместить значения соответствующего типа:
  I^:= 2;
  R^:= 2*Pi;
Допустима запись: R^:= Sqr (R^) + I^ - 17;
Но недопустима запись: R:= Sqr (R^) + I^ - 17; так как указателю R нельзя присвоить значение вещественного выражения.
Возврат динамической памяти обратно в кучу осуществляется оператором Dispose:
  Dispose(R);
  Dispose(I); - вернут в кучу, ранее забранные 8 байт.
  Dispose(Ptr) не изменяет значения указателя Ptr, а лишь возвращает в кучу память, связанную с этим указателем. Однако повторное применение процедуры к “свободному” указателю приведет к возникновению ошибки времени исполнения. Чтобы указать, что указатель свободен, нужно использовать зарезервированное слово Nil.
К указателям можно применять операции отношения, в том числе и сравнения с Nil:

Const
P:^Real = Nil;
. . . . . . . .
Begin
If P = Nil then
   New (P);
. . . . . . . .
Dispose(P);
P:= Nil;
End.
Использование указателей, которым не присвоено значение процедурой New или каким-либо другим способом, никак не контролируется системой и может привести к непредсказуемым результатам. Многократное чередование New и Dispose приводит к “ячеистой” структуре кучи. Дело в том, что все операции с кучей выполняется под управлением особой программы, которая ведёт учёт всех свободных фрагментов в куче. При выполнении оператора New( ) эта программа отыскивает минимальный свободный фрагмент, в котором может разместиться требуемая переменная. Адрес начала найденного фрагмента возвращается в указателе, а сам фрагмент или его часть нужной длины, помечаются как занятая часть кучи.
Можно освободить целый фрагмент кучи следующим образом:

1. Перед началом выделения динамической памяти значения указателя HeapPtr запоминается в переменной-указателе с помощью процедуры Mark.
2. Выполнение программы.
3. Освобождение фрагмента кучи от заполненного адреса до конца динамической памяти с использованием процедуры Release.
Var
P, P1, P2, P3, P4, P5: ^Integer;
Begin
New(P1);
New(P2);
New(P3);
New(P4);
New(P5);
Mark(P);
. . . . . . . .
Release (P);
End.
В этом примере процедурой Mark(P) в указатель P было помещено текущее значение HeapPtr, однако память под переменную не резервировалась.
Вызов Release уничтожает список свободных фрагментов в куче, созданных Dispose, поэтому совместное применение этих процедур не рекомендуется.
Для работы с нетипизированными указателями используются также процедуры GetMem(P, Size) и FreeMem(P, Size) - резервирование и освобождение памяти.
P - нетипизированный указатель, Size - Размер (Size).
За одно обращение к куче процедурой GetMem можно зарезервировать до 65521 байт. Освобождать нужно ровно столько памяти, сколько было зарезервировано, и именно с того адреса, с которого память была зарезервирована, иначе программа не будет работать и завершаться корректно!!!
Использование нетипизированных указателей даёт широкие возможности неявного преобразования типов:
Var
  i,j: ^Integer;
  r: ^Real;
Begin
  New (i); { I:= HeapOrg; HeapPtr:= HeapOrg+2 }
  j:= i; { J:= HeapOrg }
  j^:=2;
  Dispose (i); { HeapPtr:= HeapOrg }
  New (r); { R:= HeapOrg; HeapPtr:= HeapOrg+6 }
  r^:= Pi;
  WriteLn (j^);
End.
{Будет выведено: "8578"}
{здесь преобразование не имеет никакого смысла}
Примеры использования указателей.
Динамическая память - 200..300 Кбайт. Нужно разместить массив 100 * 200 типа Extended. Требуется 100 * 200 * 10 = 200000 байт. Пробуем:
Var
  i,j: Integer;
  PtrArr: Array[1..100, 1..200] of ^Extended.
Begin
. . . . . .
  For i:= 1 to 100 do
    For j:= 1 to 200 do
     New (PtrArr [i,j]);
. . . . . .
End.
Теперь к любому элементу можно обратиться: PtrArr[i,j]^:=...; Но длина внутреннего представления указателей 4 байта, поэтому потребуется ещё 100*200*4 = 80000 байт, что превышает Размер (Size) сегмента (65536 байт), доступный для статического размещения данных.
Можно было бы работать с адресной арифметикой (арифметикой над указателями), то есть не создавать массив указателей, а вычислять адрес элемента непосредственно перед обращением к нему. Однако в Турбо-Паскале над указателями не определены никакие операции, кроме присваивания и отношения. Но задачу решить можно:
Seg(x) - возвращает сегментную часть адреса.
Ofs(x) - возвращает смещение.
x - любая переменная, в том числе и та, на которую указывает указатель.
Далее с помощью Ptr(Seg, Ofs: Word): Pointer можно создать значение указателя, совместимое с указателем любого типа.
Таким образом, сначала с помощью GetMem забираем из кучи несколько фрагментов подходящей длины (не более 65521). Удобно по строкам 200 * 100 = 20000 байт. Начало каждого фрагмента запоминается в массиве PtrStr из 100 указателей. Теперь для доступа к любому элементу строки нужно вычислить смещение этого элемента от начала строки и сформировать указатель.
Var
  i,j: Integer;
  PtrStr: Array [1..100] of Pointer;
  Pr: ^Extended;
Const
  SizeOfExt = 10;
Begin
  For i:= 1 to 100 do
    GetMem (PtrStr, SizeOfExt*200);
. . . . . . . . . . . . . . . .
    Pr:= Ptr(Seg(PtrStr[i]^), Ofs(PtrStr[i]^) + (j - 1) * SizeOfExt);
    {Обращение к элементу матрицы [i,j]}
End;
далее работаем с Pr^:=. . . и т.д.
Полезно ввести две вспомогательных функции GetExt и PutExt. Каждая из них будет обращаться к функции вычисления адреса AddrE.
Program Demo;
Const
  SizeOfExt = 10;
  N = 100;
  M = 200;
Type
  ExtPoint = ^Extended;
Var
  i,j: Integer;
  PtrStr: Array[1..N] of Pointer;
  S: Extended;
  Function AddrE(i,j: Word): ExtPoint;
  Begin
    AddrE:= Ptr(Seg(PtrStr[i]^), Ofs(PtrStr[i]^) + (j - 1) * SizeOfExt);
  End;
  Function GetExt(i,j: Integer): Extended;
  Begin
   GetExt:= AddrE(i,j)^;
  End;
  Procedure PutExt(i,j: Integer; X: Extended);
  Begin
   AddrE(i,j)^:= X;
  End;
  Begin {main}
   Randomize;
   For i:=1 to N do
   Begin
    GetMem (PtrStr[i], M*SizeOfExt);
    For i:= 1 to m do
      PutExt(i, j, Random(255));
   End;
   S:= 0;
  For i:= 1 to N do
   For j:= 1 to M do
    S:= S + GetExt(i,j);
   WriteLn(S/(N*M));
End.
Мы предполагали, что каждая строка размещается в куче с начала границы параграфа и смещение каждого указателя PtrStr ровно 0. В действительности при последовательных обращениях к GetMem начало очередного фрагмента следует за концом предыдущего и может не попасть на границу сегмента. В результате при размещении фрагментов максимальной длины (65521 байт) может возникнуть переполнение при вычислении смещения последнего байта.
[RIGHT][/RIGHT]
[LEFT]
3. Процедуры и функции для работы с динамической памятью[/LEFT]
• Функция Addr - возвращает результат типа Pointer, в котором содержится адрес аргумента.
• Addr(X), x - любой объект программы. Возвращаемый адрес совместим с указателем любого типа. Аналогично операции @.
• Функция CSeg - возвращает значения хранящееся в регистре CS (в начале работы программы в CS содержится сегмент начала кода программы), результат CSeg - слово типа Word.
• Процедура Dispose(x) - возвращает в кучу фрагмент динамической памяти, зарезервированный за типизированным указателем x.
• Функция DSeg - возвращает значение хранящиеся в регистре DS (в начале работы в DS - сегмент начала данных программы), результат - типа Word.
• Процедура FreeMem - возвращает в кучу фрагмент динамической памяти, который ранее был зарезервирован за нетипизированным указателем. FreeMem(P, Size), P - нетипизированный указатель. Size - длина фрагмента, подлежащего освобождению.
• Процедура GetMem(P, Size) - резервирует память (за одно обращение не более 65521 байт), если нет свободной памяти - ошибка времени исполнения.
• Процедура Mark(Ptr) запоминает текущее значение указателя кучи HeapPtr. Ptr - указатель любого типа, в нём будет возвращено HeapPtr. Используется совместно с Release для освобождения части кучи.
• Функция MaxAvail - возвращает Размер (Size) (в байтах) наибольшего непрерывного свободного участка кучи. Результат типа LongInt. За один вызов New или GetMem нельзя зарезервировать значение большее, чем возвращаемое этой функцией.
• Процедура New(TP) - резервирует фрагмент кучи для размещения переменной. TP - типизированный указатель (за одно обращение не более 65521байт).
• Функция MemAvail - возвращает Размер (Size) (в байтах) общего свободного пространства кучи. Результат типа Longint.
• Функция Ofs(X) - возвращает значение типа Word, содержащее смещение адреса указанного объекта. X - выражение любого типа или имя процедуры.
• Функция Ptr(Seg, Ofs) - возвращает значение типа Pointer по заданному сегменту и смещению. Значение, возвращаемое функцией, совместимо с указателем любого типа.
• Процедура Release(Ptr) - освобождает участок кучи. Рtr - указатель любого типа, в котором сохранено процедурой Mark значение указателя кучи. Освобожденный участок кучи - от адреса в Ptr до конца. Одновременно уничтожается список свободных фрагментов, созданных по Dispose и FreeMem.
• Функция Seg(X) - возвращает значение типа Word, содержащее сегмент адреса указанного объекта.
• Функция SizeOf(X) - возвращает длину (в байтах) внутреннего представления указанного объекта. X - имя переменной, функции или типа.
Проблема потерянных ссылок
Работа с динамическими переменными через указатели требует большой тщательности и аккуратности при проектировании программ. В частности, следует стремиться освобождать выделенные области сразу же после того, как необходимость в них отпадает, иначе “засорение” памяти ненужными динамическими переменными может привести к быстрому ее исчерпанию.
Кроме того, необходимо учитывать еще одну проблему, связанную с противоречием между стековым принципом размещения статических переменных и произвольным характером создания и уничтожения динамических переменных. Рассмотрим следующий схематический пример программы:
Program LostReference;
Type
  PPerson = ^Person;
  Person = Record
. . . .
  End;

Procedure GetPerson;
Var
  Р: РРerson;
Begin
  P:= New(PPerson);
End;

Begin
  WriteLn(MemAvail);
  GetPerson;
  Writeln(MemAvail);
End.
Вызов New в процедуре GetPerson приводит к отведению памяти для динамической переменной типа Person. Указатель на эту переменную присваивается переменной Р. Рассмотрим ситуацию, возникающую после выхода из процедуры GetPerson. По правилам блочности все локальные переменные подпрограммы перестают существовать после ее завершения. В нашем случае исчезает локальная переменная Р. Но, с другой стороны, область памяти, отведенная в процессе работы GetPerson, продолжает существовать, так как освободить ее можно только явно, посредством процедуры Dispose. Таким образом, после выхода из GetPerson отсутствует какой бы то ни было доступ к динамической переменной, так как единственная "ниточка", связывавшая ее с программой - указатель Р - оказался потерянным при завершении GetPerson. Вывод на печать общего объема свободной памяти до и после работы GetPerson подтверждает потерю определенной области.
При проектировании программ, интенсивно использующих динамическую память, следует с особой внимательностью относиться к данной проблеме, так как Turbo Pascal, как, впрочем, и многие другие языки программирования, не имеет встроенных средств борьбы с засорением памяти неиспользуемыми динамическими переменными. Во всяком случае нужно придерживаться правила, согласно которому при выходе из блока необходимо или освободить все созданные в нем динамические переменные, или сохранить каким-то образом ссылки на них (например, присвоив эти ссылки глобальным переменным).
К описанной проблеме примыкает коллизия другого рода, заключающаяся в ситуации, когда некоторая область памяти освобождена, а в программе остался указатель на эту область. Рассмотрим следующий [i]пример:
Var
  P: Integer;

  Procedure X1;
  Var
    i: Integer;
  Begin
    i:= 12345;
    P:= @i;
    WriteLn(P^); { напечатает 12345 }
  End;

  Procedure X2;
  Var
    j: Integer;
  Begin
    j:= 7777;
    WriteLn(P^); { напечатает 7777, а не 12345 }
  End;

Begin
  X1;
  X2;
End;
В этом примере глобальная ссылочная переменная Р первоначально (в процедуре X1) устанавливается на локальную переменную i. После завершения процедуры X2 переменная i исчезает, указатель Р “повисает”. Вызов процедуры Х2 приводит к тому, что на место, локальной переменной i, будет помещена локальная переменная j, и указатель Р теперь ссылается на нее, что подтверждает результат второго вызова WriteLn.
Таким образом, смысл указателя Р зависит в данном случае не от семантики решаемой задачи, a от системных особенностей ее функционирования, что может привести к неожиданным эффектам. Аналогичные ситуации возможны при повторном использовании областей динамической памяти: если на освобожденную область остался указатель, то он может быть (по ошибке) использован после повторного выделения этой памяти для другой переменной, что опять- таки не будет "замечено" системой, но может сделать поведение программы непредсказуемым.

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!

Ключи и директивы компилятора

Позволяют управлять процессами компиляции программы. Директива представляет собой комментарий со специальным синтаксисом: начинается с {$, далее пишется имя директивы (одна или несколько букв) и параметры.

Турбо-Паскаль 7.0 допускает применение директив в любом месте программы, где допускается применение комментариев.

В Турбо-Паскале 7.0 существует три основных вида директив:

[LIST]
[*]Директивы - переключатели. С их помощью, указывая символ (+) или (-), можно разрешать или запрещать тот или иной режим.
[*]Директивы с параметрами. Позволяют задавать компилятору параметры, такие как имена подключаемых файлов, размеры памяти, выделяемые под определённую задачу, и так далее.
[*]Условные директивы. Позволяют организовывать так называемую "условную компиляцию" частей исходного текста, благодаря чему скомпоновать программу определённым образом.
[/LIST]Все директивы, кроме директив-переключателей, должны иметь по крайней мере один пробел между именем директивы и параметром.

Чтобы не прописывать директивы компилятора в тексте программы можно воспользоваться пунктом "Options" меню ИПО и далее подпунктом "Compiler". Но при этом все изменения будут иметь силу при всех последующих компиляциях других программ. Однако, если указать в исходном тексте какие-либо директивы, противоречащие установленным в ИПО, то последние будут проигнорированы. Это справедливо как для командно-строчного компилятора, так и для встроенного в ИПО.

[LEFT]1. Директивы-переключатели[/LEFT]
Различаются по диапазону своего действия на глобальные и локальные:
• Глобальные - влияют на ход компиляции и выполнение всей программы,
• локальные - только на определённую часть программы.
Глобальные директивы могут быть объявлены в разделе объявлений и соглашений прежде, чем будет использовано хотя бы одно из следующих зарезервированных слов: Uses, Label, Const, Type, Procedure, Function, Begin, а Локальные директивы могут быть объявлены в любом месте программы или программного модуля.
При необходимости можно сгруппировать комментарии из нескольких директив, разделённых запятой: {$A+, B-}.
Примечание: двойное нажатие комбинации Ctrl+O заставит редактор поместить в самое начало файла строки, содержащие текущую настройку среды в виде директив компилятора.
Директивы:
Выравнивание данных - (Word Align Data)
{$A+}
Тип глобальный. Делает возможным переключение между выравниванием на границу слова или байта. (Для 8086 выравнивание на границу слова игнорируется, однако для 80X86 выравнивание на границу слова означает более быстрое выполнение, поскольку адресация по всем элементам, имеющим Размер (Size) в слово (чётная адресация) происходит за один цикл вместо двух. {$A+} не влияет:
1. на переменные размером в байт,
2. на поля структур или элементы массивов.
Булевы вычисления (Complete Boolean Evaluation)
{$B+}
Тип локальный Может быть осуществлено два различных вида генерации кода для And и Or .При {$B-} генерируется код вычисления выражения, по короткой схеме (вычисления прекращаются сразу, как станет очевидным результат вычисления всего выражения).
Пример:
Function Fun(X: Integer): Boolean;
Begin
  X:= X + 1;
  Fun:= X > 10;
End;
. . . . . . . . . . .
Begin
  X:= 0;
  If False And Fun(X) Then
    X:= 10;
информация (info) для отладки (Debug Information)
{$D+}
Тип глобальный. Составляется таблица для отладчика, состоящая из N-строк для каждой процедуры, устанавливающая соответствующие адреса объектных кодов номерам строк исходного текста.
Отладочная информация (info) приводит к увеличению размера файла .TPU и требует дополнительного пространства при компиляции использующей модуль программы, но на Размер (Size) и скорость не влияет.
$D не будет работать в Турбо-Паскале 7.0 до тех пор пока не установить в меню или не задать параметр /V при запуске TPC.EXE.
Эмуляция сопроцессора. (Emulation).
{$E+}
Тип глобальный. В процессе генерации кода нет библиотеки, реализующей функции сопроцессора программы.
Дальний тип вызова (Force Far Calls).
{$F-}
Тип локальный, (Far) или (Near).
Генерация кода для 80286 (286 Instruction).
{$G-}
Тип локальный. При {$G-} генерируются инструкции 8086, такие программы могут работать на любой машине. Если {$G+}, то будут использоваться дополнительные инструкции 80286, которые позволяют генерировать более эффективный код, но не работают на 8086 и 8087. (Например команды Shr и Shl - расширенные).
Проверка ошибок ввода-вывода (I/O checking).
{$I+}
Тип локальный. Если {$I-}, то результат ввода-вывода может быть проанализирован с помощью функции IOResult.
информация (info) о локальных идентификаторах. (Local Symbols)
{$L+}
Тип глобальный. Используется в основном для модулей, дает возможность проверить и модифицировать локальные переменные модуля. Увеличивает Размер (Size) .TPU, на Размер (Size) и скорость работы выполняемой программы не влияет. В Турбо-Паскале 7.0 директива не будет работать до тех пор, пока в меню не будет Debuginfo или для TPC.EXE ключ /V.
Использование математического сопроцессора (8087/80287).
{$N-}
Тип глобальный. Позволяет осуществлять выбор генерируемых кодов для вычислений с плавающей запятой при “-“ реализуется программно, при ”+” - код для сопроцессора.
Примечание: если отсутствует сопроцессор и возникла необходимость в использовании специальных вещественных типов, нужно использовать {$E+}.
Использование оверлейных структур. (Overlays allowed).
{$O-}
Тип глобальный. Разрешает или запрещает генерацию оверлейного кода, то есть Турбо-Паскаль 7.0 может использовать модуль в качестве оверлейного, если он был скомпилирован с {$O+}. Задание данного режима компиляции не обязывает использовать данный модуль в качестве оверлейного. Директиву {$O+} почти всегда используют с {$F+}.
Использование в качестве параметров массивов открытого типа (Open parameters).
{$P-}
Тип глобальный.
Проверка переполнения при математических операциях (Overflow checking).
{$Q-}
Тип глобальный.
Проверка границ. (Range-Checking).
{$R-}
Тип локальный. Рекомендуется использовать R+ при отладке, а затем отключать так как “+” увеличивает Размер (Size) и замедляет работу программ. R+ осуществляет так же проверку виртуальных методов на состояние инициализации для экземпляра объекта, выполняющего вызов.
Проверка переполнения стека (Stack Checking)
{$S+}
Тип локальный. При “+” компилятор генерирует вначале каждой процедуры или функции код, который проверяет, достаточно ли в стеке выделено места для локальных переменных.
Использование типизированного адресного оператора @ (Typed @ operator).
{$T-}
Тип глобальный. Позволяет или запрещает использовать в тексте оператор @.
Проверка параметров переменных строкового типа (Strict Var String).
{$V+}
Тип локальный. Управляет проверкой типа при передачи строк в качестве параметров-переменных. В состоянии “+” выполняется строгая проверка типа. Требуется, чтобы формальный и фактический параметр имели идентичные строковые типы; при “-” длины могут не совпадать.
Расширенный синтаксис. (Extended Syntax).
{$X-}
Тип глобальный. При X+ вызов функции можно использовать как оператор, то есть результат функции может быть отброшен (функция может быть интерпретирована как процедура).
[RIGHT][/RIGHT]
[LEFT]
2. Директивы с параметрами[/LEFT]
Включение файла для компиляции (Include Directories).
{$I < имя файла >}
Тип локальный. Сообщает компилятору о необходимости включить в компиляцию названный файл. Текст файла вставляется сразу за директивой. Расширение по умолчанию .PAS. Турбо-Паскаль допускает одновременно не более 15 входных файлов. Значит допускается вложенность до 15-ти уровней. Так же включаемый файл не может указываться в середине раздела операторов. Это означает, что все операторы между Begin и End раздела операторов должны быть в одном файле.
Компоновка объектного файла. (Object Directories).
{$L < Имя-файла >}
Тип локальный. Предписывает компилятору использовать указанный файл (.Obj) при компоновке компилируемой программы или модуля.
Директива {$L} используется для компоновки кода Ассемблера для подпрограмм, описанных External.
Размеры выделяемой памяти (Memory Sizes).
{$M < Размер (Size) стека >, < Размер (Size) динамической области >}.
Тип глобальный. Размер (Size)-стека - целое число от 1024 до 65520. Для модуля Размер (Size)- стека игнорируется (модуль использует стек основной программы). Размер (Size) динамической области - целое число от 0 до 65360. Директива {$M} при использовании в Unit не оказывает влияния на компиляцию.
Компоновка оверлейного модуля.
{$O < Имя модуля >}
Тип локальный. Можно преобразовать обычный модуль в оверлейный. Игнорируется при попытке объявить её в теле какого-либо модуля. Директива должна указываться в тексте программы после слова Uses. Любой модуль, который указывается в качестве параметра, должен быть откомпилирован с директивами {$O+} и {$F+}.
[RIGHT][/RIGHT]
[LEFT]
3. Условные директивы[/LEFT]
Установить условие (Conditional Defines).
{$ Define < условие >}
Определяет условия, которые можно использовать в операторах условной компиляции.
Установить условие - значит с помощью данной директивы ввести некоторое слово, которое затем будет управлять компиляцией какого- либо фрагмента программы. За условием не должно следовать ничего кроме }.
Пример:
{$Define Debug}
. . . . . . . . . . . . . .
{$Ifdef Debug}
Writeln(‘Отладка’);
{$Endif}
Можно ввести несколько условий одновременно, причём условия должны отделяться друг от друга точкой с запятой (в меню).
Допускается использование развёрнутой формы операторов условной компиляции.
Пример:
{$Ifdef Demo}
  Code:= 1;
{$Else}
  Code:= 2;
  A:= ”Yes”;
{$EndIf}.
Операторы условной компиляции могут быть вложенными, что позволяет контролировать несколько условий одновременно.
Пример:
{$Ifdef Var1}
{$Ifdef Var2}
A: = N;
{$Else}
A: = 0;
{$Endif}
{$Endif}.

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!

Другие возможности Турбо-Паскаля

[LEFT]1. Внешние процедуры (функции)[/LEFT]
С помощью внешних процедур (функций) можно вызывать из Турбо-Паскалевой программы процедуры или функции, написанные на языке ассемблера и других языках. Машинно-ориентированный язык ассемблера предоставляет квалифицированному программисту богатейшие возможности использования всех особенностей архитектуры ПЭВМ. Ассемблерные программы выполняются значительно быстрее и занимают меньший объем памяти, чем Турбо-Паскалевые программы, однако низкий уровень языка существенно снижает производительность труда программиста и резко усложняет отладку программ, Как правило, на языке ассемблера пишутся сравнительно небольшие фрагменты программ, учитывающие особенности архитектуры ПЭВМ, которые невозможно использовать в Турбо- Паскалевой программе. Внешняя процедура (функция) в Турбо-Паскалевой программе объявляется заголовком, за которым следует зарезервированное слово ЕХТЕRNАL, например:
Function LoCase(ch: char): char; external;
Procedure Swapping(Var a, b; N: word); externa1;
Как видим, тело внешней процедуры (функции) отсутствует его заменяет кодовое слово ЕХТЕRNАL. Для подключения ассемблерной программы необходимо предварительно ее откомпилировать и получить OBJ - файл с перемещаемым кодом программы. Непосредственно перед описанием внешней процедуры (функции) в основной программе вставляется директива компилятора {$L < имя файла >}, где < имя файла > - имя OBJ - файла. Диск и каталог, в котором следует искать этот файл, если он не обнаружен в текущем каталоге, указывается опцией "OPTIONS/DIRECTORIES/OBJECT DIRECTORIES" ИПО.
Разумеется, в рамках этого пособия совершенно невозможно рассмотреть методику разработки программ на языке ассемблера - это предмет самостоятельной учебника. Тем не менее, следует дать один совет. Прежде чем браться за разработку ассемблерной процедуры, тщательно взвесьте специфические потребности разрабатываемой программы и возможности Турбо-Паскаля: может оказаться, что, оставаясь только в рамках Турбо-Паскаля, Вы решите задачу намного проще и быстрее, хотя, разумеется, Ваша программа и не будет оптимальной по скорости вычислений и расходуемой памяти. Замечено, что производительность труда программиста почти не зависит от языка и составляет 10...20 операторов отлаженной программы в день. Один оператор Турбо- Паскаля реализуется десятками машинных команд, вот почему использование языков высокого уровня, к которым относится Турбо- Паскаль, значительно ускоряет разработку программ.
Перед передачей управления внешней процедуре (функции) Турбо- Паскалевая программа заталкивает параметры обращения в программный стек в том порядке, как они перечислены в заголовке процедуры (функции). Ассемблерная процедура должна сохранить регистры BP, SP, SS и DS центрального процессора в самом начале своей работы и восстановить содержимое этих регистров перед возвратом управления в Турбо-Паскалевую программу. Остальные регистры можно не сохранять и соответственно не восстанавливать.
Параметры могут передаваться по ссылке или по значению. Если параметр передается по ссылке, в стек заталкивается указатель, содержащий абсолютный адрес параметра; если по значению - в стек заталкивается сам параметр, точнее - его значение. Параметры, объявленные в заголовке с предшествующим словом VAR, всегда передаются по ссылке. Параметры- значения могут передаваться по ссылке или по значению, в зависимости от длины внутреннего представления соответствующею параметра. В общем случае используется следующее правило: если длина внутреннего представления параметра-значения составляет 1, 2 или 4 байта, само значение параметра заталкивается в стек. Точно так же через стек передаются и все вещественные данные длиной в 4, 6, 8 и 10 байт (в версии 4.0 эти данные передаются через стек сопроцессора 8087/80287, в версии 5.0 - через стек центрального процессора 8086/80286). Во всех остальных случаях, если длина внутреннего представления больше 4 байт, соответствующий параметр передается по ссылке.
Ассемблерные функции должны возвращать результат с помощью регистров центрального процессора или сопроцессора в зависимости от длины внутреннего представления результата по следующим правилам:

• длиной в 1 байт - в регистре АL;
• длиной в 2 байта - в регистре АХ;
• длиной в 4 байта - в регистрах DХ:АХ (старшее слово в DХ);
• тип REAL (б байт) - в регистрах DХ:ВХ:АХ;
• типы SINGLE, DOUBLE, EXTENDED и COMP - через стек сопроцессора 8087/80287;
• указатели - в регистрах DХ:АХ (сегмент в DХ);
• строки возвращаются по ссылке: адрес начала строки помещается в DХ:АХ (сегмент в DХ).
Все ассемблерные процедуры должны размещаться в сегменте с именем СОDЕ, а имена процедур и функций должны быть объявлены директивой PUBLIC. Локальные переменные необходимо размещать в сегменте с именем DАТА. Все имена, объявленные в интерфейсной части модулей Турбо-Паскалевой программы, становятся доступны ассемблерной процедуре (функции) после их объявления директивой ЕХТRN.

[LEFT]2. Использование встроенных машинных кодов[/LEFT]
В Турбо-Паскале имеется возможность включения в программу фрагментов, написанных непосредственно в машинных кодах. Для этого используется зарезервированное слово INLINE, за которым в круглых скобках следует один или несколько элементов машинного кода, разделяемых косыми чертами. Элемент кода, в свою очередь, строится из одного или более элементов данных, разделенных знаками "+" или "-".
В качестве элемента данных может использоваться целая константа, идентификатор (переменной, константы или функции) или URL (ссылка) на счетчик адреса "*". Каждый элемент данных вызывает генерацию 1 или 2 байт кода программы. Значение этого кода получается сложением или вычитанием элементов данных в соответствии с разделяющим их знаком. Значением идентификатора переменной, константы, функции является адрес соответствующего объекта, значением ссылки на счетчик адреса является тот адрес, по которому будет размещаться следующий байт кода.
Элемент кода будет генерировать 1 байт кода, если этот элемент состоит только из целых констант и значение результата не превышает 1 байта, т.е. находится в диапазоне от 0 до 255. Если значение превышает 255 или элемент кода содержит ссылку на счетчик адреса, генерируются 2 байта. Знаки ">" и "<" могут использоваться для отмены автоматического выбора размера генерируемого кода. Если элемент кода начинается со знака "<", в код заносится только один младший байт, даже если само значение занимает 2 байта. Наоборот, если элемент начинается со знака ">", в код заносится 2 байта (старший байт может оказаться нулевым).
Значением идентификатора, как уже говорилось, является смещение соответствующего объекта. Если переменная. глобальная, смещение задается относительно сегмента данных, хранящегося в регистре DS, если переменная локальная, - относительно сегмента стека (регистр SР). Базовым сегментом типизированной константы является сегмент кода (регистр СS).
В следующем примере приводятся две короткие процедуры, с помощью которых можно вывести данные через любой порт ПЭВМ:
Function InPort(Port: Word): Word;
Var
pp: Word;
cc: Char;
Begin
pp:= port;
in1ine( {assembler code: }
$8b/$96/pp/ { MOV DX,pp[bp] }
$EC/ { IN AX,DX }
$88/$86/cc { MOV cc[bp],AX }
);
InPort:= ord(cc);
End;

Procedure OutPort(Port, Bt: Word);
Var
pp: Word;
cc: Char;
Begin
pp:=port;
cc:=chr(Bt);
in1ine(
$8a/$86/cc/ { MOV AX,cc[bp] }
$8b/$96/pp/ { MOV DX,pp[bp] }
$EE { OUT DX,AX }
);
END;
Операторы INLINE могут произвольным образом смешиваться с другими операторами Турбо-Паскаля, однако при выходе из процедуры (функции) содержимое регистров BP, SP, DS и SS должно быть таким же, как и при входе в нее.

[LEFT]3. Обращение к функциям операционной системы[/LEFT]
Турбо-Паскаль предоставляет программисту практически неограниченные возможности использования любых функций стандартной операционной системы PC DOS (MS DOS). При внимательном анализе материала этой книги Вы, очевидно, заметите, что большую часть составляет Описание (description) многочисленных библиотечных процедур и функций. Собственно язык Паскаль весьма прост и лаконичен, что, по мнению многих специалистов, и послужило одной из причин его широкого распространения. Значительная же часть библиотечных процедур и функций является по существу своеобразным интерфейсом между языковыми средствами Турбо-Паскаля и функциями операционной системы. Разумеется, можно только приветствовать усилия разработчиков Турбо-Паскаля по созданию мощных библиотек TURBO.TPL и GRAPH.TPU, однако ясно что таким способом невозможно запрограммировать все допустимые обращения к средствам ДОС. Вот почему в Турбо-Паскаль включены две процедуры, с помощью которых программист может сам сформировать вызов той или иной функции ДОС.
Следует учесть, что единственным механизмом обращения к функциям операционной системы является инициация программного прерывания. Прерывание - это особое состояние вычислительного процесса. В момент прерывания нарушается нормальный порядок выполнения команд программы, и управление передается специальной процедуре, которая входит в состав ДОС и называется процедурой обработки прерывания. Каждое прерывание характеризуется в рамках ДОС порядковым номером и связано со своей процедурой обработки. В архитектуре центрального процессора ПЭВМ предусмотрены прерывания двух типов: аппаратные и программные. Аппаратные прерывания создаются схемами контроля и управления ПЭВМ и сигнализируют операционной системе о переходе какого-либо устройства в новое состояние или о возникновении неисправности. Программные прерывания инициируются при выполнении одной из двух специальных команд (INТ или INТО) и служат для обращения к средствам ДОС.
Всего в ДОС имеется около 40 программных прерываний, каждое из которых может активизировать одну или несколько функций ДОС. Одно из прерываний - с номером 33 ($21 - шестнадцатиричное число) обеспечивает доступ к 85 функциям, а всего в ДОС имеется более 200 разнообразных функций.
Описываемые ниже процедуры входят в состав библиотечного модуля DOS и становятся доступными после объявления USES DOS. При возникновении программного прерывания в большинстве случаев необходимо передать процедуре обработки прерывания некоторые параметры, в которых конкретизируется запрос нужной функции. Эти параметры, а также выходная информация (info) передаются от программы к процедуре и обратно через регистры центрального процессора. В модуле DOS для этих целей определен специальный тип:
Type
Registers = record
Case integer of
0:(AX, BX, CX, 0X, BP, SI, DI, DS, ES, Flags: word);
1:(AL, AH, BL, BH, CL, CH, DL, DH: byte)
end;
Как видим, этот тип имитирует регистры центрального процессора и дает возможность обращаться к ним как к 16-битным или 8-битным регистрам.
С помощью процедуры INTR инициируется программное прерывание с требуемым номером; формат обращения: INTR(< N >, < регистры >)
Здесь < N > - выражение типа ВYТЕ, означающее номер прерывания;
< регистры > - переменная типа REGISTERS, в которой процедуре обработки прерывания передается содержимое регистров и возвращается выходная информация (info).
Так, прерывание с номером 18 ($12) возвращает в регистре AX объем оперативной памяти ПЭВМ. Пример программы выводящей на экран сообщение об этом объеме:
Program IntrDem;
Uses DOS;
Var
r: registers;
Begin
Intr($12, r);
writeln('Объем памяти = ', r.АХ, ' Кбайт')
END.
Процедура MSDOS.
Инициирует прерывание с номером 33 ($21);
формат обращения: MSDOS(< регистры >);
Здесь < регистры > - переменная типа REGISTERS, содержащая значения регистров на входе и выходе процедуры обработки прерывания.
Программное прерывание с номером 33 ($21) стоит особняком: как уже говорилось, оно дает доступ к большому количеству функций ДОС (этим прерыванием вызывается 85 функций). Рассматриваемая процедура полностью эквивалентна вызову процедуры INTR c номером прерывания 33. Программа примера выведет на экран версию операционной системы:

Program MsDosDemo;
Uses DOS;
Var
R: registers;
Begin
r.AH: = $30;
MsDos(r);
write1n ('Версия операционной системы: г.АL, '.', г.АН)
END.

[LEFT]4. Поддержка процедур обработки прерываний[/LEFT]
При написании процедур обработки прерываний существенными являются два обстоятельства. Во-первых, процедура обработки прерывания не должна искажать работу прерванной программы. Для этого необходимо сначала сохранить регистры центрального процессора, а перед выходом из процедуры - восстановить их. Во- вторых, процедура должна строиться по принципу реентерабельности (повторной входимости): ее работа может быть прервана в любой момент другими прерываниями и ДОС может обратиться к соответствующей функции до завершения обработки предыдущего прерывания.
Турбо - Паскаль предоставляет программисту возможность написать процедуру обработки прерывания на языке высокого уровня, хотя обычно такие процедуры пишутся на языке ассемблера.
Турбо-Паскалевая процедура обработки прерывания должна начинаться зарезервированным словом INTERRUPT (англ. прерывание), например:
Procedure IntProc(Flags, CS, IP, AX, BX, CX, DX, SI, DF, 0S, ES, BP: word); inerrupt;
begin
.......
end;
Список формальных параметров должен быть именно таким, как в примере: через эти параметры вызова все регистры прерванной программы становятся доступны процедуре обработки прерывания. Кодовое слово INTERRUPT приводит к генерации специальных машинных кодов, обеспечивающих заталкивание регистров в стек при входе в процедуру и извлечение их из стека перед выходом из нее.
При входе в процедуру:
push ax
push bx
push cx
push dx
push si
push di
push ds
push es
push bp
mov bp,si
sub sp,LocalSize
mov ax,SEG DATA
mov ds,ax

При выходе из процедуры:
mov sp,bp
pop bp
pop es
pop ds
pop di
pop si
pop dx
pop cx
pop bx
pop ax
irep
В самой процедуре обработки прерывания не рекомендуется обращение к другим функциям ДОС, так как некоторые из них, в том числе все функции ввода-вывода, нереентерабельны.
Для связи с любыми процедурами прерываний, а следовательно и с процедурами, написанными программистом, используются векторы прерываний - четырехбайтные абсолютные адреса точек входа в эти процедуры. Векторы прерываний располагаются в младших адресах оперативной памяти, начиная с нулевого адреса: прерывание номер 0 - по адресу 0, номер 1 - по адресу 1 * 4 = 4, номер N - по адресу N*4.
С помощью следующих двух процедур программист может прочитать содержимое любого вектора или установить его новое значение.
Процедура GETINTVECT. Возвращает вектор прерывания с указанным номером;
формат обращения GETINTVECT(< N >, < вектор >> )
Здесь < N > - выражение типа ВYТЕ, содержащее номер прерываиия;
< вектор > -переменная типа РOINTER, в которой возвращается адрес точки входа в процедуру обработки прерывания.
Пример: программа выводит на экран содержимое всех ненулевых векторов прерываний.
Uses DOS;
var
i: byte;
p: pointer;
Begin
for i:= 0 to 255 do
Begin
GetIntVec(i, p);
if (Seg(p^) <> 0) or (Ofs(p^) <> 0) then
write1n('N = ', i:3, 'Seg = ', Seg(p^):5, 'Ofs =', Ofs(p^):5);
End;
End.
Процедура SETINTVEC. Устанавливает новое значение вектора прерывания;
формат обращения SETINTVEC(< N >>, < адрес >);
Здесь < адрес > - выражение типа РOINTER , в котором задается адрес точки входа в процедуру обработки прерывания.
При нормальном завершении Турбо-Паскалевой программы она выгружается из памяти, что делает невозможным разработку резидентных в памяти процедур обработки прерываний. Вы можете прекратить работу программы и оставить ее в памяти, если воспользуетесь процедурой КЕЕР.
Процедура КЕЕР. Завершает работу программы и оставляет ее в памяти;
формат обращения КЕЕР(< код >)
< код > - выражение типа WORD, в котором содержится код завершения программы.
Код завершения представляет собой фактически единственный механизм передачи сообщений от запущенной программы к программе, которая ее запустила. Он может быть проанализирован в вызывающей программе с помощью функции DOSEXITCODE.
Функция DOSEXITCODЕ. Возвращает значение типа WORD - код завершения подчиненной программы.

[LEFT]5. Запуск внешних программ[/LEFT]
Из Турбо-Паскалевой программы можно запустить любую другую готовую к работе программу. Для этого используется процедура ЕХЕС из библиотечного модуля DOS;
формат обращения ЕХЕС(< имя >, < параметры >);
Здесь < имя > - выражение типа STRING, в котором задается имя файла с вызываемой программой;
< параметры > - выражение типа STRING, в котором передаются параметры вызова.
Имени запускаемой программы должен предшествовать путь к файлу. Параметры передаются запускаемой программе в виде текстовой строки и могут быть проанализированы ею с помощью двух следующих функций.
Функция PARAMCOUNT. Возвращает общее количество параметров вызова программы (значение типа WORD). Обращение PARAMCOUNT
Параметры вызова обычно следуют в командной строке ДОС сразу за именем вызываемой программы и отделяются от этого имени и друг от друга пробелами, например:
С:\ТURBO MyProg.Рas
C:\SIAM A:\Sistem.Sia
Здесь MyProg.Pas и A:\Sistem.Sia - параметры, передаваемые программам TURBO и SIAM.
При вызове программы непосредственно из среды Турбо-Паскаля ей можно передать параметры с помощью опции OPTIONS/PARAMETERS
Функция PARAMSTR Возвращает значение типа STRING, соответствующее нужному параметру вызова, формат обращения PARAMSTR(< N >)
Здесь < N > - выражение типа WORD, задающее порядковый номер параметра.
Использование процедуры ЕХЕС имеет ряд специфических особенностей. Прежде всего необходимо отметить, что сама Турбо- Паскалевая вызывающая программа остается резидентной в памяти, поэтому она не должна занимать всю оперативную память. Объем выделяемой программе памяти регулируется опцией OPTIONS/COMPILER/MEMORY SIZE или директивой компилятора {$M . . }. По умолчанию параметры этой опции таковы (0 и 655360 байт соответственно), что Турбо-Паскалевая программа занимает весь доступный объем памяти и вызываемая программа не будет загружена. Полезно включить в текст вызывающей программы директиву компилятора, в которой изменяются принятые по умолчанию размеры памяти. Это можно сделать, например, так:
{$М 2048, 0, 0}
Такая директива ограничивает используемую программой область стека объемом 2 Кбайт и исключает возможность использования в ней динамической памяти. Разумеется, Вы можете установить и другие значения параметров в этой директиве.
Далее, специфические особенности исполнения Турбо-Паскалевых программ требуют изменения стандартных значений некоторых векторов прерываний. К ним относятся векторы со следующими шестнадцатеричными номерами: $00, $02, $18, $23, $24, $34, $35, $36, $37, $38, $39, $3А, $3В, $3С, $3D, $3Е, $3F, $75.
Начальные значения этих векторов сохраняются в восемнадцати переменных с именами SAVEINTXX из библиотечного модуля SYSTEM, где ХХ -шестнадцатеричный номер прерывания. Поэтому непосредственно перед запуском внешней программы и сразу после возврата из нее рекомендуется вызвать библиотечную процедуру без параметров SWAPVECTORS, которая обменивает содержимое векторов прерывания и перечисленных переменных.
Пример: программа воспринимает с клавиатуры любую команду ДОС, затем вызывает командный процессор СОММАND.СОМ операционной системы и передает ему эту команду.
Program ExecDemo;
{$M 1024, 0, 0}
Uses DOS;
Var
st: string [79];
Begin
Write(‘Введите команду DOS:’);
Readln(st);
if st <> '' then
Begin
st:= 'C:\'+st,;
SwapVectors;
Exec(GetEnv('COMSPEC'), st);
SwapVectors;
End;
End.
Обратите внимание: для указания файла СОММАND.СОМ и пути к нему использовано обращение к библиотечной функции GETENV, с помощью которой можно получить параметры настройки операционной системы. В частности, параметр СОМSPЕС определяет спецификацию файла, содержащего командный процессор.
С помощью следующей несложной программы можно вывести на экран ПЭВМ список всех параметров настройки ДОС.
Program EnvParDemo;
Uses DOS;
Var
i: integer;
Begin
For i:= 0 To EnvCount Do
Writeln(EnvStr(i));
End.
Функция ENVCOUNT. Возвращает значение типа INTEGER, в котором содержится общее количество установленных в ДОС параметров. Обращение ENVCOUNT.
Функция ENVSTR. Возвращает значение типа STRING, содержащее имя и значение нужного параметра настройки операционной системы; формат обращения ENVSTR(< N >)
Здесь < N > - выражение типа INTEGER, в котором указывается номер параметра.
Эта функция возвращает строку вида NАМЕ = VАLUЕ, где NАМЕ - имя, а VALUE - значение соответствующего параметра настройки.
Функция GETENV возвращает значение типа STRING, в котором содержится параметр настройки ДОС; формат обращения GETENV (< имя >)
Здесь < имя > - выражение типа STRING, определяющее имя параметра.
Эта функция имеет параметр обращения NАМЕ и возвращает значение VALUE (см. функцию ENVSTR).

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!

Прямое обращение к памяти и портам ввода-вывода

В Турбо-Паскале имеется пять предварительно объявленных массивов: МЕМ, МЕМW, МЕМL, РОRТ и РОRТW. Первые три обеспечивают доступ к любому участку оперативной памяти по абсолютному адресу, два другие - доступ к портам ввода-вывода.
Компонентами массива МЕМ являются данные типа ВYТЕ, массива МЕМW - типа WORD, массива МЕМL - типа LONGINT. Обращение к элементам этих массивов, т.е. их индексация, имеет специальный вид: каждый индекс представляет собой абсолютный адрес и состоит из двух выражений типа WORD; первое дает сегментную часть адреса, второе - смещение; выражения разделяются двоеточием:
Mem[$0000:$1000]:= 0;
DataMem:= MemW[Seg(p):Ofs(p)];
MemLong:= MemL[64:i*SizeOf(rea1)];
Как следует из технического описания операционной системы МS DOS, в ПЗУ BIOS по адресу $F000:$FFFE зашит байт-идентификатор типа компьютера. Таким образом можно определить тип компьютера, на котором запускается программа:

Program DMA_Demo;
Begin
  Write('Тип компьютера: ');
  Case Mem[$FOOO:$FFFE] of
    $FF: writeln('PC');
    $FE: writeln('XT');
    $FD: writeln('PCjr');
    $FC: write1n('AT');
    $F9: writeIn('совместимый c PC');
  End
End.
Компонентами массива РОRТ являются байты, а массива РОRТW - слова. Индексами этих массивов должно быть выражение типа ВYТЕ, указывающее номер нужного порта. Присвоение значения элементу массива РОRТ или РОRТW приведет к записи в порт, упоминание элемента в выражении - к чтению из порта. Компоненты массивов РОRТ и РОRТW нельзя передавать в качестве параметров процедурам или функциям. Эти идентификаторы нельзя употреблять без индексных выражений.

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!

ТурбоПаскаль и объектно-ориентированное программирование
1. Основные определения типа <объект>
Начиная с версии 5.5, Турбо-Паскаль охватывает еще один современный метод проектирования программ, описанный выше как обьектно-ориентированное проектирование.
Объект - это структура данных, содержащая поля данных (подобно записи) различных типов и заголовки методов.
Синтаксис объявления объекта:
< ИмяПотомка > = Object(< ИмяПредка >)
                        поле;
                        ............
                        поле;
                        метод;
                        .............
                        метод;
                      End;
Метод - это процедура или функция, объявленные внутри объявления элемента типа объект и предназначенная в обычно для работы с полями этого объекта.
Формат обьявления Procedure <ИмяМетода>(<Параметры, как у процедуры>);
Метод имеет доступ к полям данных объекта, не требуя передачи их ему в виде параметров.
Объявление метода внутри объявления объектного типа содержит только заголовок. Тело метода определяется вне объявления объекта. Его заголовок должен содержать имя объекта, которому принадлежит метод.
Например:
Procedure Объект.Метод;
(< параметры >);
Begin
.......
.......
End;
Методы подразделяются на статические и виртуальные. Виртуальный метод отличается от статического тем, что реализующий его код подсоединяется к вызову не в процессе компиляции, а в процессе выполнения, что достигается так называемым поздним связыванием. Это дает возможность строить иерархию объектов с одинаковыми названиями методов, реализуемыми, однако, различными кодами.
Синаксис объявления виртуального метода: Procedure Метод(< параметры >); virtual;
Кроме обычных процедур и функций Турбо-Паскаль 6.0 реализует два специальных типа методов: конструктор и деструктор.
Конструктор - это специальный метод, инициализирующий объект, содержащий виртуальные методы, он объявляется специально зарезервированным словом constructor.
Синтаксис: constructor Init(< параметры >);
Конструктор инициализирует объект установлением связи между объектом и специальной таблицей виртуальных методов, содержащей адреса кодов, реализующих виртуальные методы. Конструктор может также использоваться для инициализации полей данных объекта.
Деструктор - это специальный метод, освобождающий память кучи от динамических объектов. Он объявляется с использованием специально зарезервированного слова destructor.
Синтаксис: destructor Done;

2. Основные свойства объектов
Основными отличительными свойствами объекта являются:

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

Инкапсуляция
Допустим, наши практические интересы лежат в области построения изображений тел звездном неба в двумерной проекции. Очевидно, что основой всякого изображения является положение (позиция) отдельного элемента на экране, описываемая координатами Х и У. Для задания двумерной позиции подходит тип запись, имеющйся в Турбо- Паскале.
Position = Record
Х: Integer;
Y: Integer;
End;
Что можно делать с парой координат (Х,У) ?
Во-первых, может потребоваться задать значения координат (в программировании такая процедура носит название инициализации). Создадим соответствующую процедуру:
Procedure Init(СоordХ, СооrdУ: Integer);
Begin
  Х:= СооrdX;
  Y:= СооrdY.,
End;
Во-вторых, нам может потребоваться знание фактических значений координат, для этом вводим две функции:
Function GetX: integer;
Begin
  GetX:= X;
End;
{---------------------------}
Function GetY: integer;
Begin
  GetY:= Y;
End;
По нашему замыслу процедура Init и функции GetХ и GetY должны работать только с полями записи Pozition. Введение объектов в Паскаль позволяет зафиксировать зто положение, объявив и поля и действия в одном месте:
Pozition = Object
X: Integer;
Y: Integer,

Procedure Init(CoordX, CoordY: Integer);
Function GetX: Integer;
Function GetY: Integer;
End;
Теперь для инициализации экземпляра типа Pozition достаточно вызвать его метод, как если бы он был полем записи:
Var
FirstPozition: Pozition;
...................
Begin
FirstPozition.Init(10,15);
...................
Метод задается так же, как и процедура в модуле: внутри объекта записывается заголовок (как в секции Interface модуля), при этом все поля, используемые методом, должны предшествовать ем объявлению. Определение метода (расшифровка действий) происходит вне объявления объекта. Имя метода должно предваряться названием типа объекта, которому метод принадлежит, сопровождаемым точкой.

Procedure Pozition.Init(CoordX, CoordY: Integer);
Begin
  X:= CoordX;
  Y:= CoordY;
End;
Заметим, что имена формальных параметров метода не могут совпадать с именами полей данных объекта.
Также как модуль защищает детали реализации процедур от пользователя, объект может защищать свои поля и методы. Для этом используется ключевое слово private (личный), Личные поля и методы доступны только внутри метода. Объявление выглядит следующим образом:

Type
ObjectNam = Object
поле;
..........
поле;
метод;
..........
метод;
private
ЧастноеПоле;
..........
ЧастноеПоле;
ЧастныйМетод;
..........
ЧастныйМеетод;
End;

Наследование
Рассмотрим звезду с координатами Х и У. Ее можно сделать видимой или невидимой, ей можно задать цвет, ее можно переместить.
Создадим объект с такими возможностями:
Star = Object
        X: Integer;
        Y: Integer;
        Procedure Init(CoordX, CoordY: Integer);
        Function GetX: Integer;
        Function GetY: Integer;
        Visible: Boolean;
        Color: Word;
        Procedure Init(CoordX, CoordY: Integer; InitColor: Word);
        Function IsVisible: Boolean;
        Procedure Show; { зажигает звезду }
        Procedure Blind; { гасит звезду }
        Procedure Jump(NextX, NextY: Integer); { перемещает звезду }
End;
Заметим, однако, что поля Х,У и методы GetХ, GetУ практически совпадают с соответствующими полями и методами обьекта Pozition. Турбо-Паскаль предоставляет возможность учесть эту ситуацию. Следует считать тип объекта Star порожденным типом Pozition, записав это следующим образом (наследование):
Star = Object(Pozition)
        Visible: Boolean;
        Color: Word;
        Procedure Init(CoordX, CoordY: Integer; InitColor: Word);
        Function IsVisible: Boolean;
        Procedure Show;
        Procedure Blind;
        Procedure Jump(NextX, NextY: Integer);
       End;
Объект Star теперь наследует свойства объекта Pozition. Поля Х,У явно не заданы в Star, но Star ими обладает благодаря наследованию, т.е. можно написать:
Star.X:=17;
Смысл обьектно-ориентированного программирования заключается именно в работе с полями объекта через его методы.

Полиморфизм
Давайте создадим объект "планета". Очевидно, что новый объект должен иметь предком объект Star, обладая всеми его свойствами, кроме того, быть "больше" по размеру (точнее - видимому размеру). Однако, даже начинающему программисту ясно, что нарисоавть на экране точку и закрашенную окружность не удастся одними и теми же командами.
Турбо-Паскаль разрешает сохранить потомку имя родительского метода, "перекрывая" его. Чтобы перекрыть родительский метод, нужно просто задать его с тем же именем, но с другим телом (кодом) и, если необходимо, с другим набором параметров. Такой метод делается виртуальным и к его объявлению добавляется слово virtual. Применение виртуальных методов налагает ограничения на процедуры инициализации, которые должны записываться с зарезервированным словом constructor и иметь общее имя Init.
Каждый отдельный экземпляр объекта должен инициализироваться с помощью отдельного вызова конструктора.
Для очистки и убирания динамически распределенных объектов существует специальная процедура - destructor Done.
Деструктор комбинирует шаг освобождения памяти в "куче" с некоторыми другими задачами. Метод деструктора может быть пустым, поскольку работу выполняет не только код тела, но и код, генерируемый Турбо-Паскалем в ответ на зарезервированное слово destructor.

Подпись автора

Кто продает?! - Мы продаем! Забиваем, продаем!!!