Объектно-ориентированное программирование

Эта глава посвящена принципиально новым возможностям языка Pascal. В отличие от других расширений языка Pascal - строковых типов, модулей, оверлеев и т.д., которые представляют собой, в основном, технологические усовершенствования языка, не меняющие его природы, - введение объектовых типов означает достаточно радикальные изменения в самом подходе к программированию. Это, разумеется не означает, что традиционный подход к разработке программ теряет свое значение. Речь идет о согласованной совокупности новых принципов и понятий, позволяющих существенно повысить производительность труда программистов, сделать программы более компактными и легко расширяемыми.

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

10.1. Объекты. Основные понятия

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

Type Point = object

x,y:integer;

visible:boolean;

end;

Здесь для формирования структуры используется служебное слово Object, а содержимым объектового типа являются два поля целого типа и одно - булевского. (назначением такой структуры может быть хранение информации о положении некоторой точки на экране дисплея и о видимости этой точки). В дальнейшем введенный таким образом тип Point можно использовать в программе обычным образом: определять переменные этого типа (как статически - посредством описателя Var, так и динамически, создавая экземпляр переменной этого типа с помощью стандартной процедуры New), работать с полями и т.д.

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

Подпрограммы, определенные в объектовом типе, называются методами объекта (methods).

Технически определение подпрограмм в объектовых типах делается так: непосредственно в объектовом типе задаются только заголовки подпрограмм, а полные их описания должны быть заданы отдельно, причем имя подпрограммы-метода формируется из имени объектового типа - "хозяина", символа "точка" и имени подпрограммы, например:

Type Point = object

x,y:integer;

visible:boolean;

procedure Create(a,b:integer);

procedure SwitchOn;

procedure SwitchOff;

procedure Move(dx,dy:integer);

function GetX:integer;

function GetY:integer;

end;

Procedure Point.Create(a,b:integer);

begin

x:=a; y:=b; visible:=false

end;

Procedure Point.SwitchOn;

begin

visible:=true; PutPixel(x,y,GetColor)

end;

.........................

Function point.GetX:integer;

begin

Getx:x

end;

..........................

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

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

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

Var OnePoint:point;

и в дальнейшем оперировать с этим экземпляром посредством его методов:

OnePoint.Create(100,200);

OnePoint.SwichOn;

OnePoint.Move(20,-10);

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

with OnePoint do

begin

Create(100,200); SwitchOn; Move(20,-10)

end;

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

10.2. Наследование и переопределение

Следующее важное свойство объектовых типов позволяет при построении нового объектового типа использовать некоторый ранее определенный объектовый тип. Пусть, например, необходимо построить объектовый тип, управляющий простой геометрической фигурой - кругом - на экране дисплея. Ясно, что структура информации для определения круга очень похожа на описанную нами структуру для точки: здесь также необходимы поля X и Y для фиксации центра круга и логическое поле visible для определения видимости круга в текущий момент. Нужно еще добавить поле для хранения величины радиуса круга.

Традиционный стиль программирования допускает два решения.

Во-первых, можно ввести для круга совершенно новую структуру, повторив в ней (может быть, под другими именами) те же поля X, Y и visible и добавив новое поле Radius. Во-вторых, можно сконструировать структуру для круга, использовав в ней поле с типом, ранее определенным для точки (сделать структуру в структуре). Оба подхода вполне приемлемы, однако объектно-ориентированное программирование предлагает иной подход, который по ряду причин является гораздо более предпочтительным.

Объектно-ориентированный стиль позволяет определить новый объект как потомок другого ранее определенного типа. Это означает, что новый тип автоматически получает все поля и методы ранее введенного типа, который в этом случае называется предком или родительским типом. В этом случае в определении типа-потомка должно быть указано (в круглых скобках после служебного слова object) имя родительского типа:

Type Circle = object (Point)

Radius:integer

end;

Задание родительского типа означает, что в объектовом типе Circle неявно присутствуют все поля из типа Point: аналогично, для переменной этого нового типа доступны все методы из Point:

Var OneCircle:circle;

begin

OneCircle.Create(100,200);

OneCircle.Radius:=30;

.....................

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

Type Ring = object(Circle)

Radius2:integer;

end;

Тип Ring наследует поле Radius из своего непосредственного родителя Circle, а также поля и методы из типа Point, который также считается (косвенным) предком для Ring. Длина такой цепочки наследования никак не ограничивается.

Вернемся к примеру с объектовым типом Circle. По правилу наследования тип Circle имеет в своем составе методы объекта-предка Point. Однако, легко видеть, что если методы GetX, GetY, возвращающие текущие значения координат, вполне применимы в типе-потомке, то, например, методы SwitchOn, SwitchOff не подходят для рисования круга. Поэтому, наряду с новым полем Radius, полное описание типа Circle должно содержать также собственные методы для рисования и удаления круга и его передвижения по экрану. Самым простым решением было бы ввести в новый тип такие методы, дав им некоторые новые имена. Но объектно-ориентированный подход позволяет определить новые методы со старыми именами, переопределив тем самым методы типа-родителя:

Type Circle = object(Point)

Radius: integer;

procedure Create (a,b,R:integer);

procedure SwitchOn;

procedure SwitchOff;

procedure Move(dx,dy:integer);

function GetR:integer;

end;

Procedure Circle.Create (a,b,R:integer);

begin

Point.Create(a,b); Radius:=r

end;

Procedure Circle.SwitchOn;

begin

visible:=true; Graph.Circle(x,y,Radius)

end;

..........................

Function Circle.GetR:integer;

begin

GetR:=Radius

end;

..........................

Такое определение объектового типа Circle содержит следующие элементы:

· поля X,Y,visible, унаследованные от родительского типа Point;

· собственное поле Radius;

· метод Circle.Create, который инициализирует поля Circle. Этот метод переопределяет внутри типа Circle унаследованный от Point метод Point.Create. Для инициализации полей X,Y,visible используется вызов метода Point.Create, который доступен (унаследован) в типе Circle;

· методы Circle.SwitchOn, Circle.SwitchOff и Circle.Move, которые, соответственно рисуют и удаляют круг и передвигают его. Эти методы полностью переопределяют (замещают) одноименные методы из Point, что имеет очевидный смысл: для рисования круга требуется иной алгоритм, нежели для рисования точки; в примере для этих целей используются стандартные процедуры из модуля Graph. Так как стандартная процедура вывода круга также имеет имя Circle, то для ее однозначной идентификации используется составное имя Graph.Circle;

· новый (собственный) метод GetR для доступа к текущему значению радиуса круга;

· два унаследованных (и не переопределенных) метода GetX, GetY для получения текущих координат центра круга.

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

10.3. Виртуальные методы

В ряде случаев при описании тех или иных схожих объектов приходится писать методы, также схожие друг с другом и отличающиеся только отдельными деталями. Так, в рассматриваемом примере алгоритм метода Move для обоих типов весьма похож. Для того, чтобы переместить фигуру, достаточно удалить ее со старого места, изменить ее координаты и нарисовать эту же фигуру на новом месте. Это можно выразить следующим фрагментом:

Procedure Move (dx,dy:integer);

begin

SwitchOff; x:=x+dx; y:=y+dy; SwitchOn

end;

Возникает желание определить метод Move для объектового типа Point с тем, чтобы тип-потомок Circle унаследовал его без переопределения. Необходимо в этом случае обеспечить возможность для Move вызывать либо метод Point.SwitchOff, либо метод Circle.SwitchOff в зависимости от того, какой объект вызывает Move. Такой механизм называется динамическим (или поздним) связыванием и достигается введением виртуальных методов.

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

Type Point = object

.....

Constructor Create(a,b:integer);

procedure SwitchOn;virtual;

procedure SwitchOff;virtual;

procedure Move(dx,dy:integer);

.....

end;

Circle = object(Point)

.....

Constructor Create(a,b:integer);

procedure SwitchOn;virtual;

procedure SwitchOff;virtual;

.....

end;

Полные описания методов SwitchOn и SwitchOff в обоих типах остаются неизменными. Pascal обеспечивает вызов в процессе выполнения программы именно того виртуального метода, который определен для вызывающего объекта. Таким образом, один и тот же метод Move будет работать по-разному (передвигать различные фигуры) в зависимости от того, какой объект этот метод вызывает. Такое свойство называется полиморфизмом.

10.4. Конструкторы и деструкторы. Динамические объекты

Если объектовый тип содержит виртуальный метод, то он обязательно должен содержать хотя бы один особый метод, называемый конструктором; метод-конструктор должен быть применен до первого вызова виртуального метода. Синтаксически конструктор отличается от обычного метода тем, что вместо зарезервированного слова procedure используется зарезервированное слово constructor. Помимо действий, заданных в его теле, конструктор формирует необходимую информацию для последующих вызовов виртуальных методов объекта.

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

Var CirclePtr: ^Circle;

Begin

New(CirclePtr);

CirclePtr^.Create(100,200,35);

...............

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

New(CirclePtr, Create(100,200,35));

Освобождение динамической памяти, выделенной объекту, реализуется стандартной процедурой Dispose, также аналогично значениям других типов:

Dispose(PointPtr);

C освобождением памяти связаны методы-деструкторы, предназначенные для выполнения действий завершающего характера. Деструкторы оформляются заменой служебного слова Procedure на слово Destructor. В отличие от методов-конструкторов деструкторы могут быть виртуальными и могут наследоваться.

Использование деструкторов необходимо, если экземпляр объекта был создан динамически (процедурой New). В этом случае завершение работы нужно производить посредством расширенного вида процедуры Dispose, вторым параметром которой является вызов деструктора. Например, если PointPtr - указатель на экземпляр объектового типа Point, а Point.Done - деструктор этого типа, то можно совместить операцию освобождения памяти с завершающими действиями с экземпляром:

Dispose(PointPtr,Done);

10.5. Классы.

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

Описание нового класса похоже на описание новой структуры данных, только к полям (свойствам) добавляются методы — подпрограммы.

В Паскале для описания класса используется ключевое слово class. Type TMyClass = Сlass

Iteml: integer;

Item2: string;

function GetSum(n; integer): integer;

procedure Initializer-end;

При определении подпрограмм, принадлежащих конкретному классу, его методов, в заголовке подпрограммы перед ее названием явно указывается, к какому классу она принадлежит. Название класса от названия метода отделяют специальные символы (точка в Паскале или два двоеточия в Си++).

procedure TMyClass.Initialize;

begin Iteml:= 1; Item2:= "";

end;

Си++:

Класс — это тип данных, такой же, как любой другой базовый или сложный тип. На его основе можно описывать конкретные объекты (экземпляры классов).

var Cl, C2'. TMyClass;

Доступ к свойствам объектов и к их методам осуществляется так же, как к полям записей, через точку:

Cl.Iteml:= 5;

С2.Initialize;

х:= Cl.GetSum(21);

Объединение данных с методами в одном типе (классе) называется инкапсуляцией.

Важнейшая характеристика класса — возможность создания на его основе новых классов с наследованием всех его свойств и методов и добавлением собственных. Класс, не имеющий предшественника, называется базовым.

Например, класс «животное» имеет свойства «название», «размер», методы «идти» и «размножаться». Созданный на его основе класс «кошка» наследует все эти свойства и методы, к которым дополнительно добавляется свойство «окраска» и метод «пить».

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

В большинстве случаев методы базового класса у классов-наследников приходится переопределять — объект класса «кошка» выполняет метод «идти» совсем не так, как объект класса «амеба». Все переопределяемые методы по написанию (названию) будут совпадать с методами базового объекта, однако компилятор по типу объекта (его классу) распознает, какой конкретно метод надо использовать, и не вызовет для объекта класса «кошка» метод «идти» класса «животное». Такое свойство объек­тов переопределять методы наследуемого класса называется полиморфизмом.

Объектно-ориентированное программирование характеризуется тремя основными свойствами:

· инкапсуляция (incapsulation), т.е. объединение в одном объекте данных и действий над ними;

· наследование (inheritance) позволяет создавать иерархию объектов, начиная с некоторого простого (предка) и кончая более сложными, но включающими (наследующими) свойства предшествующих элементов (потомки);

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

Объектно-ориентированное программирование обладает рядом преимуществ при создании больших программ, к ним можно отнести:

· использование более естественных понятий (таких как объект), простота введения новых понятий;

· сокращение размера программ за счет того, что наследуемые свойства и действия можно не описывать многократно;

· возможность создания библиотеки объектов;

· сравнительно простая возможность внесения изменений в программу без изменения уже написанных частей;

· возможность написания подпрограмм с различными наборами формальных параметров, но имеющих одно и то же имя, используя свойство полиморфизма;

· более четкая локализация свойств и поведения объекта в одном месте, позволяющая проще разбираться со структурой программы, отлаживать ее, находить ошибки;

· возможность разделения доступа к различным объектам программы.

Однако следует иметь в виду, что объектно-ориентированное программирование обладает и рядом недостатков и эффективно не во всех случаях. Как правило, использование объектно-ориентированного программирования приводит к уменьшению быстродействия программы, особенно в тех случаях, когда используются виртуальные методы.

Неэффективно применение объектно-ориентированного програм-мирования к небольшим программам, оно ценно при создании больших программ, а лучше даже класса программ. Объектно-ориентированное программирование скорее не упрощает саму программу, а упрощает технологию ее создания.

Вопросы для самоконтроля

1. Как в Паскале определяется объектовый тип?

2. Для чего в языки программирования было введено понятие класса?

3. В чем различие между классом и объектом?

4. Поясните понятие инкапсуляции на бытовых примерах.

5. Для чего применяется механизм наследования?

6. Как полиморфизм модифицирует принцип наследования?

7. Опишите использование принципов объектно-ориентированного программирования в средах быстрого проектирования.

Приложение А

Коды клавиш ПК

Клавиша	10-й код	16-й код	Клавиша	10-й код	16-й код
			Й
			К		10a
			Л		10b
			М		10c
			Н		10d
			О		10e
			П		10f
			Р
			С
			Т
-		2D	У
=		3D	Ф
BkSp			Х
Tab			Ц
A			Ч
B			Ш
C			Щ
D			Ъ		14a
E			Ы		14b
F			Ь		14c
G			Э		14d
H			Ю		14e
I			Я		14f
J		6a	`
K		6b	~		7e
L		6c	[		5b
M		6d	]		5d
N		6e	;		3b
O		6f	‘
P			,		2c
Q			.		2e
R			/		2f
S			{		7b
T			}		7d
U			:
V			“		3a
W			<		3c
X			>		3t
Y			?		3f
Z		7a	\		5c
А			Down
Б			Left		4b
В			Right		4d
Г			Up
Д			Del
Е			End		4f
Ё			Home
Ж			Ins
З			PageUp
И			PageDown

Расширенные коды клавиш ПК

Клавиша	10-й код	16-й код	Клавиша	10-й код	16-й код
F1		3b	Alt+F1
F2		3c	Alt+F2
F3		3d	Alt+F3		6a
F4		3e	Alt+F4		6b
F5		3f	Alt+F5		6c
F6			Alt+F6		6d
F7			Alt+F7		6e
F8			Alt+F8		6f
F9			Alt+F9
F10			Alt+F10
F11			Alt+F11		8b
F12			Alt+F12		8c
Shift+F1			Alt+A		1e
Shift+F2			Alt+B
Shift+F3			Alt+C		2e
Shift+F4			Alt+D
Shift+F5			Alt+E
Shift+F6			Alt+F
Shift+F7		5a	Alt+G
Shift+F8		5b	Alt+H
Shift+F9		5c	Alt+I
Shift+F10		5d	Alt+J
Shift+F11			Alt+K
Shift+F12			Alt+L
Ctrl+F1		5e	Alt+M
Ctrl+F2		5f	Alt+N
Ctrl+F3			Alt+O
Ctrl+F4			Alt+P
Ctrl+F5			Alt+Q
Ctrl+F6			Alt+R
Ctrl+F7			Alt+S		1f
Ctrl+F8			Alt+T
Ctrl+F9			Alt+U
Ctrl+F10			Alt+V		2f
Ctrl+F11			Alt+W
Ctrl+F12		8a	Alt+X		2d
Alt+0			Alt+Y
Alt+1			Alt+Z		2с
Alt+2			Shift+Tab		0f
Alt+3		7a	Ctrl+Tab
Alt+4		7b	Alt+;
Alt+5		7c	Alt+’
Alt+6		7d	Alt+\		2b
Alt+7		7e	Alt+,
Alt+8		7f	Alt+.
Alt+9			Alt+/
Alt+ -			Alt+Bksp		0e
Alt+ –			Alt+Enter		1c
Alt+[		1a	Alt+Esc
Alt+]		1b	Alt+Tab		a5
Alt+up			Ctrl+down
Клавиша	10-й код	16-й код	Клавиша	10-й код	16-й код
Alt+down		a0	Ctrl+left
Alt+left		9b	Ctrl+right
Alt+right		9d	Ctrl+up		8d
Alt+Insert		a2	Ctrl+PrtSc
Alt+Delete		a3	Ctrl+End
Alt+Home			Ctrl+Home
Alt+End		9f	Ctrl+PageUp
Alt+PageUp			Ctrl+PageDown
Alt+PageDown		a1	Ctrl+ /
Alt+Enter		1c	Ctrl+ *
Alt+ /		a4	Ctrl+ -		8e
Alt+ *			Ctrl+ +
Alt+ -		4a	Enter		0c
Alt+ +		4e	Esc		1b

Приложение Б

Коды ошибок компиляции

1 – Out of memory (Выход за границы памяти);

2 – Identifier expected (Идентификатор отсутствует);

3 – Unknown identifier (Неизвестный /неописанный/ идентификатор);

4 – Duplicate identifier (Дважды использованный /описанный/ идентификатор);

5 – Syntax error (Синтаксическая ошибка, неверный символ);

6 – Error in real constant (Ошибка в вещественной константе);

7 – Error in integer constant (Ошибка в целочисленной константе);

8 – String constant exceeds line (Строковая константа превышает размеры строки);

9 – Too many nested files (Слишком много вложенных файлов);

10 – Unexpected end of file (Отсутствует конец файла);

11 – Line too long (Слишком длинная строка);

12 – Type identifier expected (Идентификатор типа отсутствует);

13 – Too many open files (Слишком много открытых файлов);

14 – Invalid file name (Неверное имя файла);

15 – File not found (Файл не найден);

16 – Disk full (Нет места на диске);

17 – Invalid compiler directive (Неверная директива компилятора);

18 – Too many files (Слишком много файлов участвуют в компиляции программы);

19 – Undefined type in pointer definition (Неопределенный тип в определении указателя);

20 – Variable identifier expected (Идентификатор переменной отсутствует);

21 – Error in type (Ошибка в определении типа);

22 – Structure too large (Структура слишком большая /структурир.тип/, размер не более 65535 байт);

23 – Set base type out of range (Базовый тип множества выходит за границы 0 до 255);

24 – File components may not be files or objects (Компоненты файла не могут быть файлами или объектами);

25 – Invalid string length (Неверная длина строки /длина в диапазоне 1 до 255/);

26 – Type mismatch (Несоответствие типов);

27 – Invalid subrange base type (Неверный базовый тип отрезка типа);

28 – Lower bound > than upper bound (Нижняя граница больше верхней);

29 – Ordinal type expected (Отсутствует порядковый тип);

30 – Integer constant expected (Отсутствует целочисленная константа);

31 – Constant expected (Отсутствует константа);

32 – Integer or real constant expected (Отсутствует целочисленная или вещественная константа);

33 – Pointer Type identifier expected (Отсутствует идентификатор типа указателя);

34 – Invalid function result type (Функция возвращает неверный тип);

35 – Label identifier expected (Отсутствует идентификатор метки);

36 – BEGIN expected (Отсутствует BEGIN);

37 – END expected (Отсутствует END);

38 – Integer expression expected (Отсутствует выражение типа Integer);

39 – Ordinal expression expected (Отсутствует выражение порядкового типа);

40 – Boolean expression expected (Отсутствует выражение типа Boolean);

41 – Operand types do not match (Типы операндов не соответствуют оператору);

42 – Error in expression (Ошибка в выражении);

43 – Illegal assignment (Неверное присваивааание);

44 – Field identifier expected (Отсутствует идентификатор поля);

45 – Object file too large (Объектный файл слишком велик /размер не должен превышать 64К/);

46 – Undefined EXTERN (Не определена внешняя процедура);

47 – Invalid object file record (Неверная запись объектного файла);

48 – Code segment too large (Сегмент кода слишком велик /размер не должен превышать 65К/);

49 – Data segment too large (Сегмент данных слишком велик /размер не должен превышать 65К/);

50 – DO expected (Отсутствует DO);

51 – Invalid PUBLIC definition (Неверное описание раздела PUBLIC);

52 – Invalid EXTRN definition (Неверное описание раздела EXTRN);

53 – Too many EXTRN definitions (Слишком много EXTRN описаний);

54 – OF expected (Отсутствует OF);

55 – INTERFACE expected (Отсутствует INTERFACE);

56 – Invalid relocatable reference (Недопустимая перемещаемая ссылка);

57 – THEN expected (Отсутствует THEN);

58 – TO or DOWNTO expected (Отсутствует TO или DOWNTO);

59 – Undefined forward (Не определено опережающее описание);

61 – Invalid typecast (Неверное преобразование типа);

62 – Division by zero (Деление на ноль);

63 – Invalid file type (Неверный файловый тип);

64 – Cannot read or write variables of this type (Переменные данного типа не могут быть считаны или выведены);

65 – Pointer variable expected (Отсутствует переменная ссылочного типа);

66 – String variable expected (Отсутствует переменная строкового типа);

67 – String expression expected (Отсутствует выражение строкового типа);

68 – Circular unit reference (циклическая ссылка на модуль);

69 – Unit name mismatch (Неверное имя модуля);

70 – Unit version mismatch (Несоответствие программных модулей /имя модуля не соответствует указанному в USES/);

71 – Internal stack overflow (Внутреннее переполнение стека);

72 – Unit file format error (Ошибочный формат файла модуля);

73 – Implementation expected (Отсутствует раздел Implementation);

74 – Constant and case types don't match (Типы констант и тип выражения селектора не соответствуют друг другу);

75 – Record or object variable expected (Отсутствует переменная комбинированного или объектного типа);

76 – Constant out of range (Размер константы превышает допустимый диапазон);

77 – File variable expected (Отсутствует переменная файлового типа);

78 – ¦Pointer expression expected (Отсутствует выражение указательного типа);

79 – Integer or real expression expected (Отсутствует целочисленное или вещественное выражение);

80 – Label not within current block (Метка не находится внутри текущего блока /для оператора GOTO/);

81 – Label already defined (Такая метка уже определена);

82 – Undefined label in preceding stmt part (Неописанная метка в обрабатываемом разделе операторов);

83 – Invalid @ argument (Неверный аргумент оператора @ /Действитедьными аргументами являются ссылки на переменные и идентификаторыпроцедур и функций/);

84 – UNIT expected (Отсутствует UNIT);

85 – ";" expected (Отсутствует “;”);

86 – ":" expected (Отсутствует “:”);

87 – "," expected (Отсутствует “,”);

88 – "(" expected (Отсутствует “(“);

89 – ")" expected (Отсутствует “)”);

90 – "=" expected (Отсутствует “=”);

91 – ":=" expected (Отсутствует “:=”);

92 – "[" or "(." expected (Отсутствует “[“ или “(“);

93 – "]" or ".)" expected (Отсутствует “]” или “)”);

94 – "." expected (Отсутствует “.”);

95 – ".." expected (Отсутствует “..”);

96 – Too many variables (Количество переменных превышает описанное);

97 – Invalid FOR control variable (Переменная данного типа не может использоваться в качестве параметра цикла FOR);

98 – Integer variable expected (Отсутствует целочисленная переменная);

99 – Files types are not allowed here (Файловый тип не может применяться в этом случае);

100 – String length mismatch (Недопустимая длина строки /Длина строковой константы не соответствует числу символьных компонент/);

101 – Invalid ordering of fields (Неверный порядок полей);

102 – String constant expected (Отсутствует строковая константа);

103 – Integer or real variable expected (Отсутствует целочисленная или вещественная переменная);

104 – Ordinal variable expected (Отсутствует переменная порядкового типа);

105 – INLINE error (Ошибка в операторе INLINE);

106 – Character expression expected (Предыдущее выражение должно иметь символьный тип);

107 – Too many relocation items (Количество перемещаемых элементов превышает допустимое);

108 – Overflow in arithmetic operation (Переполнение в арифметической операции

/-2147483648.. 2147483648/);

109 – No enclosing For, While or Repeat statement (Для процедур Break и Continue нет включающего оператора For, While или Repeat);

112 – CASE constant out of range (Константа селектора выходит за пределы допустимого диапазона);

113 – Error in statement (Ошибка в операторе);

114 – Cannot call an interrupt procedure (Невозможно вызвать процедуру прерывания);

116 – Must be in 8087 mode to compile (Для компиляции необходим режим сопроцессора 8087/80287);

117 – Target address not found (Адрес назначения не найден);

118 – Include files are not allowed here (Включаемые файлы недопустимы в этом случае);

119 – No inherited methods are accessible here (Наследуемые методы недопустимы в этом случае);

121 – Invalid qualifier (Неверный квалификатор);

122 – Invalid variable reference (Неверное описание переменной);

123 – Too many symbols (Количество идентификаторов превышает допустимое /64К/);

124 – tatement part too large (Раздел операторов превышает допустимое значение /24К/);

126 – Files must be var parameters (Файлы должны иметь параметры-переменные);

127 – Too many conditional symbols (Избыточное количество условных символов);

128 – Misplaced conditional directive (Пропущена условная директива);

129 – ENDIF directive missing (Пропущена директива ENDIF);

130 – Error in initial conditional defines (Ошибка в начальных условиях определения);

131 – Header does not match previous definition (Заголовок процедуры или функции не соответствует предварительному описанию);

133 – Cannot evaluate this expression (Данное выражение невозможно вычислить);

134 – Expression incorrectly terminated (Некорректное завершение выыражения);

135 – Invalid format specifier (Неверный спецификатор формата);

136 – Invalid indirect reference (Недопустимая косвенная ссылка);

137 – Structured variables are not allowed here (Структурная переменная не может быть использована в данном случае);

138 – Cannot evaluate without System unit (Вычисление невозможно без модуля System);

139 – Cannot access this symbol (Доступ к данному идентификатору отсутствует);

140 – Invalid floating-point operation (Неверная операция с плавающей точкой);

141 – Cannot compile overlays to memory (Невозможно выполнить компиляцию оверлеев в память);

142 – Pointer or procedural variable expected (Отсутствует аргумент типа переменной-указателя или процедурного типа);

143 – Invalid procedure or function reference (Недопустимая ссылка на процедуру или функцию);

144 – Cannot overlay this unit (Этот модуль не может быть оверлейным);

145 – Too many nested scopes (Слишком большая вложенность);

146 – File access denied (Нет доступа к файлу);

147 – Оbject type expected (Отсутствует объектный тип);

148 – Local object types are not allowed (Описание локальных объектныъ типов не разрешается);

149 – Virtual expected (Отсутствует Virtual для метода);

150 – Method identifier expected (Отсутствует идентификатор метода);

151 – Virtual constructors are not allowed (Методы конструкторов должны быть статическими, а не виртуальными);

152 – Constructor identifier expected (Отсутствует идентификатор конструктора);

153 – Destructor identifier expected (Отсутствует идентификатор деструктора);

154 – Fail only allowed within constructors (Fail допускается только внутри конструкторов);

155 – Invalid combination of opcode and operands (Недопустимая комбинация кода операции и операндов);

156 – Memory reference expected (Отсутствует ссылка на память);

157 – Cannot add or subtract relocatable symbols (Нельзя складывать или вычитать перемещаемые идентификаторы);

158 – Invalid register combination (Недопустимые комбинации регистров);

159 – 286/287 instructions are not enabled (Инструкции процессоров 286/287 не разрешены);

160 – Invalid symbol reference (Неверная ссылка на идентификатор);

161 – Code generation error (Ошибка генерации кода);

162 – ASM expected (Отсутствует ASM);

163 – Duplicate dynamic method index (Дважды вызывается индекс динамического метода);

164 – Duplicate resource identifier (Дублирование идентификатора ресурса);

165 – Duplicate or invalid export clause (Дублирующийся или недопустимый индекс экспорта);

166 – Procedure or function identifier expected (Отсутствует идентификатор процедуры или функции);

167 – Cannot export this symbol (Невозможно экспортировать данный идентификатор);

168 – Duplicate export name (Дублирование экспортированного имени);

169 – Executable file header too large (Заголовок выполняемого файла превышает 64К).

Фатальные ошибки

Фатальные ошибки всегда приводят к немедленному прекращению выполнения программы.

200 – Division by zero (Деление на ноль);

201 – Range check error (Ошибка при проверке границ);

202 – Stack overflow error (Ошибка переполнения стека);

203 – Heap overflow error (Переполнение динамически распределяемой памяти);

204 – Invalid pointer operation (Неверная операция ссылки);

205 – Floating point overflow (Переполнение при операции с плавающей точкой);

206 – Floating point underflow (Исчезновение порядка при операции с плавающей точкой);

207 – Invalid floating point operation (Недопустимая операция с плавающей точкой);

208 – Overlay manager not installed (Не установлена система управления оверлеями);

209 – Overlay file read error (Ошибка чтения оверлейного файла);

210 – Object not initialized (Объект не инециализиован);

211 – Call to abstract method (Вызов абстрактного метода);

212 – Stream registration error (Ошибка регистрации потока);

213 – Collection index out of range (Индекс метода Тcollection лежит вне диапазона);

214 – Collection overflow error (Ошибка переполнения набора);

215 – Arithmetic overflow error (Арифметическое переполнение);

216 – General Protection fault (Общее нарушение защиты при защищенном режиме).

Дата добавления: 2014-12-27