Целевая платформа

Изначально среда разработки Delphi была предназначена исключительно для разработки приложений Windows, затем был реализован вариант для платформ Linux (как Kylix), однако после выпуска в 2002 году Kylix 3 его разработка была прекращена, и вскоре было объявлено о поддержке Microsoft .NET, которая, в свою очередь, была прекращена с выходом Delphi 2007.

Наряду с поддержкой разработки 32 и 64-разрядных программ для Windows, реализована возможность создавать приложения для Apple Mac OS X (начиная с Embarcadero Delphi XE2), iOS (включая симулятор, начиная с XE4 посредством собственного компилятора), а также, в Delphi XE5, для Google Android (непосредственно исполняемые на ARM-процессоре).

Независимая, сторонняя реализация среды разработки проектом Lazarus (Free Pascal, компиляция в режиме совместимости с Delphi) позволяет использовать его для создания приложений на Delphi для таких платформ, как Linux, Mac OS X и Windows CE.

Также предпринимались попытки использования языка в проектах GNU (например, Notepad GNU) и написания компилятора для GCC (GNU Pascal).

Отличия от других языков программирования

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

Так, сложность объектного C++, по сравнению с C, выросла весьма существенно и затруднила его изучение в качестве первого языка программирования, чего нельзя сказать об Object Pascal относительно Pascal.

Ниже перечислены некоторые отличия синтаксических конструкций Delphi от семейства C-подобных языков (C/C++/Java/C#):

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

• В Delphi идентификаторы типов, переменных, а равно и ключевые слова читаются независимо от регистра: например идентификатор SomeVar полностью эквивалентен somevar. Регистро-зависимые идентификаторы в начале компьютерной эпохи ускоряли процесс компиляции, и кроме того, позволяли использовать очень короткие имена, порой отличающиеся лишь регистром.

И хотя к настоящему времени обе эти практики – использование нескольких идентификаторов, различающихся лишь регистром, равно как и чрезмерная их лаконичность, осуждены и не рекомендованы к применению, практически все унаследованные от С языки – C++, Java, C# − являются регистро-зависимыми, что, с одной стороны, требует достаточно большой внимательности к объявлению и использованию идентификаторов, а с другой — принуждает писать более строгий код, когда каждая переменная имеет чётко определённое имя (вариации регистра могут вызвать путаницу и ошибки).

• В Delphi в исходных файла pas (которые, как правило, и содержат основное тело программы) на уровне языковых средств введено строгое разделение на интерфейсный раздел и раздел реализации. В интерфейсной части содержатся лишь объявления типов и методов, тогда как код реализации в интерфейсной части не допускается на уровне компиляции. Подобное разделение свойственно также языкам C/C++, где в рамках культуры и парадигмы программирования вводится разделение на заголовочные и собственно

В C# и Java такое разделение утрачено вовсе – реализация метода, как правило, следует сразу же после его объявления. Инкапсуляция обеспечивается лишь принадлежностью метода к той или иной области видимости. Для просмотра одной только интерфейсной части модуля исходного кода используются специальные средства.

• В Delphi метод или функция четко определяются зарезервированными для этого ключевыми словами procedure или function, тогда как в C-подобных языках различие обуславливается ключевым словом, определяющим тип возвращаемого значения:

type

Tanimal = class abstract

protected

FpersonalName: string;

public

constructor Create(const PersonalName: string); virtual; abstract;

function GetSpecieName: string; virtual; abstract; //возвращает биологический вид животного

property Name: string read FpersonalName;

end;

TanimalClass = class of Tanimal; //метакласс, могущий ссылаться на любой класс, унаследованный от Tanimal

function CreateAnAnimal(const FactAnimalClass: TanimalClass; const Name: string): Tanimal;

begin

Result := FactAnimalClass.Create(Name); //Функция не знает, животное какого именно вида будет создано, хотя «кличка» известна. Конкретная реализация вида скрыта.

Кроме того, в отличие от C# и C++, где вызов конструктора базового класса непременно осуществляется ещё до входа в тело конструктора унаследованного класса, в Delphi этот вызов делается явно. Таким образом, его можно отложить или вовсе опустить в специальных целях. Очевидно, в отличие от C#, возможен контроль над исключениями в базовых конструкторах.

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

Таким образом, для динамического вызова из класса D метода класса A, переопределенного в B, потребуется выполнить поиск в таблицах методов классов D, A и B.

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

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

Также, Delphi допускает перекрытие любого конктретного виртуального метода базового класса абстрактным в классе-потомке:

type

TmyBase=class(Tobject)

function A():integer;virtual;//метод A имеет реализованное тело в разделе implementation

end;

TmyDerived=class(TmyBase)

function A():integer;override;abstract;//метод перекрыт как абстрактный, тела не имеет,

// и при этом перекрывает(скрывает) реализованный в базовом классе

End.

mВ отличие от C++, язык C# обладает унаследованной от Delphi концепцией свойств класса: псевдополей, которые, в ряде случаев, могут более интуитивно, по сравнению с методами, отражать, а также изменять состояние объекта.

Public class Date{//данный пример взят с [http://msdn.microsoft.com/en-us/library/w86s7x04.aspx msdn]

private int month = 7; // Backing store

public int Month{

get{return month;}

set{

if ((value > 0) && (value < 13)){ }

Аналогичный исходный текст на языке Delphi может выглядеть следующим образом:

type

Tdate = class

private

Fmonth: Integer;

protected

procedure SetMonth(const Value: Integer); //реализация в разделе implementation

public

property Month: Integer read Fmonth write SetMonth;

end;

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

Метод доступа в C# всегда относится к одному, и только к одному свойству, тогда как для Delphi это утверждение, вообще говоря, неверно. Более того, один и тот же метод может быть использован для реализации доступа к существенно различным свойствам:

type

Trectangle = class

private

Fcoordinates: array[0..3] of Longint;

function GetCoordinate(Index: Integer): Longint;

procedure SetCoordinate(Index: Integer; Value: Longint);

public

property Left: Longint index 0 read GetCoordinate write SetCoordinate;

property Top: Longint index 1 read GetCoordinate write SetCoordinate;

property Right: Longint index 2 read GetCoordinate write SetCoordinate; property Bottom: Longint index 3 readGetCoordinatewriteSetCoordinate;property Coordinates[Index: Integer]: Longint read GetCoordinate write SetCoordinate

Как Delphi, так и C# допускают использование индексируемых свойств: в этом случае синтаксис доступа к такому свойству аналогичен доступу к элементу массива. Однако, если в Delphi число индексируемых свойств, равно как и число индексаторов, может быть произвольным, в C# индексатор применим лишь к специальному свойству по умолчанию. Кроме того, в Delphi свойство по умолчанию не только может быть индексируемым, также оно может быть перегружено по типу индексатора:

TmyObject = class

protected

function getStr(Name: string): string; virtual;

function getStrByIx(Index: Integer): string; virtual;

function getBy2Indicies(X, Y: Integer): string; virtual;

public

property Value[Name: string]: string read getStr; default;

property Value[Index: Integer]: string read getStrByIx; default;

property Value[X, Y: Integer]: string read getBy2Indicies; default;

end;