Delphi (язык программирования)

Материал из Википедии — свободной энциклопедии
Перейти к: навигация, поиск
Delphi
Класс языка:

императивный, структурированный, объектно-ориентированный

Появился в:

1995; последний выпуск 2014

Автор(ы):

Андерс Хейлсберг

Расширение файлов:

.pas, .dpr, .dpk, .pp

Релиз:

Delphi XE6 (2014)

Система типов:

статическая, сильная, безопасная (англ. Type safety)

Основные реализации:

Borland/Inprise/Codegear/Embarcadero Delphi; Borland Kylix; FreePascal

Испытал влияние:

Object Pascal, C++, C#

Сайт:

embarcadero.com/ru/products/delphi

Delphi (Де́лфи, произносится /ˈdɛlˌfi:/[1]) — императивный, структурированный, объектно-ориентированный язык программирования, диалект Object Pascal[2]. Начиная со среды разработки Delphi 7.0[3], в официальных документах Borland стала использовать название Delphi для обозначения языка Object Pascal. Начиная с 2007 года уже язык Delphi (производный от Object Pascal) начал жить своей самостоятельной жизнью и претерпевал различные изменения, связанные с современными тенденциями (например, с развитием платформы .NET) развития языков программирования: появились class helpers, перегрузки операторов и другое.

Целевая платформа[править | править вики-текст]

Изначально среда разработки 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) и написания компилятора[источник не указан 1877 дней] для GCC.

Философия и отличия от популярных прикладных языков программирования[править | править вики-текст]

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

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

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

  • В Delphi формальное начало любой программы четко отличается от других участков кода и расположено в определенном, единственном в рамках проекта, исходном файле с расширением dpr (тогда как другие файлы исходных текстов программы имеют расширение pas)
program Project32;
 
{$APPTYPE CONSOLE}
 
{$R *.res}
 
uses
  System.SysUtils;
 
begin
  try
    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

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

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

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

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

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

  • В Delphi метод или функция четко определяются зарезервированными для этого ключевыми словами procedure или function, тогда как в C-подобных языках обозначается лишь скобками:
//Delphi
procedure DoSomething(aParam:integer);//не возвращает значения
function Calculate(aParam1, aParam2:integer):integer;//возвращает целочисленный результат
//C#
void DoSomething(int aParam);//не возвращает значения
{
//code
}
int Calculate(int aParam1,aParam2);//возвращает целочисленный результат
{
//code
}

Тем сложнее в C#/C++ выглядят такие конструкции, как объявление типа "указатель на метод":

//C++: объявление типа pCalc, указателя на функцию-член, принимающую 2 целочисленных параметра, и возвращающию целочисленный результат
typedef int (TSomeClass::*pCalc)(int,int);

В вышеуказанном примере объявление типа отличается от объявления переменной ключевым словом typedef, имя типа, pCalc указывается в середине выражения, в скобках

//C#: объявление типа pCalc, указателя на функцию-член, принимающую 2 целочисленных параметра, и возвращающию целочисленный результат
public delegate int pCalc(int aParam1,aParam2);

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

//Delphi
type pCalc=function(aParam1, aParam2:integer):integer of object;

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

  • В Delphi начало и конец программного блока выделяются ключевыми словами begin и end, тогда как в C-подобных языках программирования для этих целей используются фигурные скобки: {}. Таким образом, в Delphi достигается лучшая читаемость кода, особенно для лиц с ослабленным зрением.
//C#
if (bVal){
//код, состоящий из нескольких инструкций
};
if (bVal2) /*код, состоящий из одной инструкции*/;

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

//Delphi
if bVal then begin
//код, состоящий из нескольких инструкций
end;
if bVal2 then (*код, состоящий из одной инструкции*);

В Delphi условное выражение всегда отделяется от следующей инструкции ключевым словом then, что избавляет от необходимости заключать условное в круглые скобки и чётче отделяет его от следующего за ним кода.

  • Подобно этому, в C-подобных языках, условное выражение цикла заключается в круглые скобки:
while (condition){//цикл с "предусловием"
//тело цикла
};
do{
//тело другого цикла
} while (condition2);//конец цикла с "постусловием", тело выполняется хотя бы однажды

В Delphi циклы с предусловием и постусловием разительно отличаются: конец цикла с постусловием нельзя принять за начало цикла с предусловием.

while condition do begin//условием продолжения цикла является истинность выражения, следующего за словом while, как C/C#
//тело цикла
end;
repeat//начало цикла с постусловием
//тело цикла
until not condition2;// истинность выражения, следующего за словом until - это условие ВЫХОДА из цикла, в отличие от C/C#
  • В Delphi операция присвоения значения переменной обозначается при помощи двоеточия со знаком равенства, :=, что является заимствованием из математической нотации. Знак равенства без двоеточия — это оператор проверки равенства, возвращающий булево значение. Напротив, в C-подобных языках оператором присваивания является одинарный знак равенства, а оператором проверки равенства — двойной, ==. В силу того, что в этих языках программирования присваивание является лишь выражением, возвращающим значение переменной слева, не так уж редки следующие неочевидные ошибки:
//C++
int iVal=12;
while (iVal=1){
//по замыслу программиста, данное тело цикла не должно выполнятся, если на входе iVal имеет значение, отличное от единицы
// однако в результате ошибочной замены знака == на одиночный =, iVal будет присвоено значение 1, а цикл окажется бесконечным
}

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

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

Язык C# принудительно объектен. Глобальные, без привязки к классу, функции запрещены. Value-типы, наподобие структур struct, унаследованы от общего типа C#, несмотря на то, что сами по себе они не могут быть унаследованы (то есть, наследование структур в C# запрещено). Вместе с тем, экземпляры классов C# являются неявно-ссылочными типами, как и в Delphi.

Поскольку системные вызовы в Windows (как, впрочем, и в POSIX-системах наподобие Linux, Mac OS) формально необъектны, взаимодействие C#-кода с ними затруднено даже без учёта разной парадигмы управления временем жизни переменных в памяти. Delphi не имеет подобных ограничений.

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

type TAnimal=class abstract
protected
fPersonalName:string;
destructor Destroy();
 
public
constructor Create(const personalName:string);virtual;abstract;
function getSpecieName():string;virtual;abstract;//возвращает биологический вид животного
property Name:string read fPersonalName;
end;
type TAnimalFactory= class of TAnimal;//метакласс, могущий содержать указатель на любой класс, унаследованный от TAnimal
 
function CreateAnAnimal(const fact:TAnimalFactory;const pName:string):TAnimal;
begin
result:=TAnimalFactory.Create(pName);//функция не знает, животное какого именно вида будет создано, хотя "кличка" известна. Конкретная реализация вида скрыта. 
end;

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

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

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

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

  • В отличие от 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)){
                month = value;
            }
        }//set
    }//prop
}//class

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

type
 TDate=class
    private
     FMonth:integer;
    protected 
     procedure setMonth(mnth:integer);//реализация в разделе implementation  
   public
   property Month:integer read FMonth write setMonth;
  end;

Прежде чем перейти к сравнению языковой реализации свойств, заметим, что сопоставление этих двух примеров наглядно показывает, что язык C# провоцирует, во-первых, злоупотребление фигурными скобками, и, во-вторых, нагромождение обязательных спецификаторов доступа к каждому члену класса; в Delphi однажды объявленный спецификатор применяется ко всем последующим членам. Также, если в 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 read GetCoordinate  write SetCoordinate;
        property Coordinates[Index: Integer]: Longint read GetCoordinate  write SetCoordinate;;
    end;

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

  TMyObject=class
    protected
    function getStr(name:string):string;virtual;
    function getStrByIx(ix:integer):string;virtual;
    function getBy2Indicies(X,Y:integer):string;virtual;
    public
    property Value[name:string]:string  read getStr;default;
    property Value[ix:integer]:string read getStrByIx;default;
    property Value[x,y:integer]:string read getBy2Indicies;default;//количество 
  end;

История языка[править | править вики-текст]

Object Pascal — результат развития языка Турбо Паскаль, который, в свою очередь, развился из языка Паскаль. Паскаль был полностью процедурным языком, Турбо Паскаль, начиная с версии 5.5, добавил в Паскаль объектно-ориентированные свойства, а в Object Pascal — динамическую идентификацию типа данных с возможностью доступа к метаданным классов (то есть к описанию классов и их членов) в компилируемом коде, также называемую интроспекцией — данная технология получила обозначение RTTI. Так как все классы наследуют функции базового класса TObject, то любой указатель на объект можно преобразовать к нему, после чего воспользоваться методом ClassType и функцией TypeInfo, которые и обеспечат интроспекцию.

Также отличительным свойством Object Pascal от С++ является то, что объекты по умолчанию располагаются в динамической памяти. Однако можно переопределить виртуальные методы NewInstance и FreeInstance класса TObject. Таким образом, абсолютно любой класс может осуществить «желание» «где хочу — там и буду лежать». Соответственно организуется и «многокучность».

Object Pascal (Delphi) является результатом функционального расширения Turbo Pascal[4].

Delphi оказал огромное влияние на создание концепции языка C# для платформы .NET.[источник не указан 846 дней] Многие его элементы и концептуальные решения вошли в состав С#. Одной из причин называют переход Андерса Хейлсберга, одного из ведущих разработчиков Дельфи, из компании Borland Ltd. в Microsoft Corp.

  • Версия 8 способна генерировать байт-код исключительно для платформы .NET. Это первая среда, ориентированная на разработку мультиязычных приложений (лишь для платформы .NET);
  • Последующие версии (обозначаемые годами выхода, а не порядковыми номерами, как это было ранее) могут создавать как приложения Win32, так и байт-код для платформы .NET.

Delphi for .NET — среда разработки Delphi, а также язык Delphi (Object Pascal), ориентированные на разработку приложений для .NET.

Первая версия полноценной среды разработки Delphi для .NET — Delphi 8. Она позволяла писать приложения только для .NET. Delphi 2006 поддерживает технологию MDA с помощью ECO (Enterprise Core Objects) версии 3.0.

В марте 2006 года компания Borland приняла решение о прекращении дальнейшего совершенствования интегрированных сред разработки JBuilder, Delphi и C++ Builder по причине убыточности этого направления. Планировалась продажа IDE-сектора компании. Группа сторонников свободного программного обеспечения организовала сбор средств для покупки у Borland прав на среду разработки и компилятор[5].

Однако в ноябре того же года было принято решение отказаться от продажи IDE-бизнеса. Тем не менее, разработкой IDE продуктов теперь будет заниматься новая компания — CodeGear, которая будет финансово полностью подконтрольна Borland.

В августе 2006 года Borland выпустил облегченную версию RAD Studio под именем Turbo: Turbo Delphi (для Win32 и .NET), Turbo C#, Turbo C++.

В марте 2008 года было объявлено о прекращении развития этой линейки продуктов.

В марте 2007 года CodeGear порадовала пользователей обновленной линейкой продуктов Delphi 2007 for Win32 и выходом совершенно нового продукта Delphi 2007 for PHP.

В июне 2007 года CodeGear представила свои планы на будущее, то есть опубликовала так называемый roadmap[6].

Embarcadero RAD Studio 2010

25 августа 2008 года компания Embarcadero, новый хозяин CodeGear, опубликовала пресс-релиз на Delphi for Win32 2009[7]. Версия привнесла множество нововведений в язык, как то[8]:

  • По умолчанию полная поддержка Юникода во всех частях языка, VCL и RTL; замена обращений ко всем функциям Windows API на юникодные аналоги (то есть MessageBox вызывает MessageBoxW, а не MessageBoxA).
  • Обобщённые типы, они же generics.
  • Анонимные методы.
  • Новая директива компилятора $POINTERMATH [ON|OFF].
  • Функция Exit теперь может принимать параметры в соответствии с типом функции.

Вышедшая в 2011 году версия Delphi XE2 добавила компилятор Win64 и кросс-компиляцию для операционных систем фирмы Apple (MacOS X, iOS).

Вышедшая в 2013 году версия Delphi XE5 обеспечила кросс-компиляцию приложений для устройств на платформе ARM/Android.

Компиляторы[править | править вики-текст]

  • Embarcadero Delphi (ранее наз. CodeGear Delphi и Borland Delphi) — наверное, самый известный компилятор, который является последователем Borland Pascal и Turbo Pascal. Используется Win16 (Delphi 1), Win32 (Delphi 2 и позже), Win64 (Delphi 16 (XE2) и позже), а также .NET 1.x, 2.0 (Delphi 8, Delphi 2005-Delphi 2007). Поддержка .NET впоследствии выделена в отдельный продукт, известный как Oxygene.
  • Free Pascal (FPC) — свободный компилятор Оbject Pascal, который поддерживает различные диалекты Паскаля, включая Turbo Pascal, Delphi и собственные диалекты. На текущий момент, FPC может генерировать код для x86, x86-64, PowerPC, SPARC и процессоров ARM, а также для различных операционных систем, в том числе для Microsoft Windows, Linux, FreeBSD, Mac OS. Существует несколько сред разработки программного обеспечения для FPC (один из самых известных представителей — Lazarus).
  • GNU Pascal (отдельно разработанная версия из GCC). Не ставит целью продолжение серии диалектов Delphi, как составляющей Паскаля, но тем не менее содержит режим совместимости Borland Pascal, и очень медленно приспосабливает компоненты языка Delphi. Не подходит для компиляции больших проектов, содержащих код Delphi, но стоит отметить, что его поддерживают большинство операционных систем и архитектур.
  • Oxygene (ранее известен как Chrome) — компилятор Object Pascal, который интегрирован в Microsoft Visual Studio. Также доступный в виде компилятора с вольной командной строкой CLI. Использует .NET и моно платформы. В настоящий момент продаётся под маркой Embarcadero Delphi Prism.
  • MIDletPascal — язык программирования с Delphi-подобным синтаксисом, и одноимённый компилятор, который преобразует исходный код в компактный и быстрый байт-код Java.
  • PocketStudio — основанная на Паскале, IDE для Palm OS.
  • Virtual Pascal — Бесплатный компилятор и текстовая IDE для Win32, OS/2 и Линукса. На тот момент очень быстрый и весьма совместимый (частично поддерживаются конструкции Delphi 5). Внешне очень похож на текстовую среду Borland Pascal 7, хотя отсутствует совместимая с ним графика, например. Однако разработка окончилась в 2004 году, а исходники открыты не были. С тех пор FPC ушёл намного вперед и в целом для программирования лучше он. Тем не менее, VP остаётся очень неплохим вариантом быстрой замены ещё более устаревших версий Borland Pascal для школы/института, учитывая родную работу в Win32 без проблем с русскими кодировками.

Синтаксис языка[править | править вики-текст]

Операторы[править | править вики-текст]

Список операторов через пробел: := + — * / div mod not and or with xor shl shr ^ = <> >= <= < > @ in is as

Выражения[править | править вики-текст]

Выражения в Object Pascal (Delphi) бывают арифметическими, логическими и строковыми.

Основные логические выражения:
Логические выражения в основном употребляются в условных операторах. К логическим выражениям относятся такие операции как:

  • not — «НЕ»
  • and — «И», умножение (пересечение) логических выражений (<логическое_выражение1> AND <логическое_выражение2>)
  • or — «ИЛИ», объединение логических выражений (<логическое_выражение1> OR <логическое_выражение2>)
  • xor — «Исключающее ИЛИ», оператор, дающий истину в случае истинности ровно одного из двух операндов (<логическое_выражение1> XOR <логическое_выражение2>)

Те же четыре оператора используются как бинарные для целочисленных типов. К битовым операторам целочисленных типов относятся также shl, shr — операторы логического сдвига.

По типу возвращаемого значения различаются операторы целочисленного деления ( div и mod ) и оператор /. Последний, применяемый как к целочисленным, так и к вещественным операндам, всегда в результате дает вещественный тип.

Операторы +, -, * — сложение, вычитание, пересечение — используются также для манипуляции со встроенным множественным типом. Для проверки вхождения элемента во множество предназначен специальный оператор in:

type TDayOfWeek=(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday);//задается тип перечислений
     TDays=set of TDayOfWeek;//задается тип множества
var 
    day:TDayOfWeek;
    days:TDays;
    isMyDay:boolean;//булевый тип
begin
 days:=[Sunday, Tuesday, Saturday];
 day:= Monday;
 isMyDay:= day in days; // оператор in возвращает булевое значение, принимая первым операндом значение типа "элемент множества", а вторым — значение типа "множество"
end;


Оператор сложения + используется также для конкатенации строк (когда используются встроенные строковые типы).

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

В Delphi оператор присваивания, :=, образует не выражение, а операцию, таким образом, не допускается "нанизывание" присваиваний.


Система типов[править | править вики-текст]

Система типов в Delphi строгая, статическая. Поддеживаются следующие типы данных:

  • целочисленные, знаковые, и беззнаковые: Byte, Shortint, Word, Smallint, Cardinal,Integer, UInt64, Int64
  • типы-перечисления, задаваемые пользователем
  • вещественные типы Single, Double, Extended(только x86-32), унаследованный тип Real, работающий в режиме целочисленной эмуляции. Тип Currency вещественное фиксированной точности.
  • строки. Тип string — автоматический распределяемый в памяти, с подсчетом ссылок и парадигмой Copy-On-Write. В поздних версиях Delphi символы двухбайтные, Unicode-совместимые. AnsiString — аналогичная реализация для строк с шириной символа в один байт. Такие строки содержат в служебном поле информацию о кодировке. В Windows компиляторах с ранних версий существует тип WideString, полностью совместимый типу BSTR в Component Object Model. Допускается использование примитивных строковых типов, в стиле языка C: PChar и PWideChar
  • массивы. Одномерные, многомерные фиксированной длины, а также подобные им динамические, с подсчетом ссылок.
  • множества, состоящие из элементов типа-перечисления. Максимальный размер такого перечисления - 256 элементов.
  • Записи. Структурный (value) тип без поддержки наследования. Начиная с Delphi 2006 добавлена поддержка инкапсуляции, методов, свойств. Перегрузка операторов.
  • Классы и обобщенные классы(generics). Поддержка инкапсуляции, наследования, полиморфизма, в том числе виртуальных конструкторов, атрибутов, обобщенных параметров для класса и отдельных методов, а также диспетчеризации методов по индексу. Класс может реализовать один или несколько интерфейсов, в том числе опосредованно, делегируя реализацию интерфейса свойству или полю. Множественное наследование не поддерживается. В Delphi класс является неявным ссылочным типом.
  • Типы-метаклассы, содержащие указатель на тип объекта(но не сам объект). В основном введены для реализации виртуальных конструкторов и автоматической сериализации.
  • интерфейсы. COM-совметимые(в Windows-компиляторе), унаследованные от одного предка. Множественное наследование не поддерживается.
  • Диспинтерфейсы, для работы с интерфейсами в режиме позднего связывания.
  • Вариантные типы[en] Variant и OleVariant
  • Старые объекты, поддерживаемые для совместимости с Turbo Pascal. В отличие от экземпляра класса, объект может быть размещен в стеке, или статически.

Объекты[править | править вики-текст]

Объекты как экземпляры класса объявляются в программе в разделе var как обычные переменные. Например:

var
  CCircle1: TColorCircle;
  CircleA: TCircle;

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

Классы[править | править вики-текст]

В языке Object Pascal классы — это специальные типы данных, используемые для описания объектов. Соответственно объект, имеющий тип какого-либо класса, является экземпляром (instance) этого класса или переменной этого типа.

Класс представляет собой особый тип, имеющий в своём составе такие элементы, как поля, свойства и методы. Поля класса аналогичны полям записи и служат для хранения информации об объекте. Методами называются процедуры и функции, предназначенные как правило для обработки полей. Свойства занимают промежуточное положение между полями и методами.

Объектно-ориентированные особенности языка[править | править вики-текст]

Инкапсуляция[править | править вики-текст]

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

Наследование[править | править вики-текст]

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

Полиморфизм[править | править вики-текст]

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

Примеры[править | править вики-текст]

Структура программы[править | править вики-текст]

Каждая написанная программа на языке Delphi состоит из заголовка программы (program NewApplication;), поля используемых модулей Uses (к примеру, Uses Windows, Messages, SysUtils и т. д.), который может не входить в саму структуру, а также блоков описания и исполнения (начинаются составным оператором begin и заканчиваются end.).

program Project1;                     // Заголовок программы, с её именем «Project1»
 
uses
  Forms,
  Unit1 in 'Unit1.pas' {Form1};       // модули, которые подключены к проекту и используются программой
 
{$R *.res}
 
begin
  Application.Initialize;                // Инициализация приложения
  Application.CreateForm(TForm1, Form1); // Создание формы/окна
  Application.Run;                       // Запуск и исполнение
end.

Пример № 1[править | править вики-текст]

Вывод сообщения «Hello, world!» в консольном приложении Delphi

program Helloworld;          //название программы
{$APPTYPE CONSOLE}           //директива компилятору о создании консольного приложения
begin
  writeln('Hello, world!');    //вывод сообщения Hello, world!
  readln;                    //ожидание нажатия клавиши пользователем
end.                         //конец программы

Пример № 2[править | править вики-текст]

Вывод сообщения «Hello, world!» в 32-разрядном GUI приложении Delphi

...
 
procedure TForm1.Button1Click(Sender: TObject); //Обработчик события OnClick, генерируемый автоматически
begin
  ShowMessage('Hello, world!');                  //вывод сообщения Hello, world!
end;                                           //конец процедуры
 
...

Пример № 3[править | править вики-текст]

Динамическое создание списка строк и запись его в файл.

// Обработчик события, происходящего при создании формы MainForm
procedure TMainForm.FormCreate(Sender: TObject);
var
  // Объявление переменной типа TStrings (список строк).
  Strings: TStrings;
begin
  // Создание (выделение памяти и заполнение её начальными значениями) объекта типа TStringList.
  // TStringList - это потомок TStrings, реализующий его абстрактные методы с целью хранения строк в памяти.
  Strings := TStringList.Create;
  try
    // Добавление строки.
    Strings.Add('Добавляемая строка.');
    // Сохранение всех строк в файл.
    Strings.SaveToFile('C:\Strings.txt');
  finally
    // Освобождение памяти объекта и очистка ссылки на неё для предотвращения непреднамеренного обращения к не выделенной памяти.
    FreeAndNil(Strings);
  end;
end;

Расширения файлов[править | править вики-текст]

  • .pas — исходный код модуля (pascal)
  • .dpr — исходный код проекта (pascal)
  • .dproj — исходный код проекта (xml)
  • .dproj.local — исходный код проекта (xml)
  • .dfm — исходный код формы
  • .dpk — скомпилированный пакет
  • .dcu — скомпилированный модуль
  • .exe — скомпилированное приложение
  • .res — ресурсы
  • .dsk — привязки к файлам
  • .identcache — кэшированные привязки к файлам

Известное программное обеспечение, созданное на Delphi[править | править вики-текст]

Среди многих распространённых программных продуктов, написанных на Delphi, можно найти[9]:

Примечания[править | править вики-текст]

  1. В Великобритании доминирует произношение «дел-фи́»: вариант произношения, характерный для Великобритании (англ.). Merriam-Webster Online Dictionary. Merriam-Webster. Проверено 1 октября 2008. Архивировано из первоисточника 21 августа 2011., а в США — «де́л-фай»: вариант произношения, характерный для США (англ.). Merriam-Webster Online Dictionary. Merriam-Webster. Проверено 1 октября 2008. Архивировано из первоисточника 21 августа 2011.
  2. Под таким названием он был разработан в фирме Apple в 1986 году группой Ларри Теслера.
  3. Delphi Language Overview
  4. Об этом говорят обозначения версий компилятора. Так, в Delphi 7 компилятор имеет номер версии 15.0 (последняя версия Borland Pascal / Turbo Pascal обозначалась 7.0, в Delphi 1 компилятор имеет версию 8.0, в Delphi 2 — 9.0 и т. д. Номер версии 11.0 носит компилятор Pascal, входивший в состав среды C++ Builder).
  5. Default Parallels Plesk Panel Page
  6. Delphi and C++Builder Roadmap
  7. Database Tools and Developer Software | Embarcadero Technologies
  8. Delphi from Embarcadero | RAD Application Development Software
  9. Good Quality Applications Built With Delphi — Delphi Programming (англ.)[неавторитетный источник?]

Литература[править | править вики-текст]

Ссылки[править | править вики-текст]