Сообщений 14    Оценка 115 [+2/-0]         Оценить

Программирование на языке Delphi

Глава 2. Основы языка Delphi

Авторы: А.Н. Вальвачев
К.А. Сурков
Д.А. Сурков
Ю.М. Четырько

Опубликовано: 12.11.2005
Исправлено: 10.12.2016
Версия текста: 1.0

В основе среды Delphi лежит одноименный язык программирования — Delphi, ранее известный как Object Pascal. При разработке программы среда Delphi выполняет свою часть работы — создает пользовательский интерфейс согласно вашему дизайну, а вы выполняете свою часть — пишите обработчики событий на языке Delphi. Объем вашей работы зависит от программы: чем сложнее алгоритм, тем тяжелее ваш труд. Необходимо заранее усвоить, что невозможно заставить средство разработки делать всю работу за вас. Некоторые задачи среда Delphi действительно полностью берет на себя, например создание простейшей программы для просмотра базы данных. Однако большинство задач не вписываются в стандартные схемы — вам могут понадобиться специализированные компоненты, которых нет в палитре компонентов, или для задачи может не оказаться готового решения, и вы вынуждены будете решать ее старым дедовским способом — с помощью операторов языка Delphi. Поэтому мы настоятельно рекомендуем вам не игнорировать эту главу, поскольку на практике вы не избежите программирования. Мы решили изложить язык в одной главе, не размазывая его по всей книге, чтобы дать вам фундаментальные знания и обеспечить быстрый доступ к нужной информации при использовании книги в качестве справочника.

2.1. Алфавит

2.1.1. Буквы

Изучая в школе родной язык, вы начинали с букв, слов и простейших правил синтаксиса. Для постижения основ языка Delphi мы предлагаем вам сделать то же самое.

Текст программы на языке Delphi формируется с помощью букв, цифр и специальных символов.

Буквы — это прописные и строчные символы латинского алфавита и символ подчеркивания:

a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z _

Цифры представлены стандартной арабской формой записи:

0 1 2 3 4 5 6 7 8 9

Специальные символы

+ - * / = < > [ ] , . : ; ' ( ) { } @ # $ & ^

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

<>  <=  >=  ..  (.  .)  (*  *)  //  :=

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

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

2.1.2. Числа

Одно и то же число можно записать самыми разными способами, например:

15           { целое }
15.0         { вещественное с фиксированной точкой }
1.5E01       { вещественное с плавающей точкой }
$F           { шестнадцатиричное }

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

Целые числа состоят только из цифр и знака + или –. Если знак опущен и число не равно 0, то оно рассматривается как положительное, например:

0            { 0 интерпретируется как целое число }
17           { положительное целое число }
-39          { отрицательное целое число  }

Вещественные числа содержат целую и дробную части, разделенные точкой:

0.0          { 0 интерпретируется как вещественное число }
133.5        { положительное вещественное число }
-0.7         { отрицательное вещественное число  }

Вещественные числа могут быть представлены в двух формах: с фиксированной и плавающей точкой.

Форма с фиксированной точкой совпадает с обычной записью чисел, например:

27800        { точка в конце числа опущена }
0.017	
3.14	

Форма с плавающей точкой используется при работе с очень большими или очень малыми числами. В этой форме число, стоящее перед буквой E, умножается на 10 в степени, указанной после буквы E:

7.13E+14     { 7.13 x 1014 }
1.7E-5       { 1.7 x 10-5 }
3.14E00      { 3.14 x 100 = 3.14}

Число, стоящее перед буквой E, называется мантиссой, а число после буквы E — порядком.

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

2.1.3. Слова-идентификаторы

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

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

Все идентификаторы подразделяются на зарезервированные слова, стандартные директивы, стандартные идентификаторы и идентификаторы программиста.

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

        and
        as
        asm
        array
        begin
        case
        class
        const
        constructor
        destructor
        dispinterface
        div
        do
        downto
        else
        end
        except
        exports
        file
        finally
        finalization
        for
        function
        goto
        if
        implementation
        in
        inherited
        inline
        initialization
        interface
        is
        label
        library
        mod
        nil
        not
        object
        of
        or
        out
        packed
        procedure
        program
        property
        raise
        record
        repeat
        resourcestring
        set
        shl
        shr
        string
        then
        threadvar
        to
        try
        type
        unit
        until
        uses
        var
        while
        with
        xor
      

Стандартные директивы интерпретируются либо как зарезервированные слова, либо как идентификаторы программиста в зависимости от контекста, в котором используются. Вот они:

        absolute
abstract
assembler
at
automated
cdecl
default
dispid
dynamic
export
external
far
forward
index
message
name
near
nodefault
on
overload
override
pascal
private
protected
public
published
read
register
reintroduce
resident
stdcall
stored
virtual
write

      

Стандартные идентификаторы — это имена стандартных подпрограмм, типов данных языка Delphi, т.д. В качестве примера приведем имена подпрограмм ввода и вывода данных и нескольких математических функций. Вы, без сомнения, сами угадаете их назначение:

Read    Write    Sin    Cos    Exp    Ln

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

LowProfit	AverageProfit	HighProfit
Price_One	Price_Two	Price_Sum

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

2.1.4. Комментарии

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

        { Любой текст в фигурных скобках }
        (* Любой текст в круглых скобках со звездочками *)
        // Любой текст от двойной наклонной черты до конца строки
      

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

        {$OPTIMIZATION ON}
        {$WARNINGS ON}
        {$RANGECHECKS OFF}
      

2.2. Данные

2.2.1. Понятие типа данных

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

Тип данных показывает, какие значения принимают данные и какие операции можно с ними выполнять. Каждому типу данных соответствует определенный объем памяти, который требуется для размещения данных. Например, в языке Delphi существует тип данных Byte. Данные этого типа принимают значения в целочисленном диапазоне от 0 до 255, могут участвовать в операциях сложения, вычитания, умножения, деления, и занимают 1 байт памяти.

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

• простые типы данных. Они в свою очередь подразделяются на порядковые и вещественные типы данных. К порядковым типам относятся целочисленные, символьные, булевские, перечисляемые и интервальные типы данных;
• временной тип данных. Служит для представления значений даты и времени;
• строковые типы данных. Служат для представления последовательностей из символов, например текста;
• составные типы данных (в некоторых источниках — структурированные типы данных). Формируются на основе всех остальных типов. К ним относятся массивы, множества, записи, файлы, классы и ссылки на классы;
• процедурные типы данных. Позволяют манипулировать процедурами и функциями как данными программы;
• указательные типы данных. Данные этих типов хранят адреса других данных, с их помощью организуются различные динамические структуры: списки, деревья и т.д.;
• тип данных с непостоянным типом значений. Служит для представления значений, тип которых заранее неизвестен; с его помощью легко организуется работа со списком разнотипных значений;

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

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

2.2.2. Константы

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

        const
  DelphiLanguage = 'Object Pascal';
  KylixLanguage = DelphiLanguage;
  Yard = 914.4;
  Foot = 304.8;

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

Значение константы можно задавать и выражением. Эту возможность удобно использовать для комплексного представления какого-либо понятия. Например, временной промежуток, равный одному месяцу, можно задать так:

        const
  SecondsInMinute = 60;
  SecondsInHour = SecondsInMinute * 60;
  SecondsInDay = SecondsInHour * 24;

Очевидно, что, изменив базовую константу SecondsInMinute, можно изменить значение константы SecondsInDay.

При объявлении константы можно указать ее тип:

        const
  Percent: Double = 0.15;
  FileName: string = 'HELP.TXT';

Такие константы называются типизированными; их основное назначение — объявление константных значений составных типов данных.

2.2.3. Переменные

Переменные в отличие от констант могут неограниченное число раз менять свое значение в процессе работы программы. Если в начале программы некоторая переменная X имела значение 0, то в конце программы X может принять значение 10000. Так бывает, например, при суммировании введенных с клавиатуры чисел.

Переменные описываются с помощью зарезервированного слова var. За ним перечисляются идентификаторы переменных, и через двоеточие указывается их тип. Каждая группа переменных отделяется от другой группы точкой с запятой. Например:

        var
  Index: Integer;        // переменная целого типа данных
  FileName: string;      // переменная строкового типа данных
  Sum, Profit: Double;   // группа переменных вещественного типа данных

В теле программы переменной можно присвоить значение. Для этого используется составной символ :=, например:

Sum := 5000.0;           // переменной Sum присваивается 5000
Percent := 0.15;         // переменной Percent присваивается 0.15
Profit := Sum * Percent; // вычисляется произведение двух переменных
                         // и его результат присваивается переменной
                         // Profit

Вы можете присвоить значение переменной непосредственно при объявлении:

        var
  Index: Integer = 1;
  Delimiter: Char = ';';

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

Каждый используемый в программе элемент данных должен быть описан в разделе const или var. Исключение составляют данные, заданные непосредственно значением, например:

Write(100, 200); // 100 и 200 - данные, заданные значением

2.3. Простые типы данных

2.3.1. Целочисленные типы данных

Целочисленные типы данных применяются для описания целочисленных данных. Для решения различных задач могут потребоваться различные целые числа. В одних задачах счет идет на десятки, в других — на миллионы. Соответственно в языке Delphi имеется несколько целочисленных типов данных, среди которых вы можете выбрать наиболее подходящий для своей задачи (таблица 2.1).

Фундаментальные типы данных:

Обобщенные типы данных:

Пример описания целочисленных данных:

        var
  X, Y: Integer;
  TextLength: Cardinal;
  FileSize: Longint;

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

2.3.2. Вещественные типы данных

Вещественные типы данных применяются для описания вещественных данных с плавающей или с фиксированной точкой (таблица 2.2).

Пример описания вещественных данных:

        var
  X, Y: Double;	
  Z: Extended;

Необходимо отметить, что тип Real является обобщенным типом данных и по отношению к нему справедливо все то, что было сказано о типах Integer и Cardinal.

2.3.3. Символьные типы данных

Символьные типы применяются для описания данных, значением которых является буква, цифра, знак препинания и другие символы. Существуют два фундаментальных символьных типа данных: AnsiChar и WideChar (таблица 2.3). Они соответствуют двум различным системам кодировки символов. Данные типа AnsiChar занимают один байт памяти и кодируют один из 256 возможных символов расширенной кодовой таблицы ANSI, в то время как данные типа WideChar занимают два байта памяти и кодируют один из 65536 символов кодовой таблицы Unicode. Кодовая таблица Unicode — это стандарт двухбайтовой кодировки символов. Первые 256 символов таблицы Unicode соответствуют таблице ANSI, поэтому тип данных AnsiChar можно рассматривать как подмножество WideChar.

Фундаментальные типы данных:

Обобщенный тип данных:

Пример описания переменной символьного типа:

        var
  Symbol: Char;

В программе значения переменных и констант символьных типов заключаются в апострофы (не путать с кавычками!), например:

Symbol := 'A';  // Переменной Symbol присваивается буква A

2.3.4. Булевские типы данных

Булевские типы данных названы так в честь Георга Буля (George Boole), одного из авторов формальной логики. Диапазон значений данных булевских типов представлен двумя предопределенными константами: True — истина и False — ложь (таблица 2.4).

Пример описания булевских данных:

        var
  Flag: Boolean;
  WordFlag: WordBool;
  LongFlag: LongBool;

Булевские типы данных широко применяются в логических выражениях и в выражениях отношения. Переменные типа Boolean используются для хранения результатов логических выражений и могут принимать только два значения: False и True (стандартные идентификаторы). Булевские типы данных ByteBool, WordBool иLongBool введены в язык Delphi специально для совместимости с другими языками, в частности с языками C и C++. Все булевские типы данных совместимы друг с другом и могут одновременно использоваться в одном выражении.

2.3.5. Определение новых типов данных

Кроме стандартных типов данных язык Delphi поддерживает типы, определенные программистом. Новый тип данных определяется с помощью зарезервированного слова type, за которым следует идентификатор типа, знак равенства и описание. Описание завершается точкой с запятой. Например, можно определить тип, тождественный существующему типу:

        type
  TUnicode = WideChar; // TUnicode тождественен типу WideChar
  TFloat = Double;     // TFloat тождественен типу Double

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

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

2.3.6. Перечисляемые типы данных

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

        type
  TDirection = (North, South, East, West);

На базе типа TDirection можно объявить переменную Direction и присвоить ей значение:

        var
  Direction: TDirection;
begin
  Direction := North;
end.

На самом деле за идентификаторами значений перечисляемого типа стоят целочисленные константы. По умолчанию, первая константа равна 0, вторая — 1 и т.д. Существует возможность явно назначить значения идентификаторам:

        type
  TSizeUnit = (Byte = 1, Kilobyte = 1024 * Byte, Megabyte = Kilobyte * 1024,
    Gigabyte = Megabyte * 1024);

2.3.7. Интервальные типы данных

Интервальный тип данных задается двумя константами, ограничивающими диапазон значений для переменных данного типа. Обе константы должны принадлежать одному из стандартных порядковых типов (но не вещественному и не строковому). Значение первой константы должно быть обязательно меньше значения второй. Например, определим интервальный тип TDigit:

        type
  TDigit = 0..9;
var
  Digit: TDigit;
begin
  Digit := 5;
  Digit := 10; // Ошибка! Выход за границы диапазонаend.

В операциях с переменными интервального типа данных компилятор генерирует код проверки на принадлежность диапазону, поэтому последний оператор вызовет ошибку. Это очень удобно при отладке, но иногда отрицательно сказывается на скорости работы программы. Для отключения контроля диапазона откройте окно Project Options, выберите страницу Compiler и снимите пометку пункта Range Checking.

Данные перечисляемых и интервальных типов занимают в памяти 1, 2 или 4 байта в зависимости от диапазона значений типа. Например, если диапазон значений не превышает 256, то элемент данных занимает один байт памяти.

2.3.8. Временной тип данных

Для представления значений даты и времени в среде Delphi существует тип TDateTime. Он объявлен тождественным типу Double. Целая часть элемента данных типа TDateTime соответствует количеству дней, прошедших с полночи 30 декабря 1899 года. Дробная часть элемента данных типа TDateTime соответствует времени дня. Следующие примеры поясняют сказанное:

2.3.9. Типы данных со словом type

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

        type
  TFileName = string;

В приведенном выше примере тип данных TFileName является псевдонимом для стандартного типа данных string.

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

        type
  TFileName = typestring;

Различие между таким способом создания типа и обычным (без слова type) проявится при изучении массивов, записей и классов. Чтобы подготовленный читатель уже сейчас понял, в чем оно состоит, забежим вперед и приведем поясняющий пример (новичкам советуем пропустить пример и вернуться к нему позже после изучения массивов):

        type
  TType1 = array [1..10] of Integer;
  TType2 = type TType1;
var
  A: TType1;
  B: TType2;
begin
  B := A; // Ошибка!end.

В примере переменные A и B оказываются несовместимы друг с другом из-за слова type в описании типа TType2. Если же переменные A и B принадлежат простым типам данных, то оператор присваивания будет работать:

        type
  TType1 = Integer;
  TType2 = type TType1;
var
  A: TType1;
  B: TType2;
begin
  B := A; // Работаетend.

2.4. Операции

2.4.1. Выражения

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

(X + Y) / 2;

X, Y, 2 — операнды; '+', '/' — знаки операций; скобки говорят о том, что сначала выполняется операция сложения, потом — деления.

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

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

2.4.2. Арифметические операции

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

Операции сложения, вычитания и умножения соответствуют аналогичным операциям в математике. В отличие от них операция деления имеет три формы: обычное деление (/), целочисленное деление (div), остаток от деления (mod). Назначение каждой из операций станет понятным после изучения следующих примеров:

2.4.3. Операции отношения

Операции отношения выполняют сравнение двух операндов и определяют, истинно значение выражения или ложно (таблица 2.6). Сравниваемые величины могут принадлежать к любому порядковому типу данных. Результат всегда имеет булевский тип.

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

Типичные примеры операций отношения:

2.4.4. Булевские операции

Результатом выполнения логических (булевских) операций является логическое значение True или False (таблица 2.7). Операндами в логическом выражении служат данные типа Boolean.

Результаты выполнения типичных логических операций:

2.4.5. Операции с битами

Если операнды в булевской операции имеют целочисленный тип, то операция выполняется над битами операндов и называется побитовой. К побитовым операциям также относятся операции сдвига битов влево (shl) и вправо (shr).

Примеры побитовых операций:

2.4.6. Очередность выполнения операций

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

20 + 40 / 2

сначала произойдет деление (ибо скобок, меняющих естественный порядок выполнения операций, нет) и только потом — сложение. Выполнение каждой операции происходит с учетом ее приоритета. Не зная приоритета каждой операции, крайне трудно правильно записать даже самое простое выражение. Значения приоритетов для рассмотренных выше операций представлены в таблице 2.9.

Чем выше приоритет (первый — высший), тем раньше операция будет выполнена.

2.5. Консольный ввод-вывод

2.5.1. Консольное приложение

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

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

Итак, давайте последовательно создадим консольное приложение:

1. Запустите среду Delphi, выберите в главном меню команду File | Close All, а затем — команду File | New.

2. Выберите “Console Application” и нажмите “OK” (рисунок 2.1).

Рисунок 2.1. Окно среды Delphi для создания нового проекта

3. В появившемся окне между ключевыми словами BEGIN и END введите следующие строчки (рисунок 2.2):

Writeln('Press Enter to exit...');
ReadLn;

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

4. Скомпилируйте и выполните эту программу, щелкнув на пункте Run | Run главного меню среды Delphi. На экране появится черное окно (рисунок 2.3), в левом верхнем углу которого будет содержаться текст "Press ENTER to exit..." ("Нажмите клавишу Enter ...").

Рисунок 2.3. Окно работающей консольной программы

5. Нажмите в этом окне клавишу Enter — консольное приложение завершится.

Теперь, когда есть основа для проверки изучаемого материала, рассмотрим операторы консольного ввода-вывода. К ним относятся Write, Writeln, Read, Readln.

2.5.2. Консольный вывод

Инструкции Write и Writeln служат для вывода чисел, символов, строк и булевских значений на экран. Они имеют следующий формат:

Write(Y1, Y2, ... ,Yn);
Writeln(Y1, Y2, ... ,Yn);

где Y1, Y2,..., Yn — константы, переменные и результаты выражений. Инструкция Writeln аналогична Write, но после своего выполнения переводит курсор в начало следующей строки.

Если инструкции Write и Writeln записаны без параметров:

Write;
Writeln;

то это вызывает пропуск на экране соответственно одной позиции и одной строки.

2.5.3. Консольный ввод

Инструкции ввода обеспечивают ввод числовых данных, символов, строк для последующей обработки в программе. Формат их прост:

Read(X1, X2, ... ,Xn);
Readln(X1, X2, ... ,Xn);

где X1, X2, ..., Xn — переменные, для которых осуществляется ввод значений. Пример:

Read(A);   // Вводится значение переменной A
Readln(B); // Вводится значение переменной B

Если одна инструкция вводит несколько значений:

Read(A, B);

то все эти значения надо набрать на клавиатуре, отделяя одно значение от другого пробелом, и нажать клавишу Enter.

Если вводится одно значение:

Read(C);

то его следует набрать и нажать клавишу Enter. С этого момента программа может обрабатывать введенное значение в соответствии с алгоритмом решаемой задачи.

Инструкция Readln отличается от Read только одним свойством: каждое выполнение инструкции Readln переводит курсор в начало новой строки, а после выполнения Read курсор остается в той же строке, где и был (потренеруйтесь — и вы быстро поймете разницу).

В простейшем случае в инструкциях Read и Readln параметры можно вообще не указывать:

Read;
Readln;

Оба этих оператора останавливают выполнение программы до нажатия клавиши Enter.

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

Читатель уже достаточно много знает об отдельных элементах программы, пора изучить ее общую структуру. Синтаксически программа состоит из заголовка, списка подключаемых к программе модулей и программного блока:

Заголовок программы	program <имя программы>;
    Директивы компилятора	{$<директивы>}

Подключение модулей	uses <имя>, ..., <имя>;

Программный блок
    Константы	const ...;
    Типы данных	type  ...;
    Переменные	var   ...;
    Процедуры	procedure <имя>; begin ... end;
    Функции	function  <имя>; begin ... end;
    Тело программы	begin 
 	  <операторы>
	end.

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

2.6.1. Заголовок программы

Заголовок программы должен совпадать с именем программного файла. Он формируется автоматически при сохранении файла на диске и его не следует изменять вручную. Например, заголовок программы в файле Console.dpr выглядит так:

        program Console;

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

        {****************************************************}
        {    Демонстрационный пример                         }
        {    A.Valvachev, K.Surkov, D.Surkov, Yu.Chetyrko    }
        {****************************************************}
      

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

        {$APPTYPE CONSOLE}
      

2.6.2. Подключение модулей

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

        uses
  SysUtils;

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

2.6.3. Программный блок

Важнейшим понятием в языке Delphi является так называемый блок. По своей сути блок — это программа в целом или логически обособленная часть программы, содержащая описательную и исполнительную части. В первом случае блок называется глобальным, во втором — локальным. Глобальный блок — это основная программа, он присутствует всегда; локальные блоки — это необязательные подпрограммы (они рассмотрены ниже). Локальные блоки могут содержать в себе другие локальные блоки (т.е. одни подпрограммы могут включать в себя другие подпрограммы). Объекты программы (типы, переменные и константы) называют глобальными или локальными в зависимости от того, в каком блоке они объявлены.

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

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

        begin
  Writeln('Press Enter to exit...');
  Readln;
end.

На этом мы заканчиваем рассмотрение структуры программы и переходим к содержимому тела программы — операторам.

2.7. Операторы

2.7.1. Общие положения

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

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

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

2.7.2. Оператор присваивания

Оператор присваивания (:=) вычисляет выражение, заданное в его правой части, и присваивает результат переменной, идентификатор которой расположен в левой части. Например:

X := 4;
Y := 6;
Z := (X + Y) / 2;

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

В общем случае для числовых типов данных действует следующее правило: выражение с более узким диапазоном возможных значений можно присвоить переменной с более широким диапазоном значений. Например, выражение с типом данных Byte можно присвоить переменной с типом данных Integer, а выражение с типом данных Integer можно присвоить переменной с типом данных Real. В таких случаях преобразование данных из одного представления в другое выполняется автоматически:

        var
  B: Byte;
  I: Integer;
  R: Real;
begin
  B := 255;
  I := B + 1;    // I = 256
  R := I + 0.1;  // R = 256.1
  I := R;        // Ошибка! Типы данных несовместимы по присваиваниюend.

Исключение составляет случай, когда выражение принадлежит 32-разрядному целочисленному типу данных (например, Integer), а переменная — 64-разрядному целочисленному типу данных Int64. Для того, чтобы на 32-разрядных процессорах семейства x86 вычисление выражения происходило правильно, необходимо выполнить явное преобразование одного из операндов выражения к типу данных Int64. Следующий пример поясняет сказанное:

        var
  I: Integer;
  J: Int64;
begin
  I := MaxInt;        // I =  2147483647 (максимальное целое)
  J := I + 1;         // J = -2147483648 (неправильно: ошибка переполнения!)
  J := Int64(I) + 1;  // J =  2147483648 (правильно: вычисления в формате Int64)end.

2.7.3. Оператор вызова процедуры

Оператор вызова процедуры представляет собой не что иное, как имя стандартной или пользовательской процедуры. О том, что это такое, вы узнаете чуть позже, а пока достаточно просто наглядного представления. Примеры вызова процедур:

Writeln('Hello!'); // Вызов стандартной процедуры вывода данных
MyProc;            // Вызов процедуры, определенной программистом

2.7.4. Составной оператор

Составной оператор представляет собой группу из произвольного числа операторов, отделенных друг от друга точкой с запятой и заключенную в так называемые операторные скобки — begin и end:

        begin
  <оператор 1>;
  <оператор 2>;
  …
  <оператор N>
end

Частным случаем составного оператора является тело следующей программы:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  X, Y: Integer;

begin
  X := 4;
  Y := 6;
  Writeln(X + Y);
  Writeln('Press Enter to exit...');
  Readln; // Точка с запятой после этого оператора не обязательнаend.

Хотя символ точки с запятой служит разделителем между операторами и перед словом end может опускаться, мы рекомендуем ставить его в конце каждого оператора (как в примере), чтобы придать программе более красивый вид и избежать потенциальных ошибок при наборе текста.

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

2.7.5. Оператор ветвления if

Оператор ветвления if — одно из самых популярных средств, изменяющих естественный порядок выполнения операторов программы. Вот его общий вид:

        if <условие> then
  <оператор 1>
else
  <оператор 2>;

Условие — это выражение булевского типа, оно может быть простым или сложным. Сложные условия образуются с помощью логических операций и операций отношения. Обратите внимание, что перед словом else точка с запятой не ставится.

Логика работы оператора if очевидна: выполнить оператор 1, если условие истинно, и оператор 2, если условие ложно. Поясним сказанное на примере:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  A, B, C: Integer;

begin
  A := 2; 
  B := 8;
  if A > B then
    C := A
  else
    C := B;
  Writeln('C=', C);
  Writeln('Press Enter to exit...');
  Readln;
end.

В данном случае значение выражения А > В ложно, следовательно на экране появится сообщение C=8.

У оператора if существует и другая форма, в которой else отсутствует:

        if <условие> then <оператор>;

Логика работы этого оператора if еще проще: выполнить оператор, если условие истинно, и пропустить оператор, если оно ложно. Поясним сказанное на примере:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  A, B, C: Integer;

begin
  A := 2;
  B := 8; 
  C := 0;
  if A > B then C := A + B;
  Writeln('C=', C);
  Writeln('Press Enter to exit...');
  Readln;
end.

В результате на экране появится сообщение С=0, поскольку выражение А > В ложно и присваивание С := А + В пропускается.

Один оператор if может входить в состав другого оператора if. В таком случае говорят о вложенности операторов. При вложенности операторов каждое else соответствует тому then, которое непосредственно ему предшествует. Например:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  A: Integer;

begin
  Readln(A);
  if A >= 0 thenif A <= 100 then 
      Writeln('A попадает в диапазон 0 - 100.')
    else 
      Writeln('A больше 100.')
  else
    Writeln('A меньше 0.');
  Writeln('Press Enter to exit...');
  Readln;
end.

Конструкций со степенью вложенности более 2–3 лучше избегать из-за сложности их анализа при отладке программ.

2.7.6. Оператор ветвления case

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

        case <переключатель> of
  <список №1 значений переключателя>: <оператор 1>;
  <список №2 значений переключателя>: <оператор 2>;
      ...
  <список №N значений переключателя>: <оператор N>;
  else <оператор N+1>
end;

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

Переключатель должен принадлежать порядковому типу данных. Использовать вещественные и строковые типы в качестве переключателя не допускается.

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

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  Day: 1..31;

begin
  Readln(Day);
  case Day of
    20..31: Writeln('День попадает в диапазон 20 - 31.');
    1, 5..10: Writeln('День попадает в диапазон 1, 5 - 10.');
    else Writeln('День не попадает в заданные диапазоны.');
  end;
  Writeln('Press Enter to exit...');
  Readln;
end.

Если значения переключателя записаны в возрастающем порядке, то поиск требуемого оператора выполняется значительно быстрее, так как в этом случае компилятор строит оптимизированный код. Учитывая сказанное, перепишем предыдущий пример:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  Day: 1..31;

begin
  Readln(Day);
  case Day of
    1, 5..10: Writeln('День попадает в диапазон 1, 5 - 10.');
    20..31: Writeln('День попадает в диапазон 20 - 31.');
    else Writeln('День не попадает в заданные диапазоны.');
  end;
  Writeln('Press Enter to exit...');
  Readln;
end.

2.7.7. Операторы повтора — циклы

Алгоритм решения многих задач требует многократного повторения одних и тех же действий. При этом суть действий остается прежней, но меняются данные. С помощью рассмотренных выше операторов трудно представить в компактном виде подобные действия в программе. Для многократного (циклического) выполнения одних и тех же действий предназначены операторы повтора (циклы). К ним относятся операторы for, while и repeat. Все они используются для организации циклов разного вида.

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

2.7.8. Оператор повтора for

Оператор повтора for используется в том случае, если заранее известно количество повторений цикла. Приведем наиболее распространенную его форму:

        for <параметр цикла> := <значение 1> to <значение 2> do
  <оператор>;

где <параметр цикла> — это переменная любого порядкового типа данных (переменные вещественных типов данных недопустимы); <значение 1> и <значение 2> — выражения, определяющие соответственно начальное и конечное значения параметра цикла (они вычисляются только один раз перед началом работы цикла); <оператор> — тело цикла.

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

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  I: Integer;

beginfor I := 1 to 10 do Writeln(I);
  Writeln('Press Enter to exit...');
  Readln;
end.

Заметим, что если начальное значение параметра цикла больше конечного значения, цикл не выполнится ни разу.

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

После выполнения цикла значение параметра цикла считается неопределенным, поэтому в предыдущем примере нельзя полагаться на то, что значение переменной I равно 10 при выходе из цикла.

Вторая форма записи оператора for обеспечивает перебор значений параметра цикла не по возрастанию, а по убыванию:

        for <параметр цикла> := <значение 1> downto <значение 2> do
  <оператор>;

Например, в результате выполнения следующей программы на экран будут выведены значения параметра цикла в порядке убывания (от 10 до 1):

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  I: Integer;

beginfor I := 10 downto 1 do Writeln(I);
  Writeln('Press Enter to exit...');
  Readln;
end.

Если в такой записи оператора for начальное значение параметра цикла меньше конечного значения, цикл не выполнится ни разу.

2.7.9. Оператор повтора repeat

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

        repeat
  <оператор 1>;
      ...
  <оператор N>;
until <условие завершения цикла>;

Тело цикла выполняется до тех пор, пока условие завершения цикла (выражение булевского типа) не станет истинным. Оператор repeat имеет две характерные особенности, о которых нужно всегда помнить:

• между словами repeat и until может находиться произвольное число операторов без операторных скобок begin и end;
• так как условие завершения цикла проверяется после выполнения операторов, циклвыполняется, по крайней мере, один раз.

В следующем примере показано, как оператор repeat применяется для суммирования вводимых с клавиатуры чисел. Суммирование прекращается, когда пользователь вводит число 0:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  S, X: Integer;

begin
  S := 0;
  repeat
    Readln(X);
    S := S + X;
  until X = 0;
  Writeln('S=', S);
  Writeln('Press Enter to exit...');
  Readln;
end.

Часто бывает, что условие выполнения цикла нужно проверять перед каждым повторением тела цикла. В этом случае применяется оператор while, который, в отличие от оператора repeat, содержит условие выполнения цикла, а не условие завершения.

2.7.10. Оператор повтора while

Оператор повтора while имеет следующий формат:

        while <условие> do
  <оператор>;

Перед каждым выполнением тела цикла происходит проверка условия. Если оно истинно, цикл выполняется и условие вычисляется заново; если оно ложно, происходит выход из цикла, т.е. переход к следующему за циклом оператору. Если первоначально условие ложно, то тело цикла не выполняется ни разу. Следующий пример показывает использование оператора while для вычисления суммы S = 1 + 2 + .. + N, где число N задается пользователем с клавиатуры:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  S, N: Integer;

begin
  Readln(N);
  S := 0;
  while N > 0 dobegin
    S := S + N;
    N := N - 1;
  end;
  Writeln('S=', S);
  Writeln('Press Enter to exit...');
  Readln;
end.

2.7.11. Прямая передача управления в операторах повтора

Для управления работой операторов повтора используются специальные процедуры-операторы Continue и Break, которые можно вызывать только в теле цикла.

Процедура-оператор Continue немедленно передает управление оператору проверки условия, пропуская оставшуюся часть цикла (рисунок 2.4):

Рисунок 2.4. Схема работы процедуры-оператора Continue

Процедура-оператор Break прерывает выполнение цикла и передает управление первому оператору, расположенному за блоком цикла (рисунок 2.5):

Рисунок 2.5. Схема работы процедуры-оператора Break

2.7.12. Оператор безусловного перехода

Среди операторов языка Delphi существует один редкий оператор, о котором авторы сперва хотели умолчать, но так и не решились. Это оператор безусловного перехода goto ("перейти к"). Он задумывался для того случая, когда после выполнения некоторого оператора надо выполнить не следующий по порядку, а какой-либо другой, отмеченный меткой, оператор.

Метка — это именованная точка в программе, в которую можно передать управление. Перед употреблением метка должна быть описана. Раздел описания меток начинается зарезервированным словом label, за которым следуют имена меток, разделенные запятыми. За последним именем ставится точка с запятой. Типичный пример описания меток:

        label
  Label1, Label2;

В разделе операторов метка записывается с двоеточием. Переход на метку выполняется с помощью зарезервированного слова goto, за которым следует имя метки:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

label
  M1, M2;

begin
  M1:
  Write('Желаем успеха ');
  goto M2;
  Write('А этого сообщения вы никогда не увидите!');
  M2:
  goto M1;
  Writeln('в освоении среды Delphi!');
  Writeln('Press Enter to exit...');
  Readln;
end.

Эта программа будет выполняться бесконечно, причем второй оператор Write не выполнится ни разу!

Внимание! В соответствии с правилами структурного программирования следует избегать применения оператора goto, поскольку он усложняет понимание логики программы. Оператор goto использовался на заре программирования, когда выразительные возможности языков были скудными. В языке Delphi без него можно успешно обойтись, применяя условные операторы, операторы повтора, процедуры Break и Continue, операторы обработки исключений (последние описаны в главе 4).

2.8. Подпрограммы

2.8.1. Общие положения

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

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

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

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

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

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

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

2.8.2. Стандартные подпрограммы

Арифметические функции

Примеры:

Тригонометрические функции

Примеры:

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

Функции выделения целой или дробной части

Примеры:

Функции генерации случайных чисел

Подпрограммы для работы с порядковыми величинами

Примеры:

Подпрограммы для работы с датой и временем

Процедуры передачи управления

Разные процедуры и функции

Примеры:

2.8.3. Процедуры программиста

Очевидно, что встроенных процедур и функций для решения большинства прикладных задач недостаточно, поэтому приходиться придумывать собственные процедуры и функции. По своей структуре они очень напоминают программу и состоят из заголовка и блока. Заголовок процедуры состоит из зарезервированного слова procedure, имени процедуры и необязательного заключенного в круглые скобки списка формальных параметров. Имя процедуры — это идентификатор, уникальный в пределах программы. Формальные параметры — это данные, которые вы передаете в процедуру для обработки, и данные, которые процедура возвращает (подробно параметры описаны ниже). Если процедура не получает данных извне и ничего не возвращает, формальные параметры (в том числе круглые скобки) не записываются. Тело процедуры представляет собой локальный блок, по структуре аналогичный программе:

        procedure <имя процедуры> ( <список формальных параметров> ) ;
const ...;
type  ...;
var   ...;
begin
  <операторы>
end;

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

Вызов процедуры для выполнения осуществляется по ее имени, за которым в круглых скобках следует список фактических параметров, т.е. передаваемых в процедуру данных:

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

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

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

Приведем пример небольшой программы, использующей процедуру Power для вычисления числа X в степени Y. Результат вычисления процедура Power заносит в глобальную переменную Z.

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  Z: Double;

procedure Power(X, Y: Double); // X и Y - формальные параметрыbegin
  Z := Exp(Y * Ln(X));
end;

begin
  Power(2, 3);                 // 2 и 3 - фактические параметры
  Writeln('2 в степени 3 = ', Z);
  Writeln('Press Enter to exit...');
  Readln;
end.

2.8.4. Функции программиста

Функции программиста применяются в тех случаях, когда надо создать подпрограмму, участвующую в выражении как операнд. Как и процедура, функция состоит из заголовка и блока. Заголовок функции состоит из зарезервированного слова function, имени функции, необязательного заключенного в круглые скобки списка формальных параметров и типа возвращаемого функцией значения. Функции возвращают значения любых типов данных кроме Text и file of (см. файлы). Тело функции представляет собой локальный блок, по структуре аналогичный программе.

        function <имя функции> ( <список формальных параметров> ): <тип результата>;
const ...;
type  ...;
var   ...;
begin
  <операторы>
end;

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

В качестве примера заменим явно неуклюжую процедуру Power (см. выше) на функцию с таким же именем:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

function Power(X, Y: Double): Double;       // X и Y - формальные параметрыbegin
  Result := Exp(Y * Ln(X));
end;

begin
  Writeln('2 в степени 3 = ', Power(2, 3)); // 2 и 3 - фактические параметры
  Writeln('Press Enter to exit...');
  Readln;
end.

2.8.5. Параметры процедур и функций

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

Исходные данные передаются в подпрограмму с помощью входных параметров, а результаты работы подпрограммы возвращаются через выходные параметры. Параметры могут быть входными и выходными одновременно.

Входные параметры объявляются с помощью ключевого слова const; их значения не могут быть изменены внутри подпрограммы:

        function Min(const A, B: Integer): Integer;
beginif A < B then Result := A 
  else Result := B;
end;

Для объявления выходных параметров служит ключевое слово out:

        procedure GetScreenResolution(out Width, Height: Integer);
begin
  Width := GetScreenWidth;
  Height := GetScreenHeight;
end;

Установка значений выходных параметров внутри подпрограммы приводит к установке значений переменных, переданных в качестве аргументов:

        var
  W, H: Integer;
begin
  GetScreenResolution(W, H);
  ...
end;

После вызова процедуры GetScreenResolution переменные W и H будут содержать значения, которые были присвоены формальным параметрам Width и Height соответственно.

Если параметр является одновременно и входным, и выходным, то он описывается с ключевым словом var:

        procedure Exchange(var A, B: Integer);
var
  C: Integer;
begin
  C := A;
  A := B;
  B := C;
end;

Изменение значений var-параметров внутри подпрограммы приводит к изменению значений переменных, переданных в качестве аргументов:

        var
  X, Y: Integer;
begin
  X := 5;
  Y := 10;
  ...
  Exchange(X, Y);
  // Теперь X = 10, Y = 5
  ...
end;

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

Если при описании параметра не указано ни одно из ключевых слов const, out, или var, то параметр считается входным, его можно изменять, но все изменения не влияют на фактический аргумент, поскольку они выполняются с копией аргумента, создаваемой на время работы подпрограммы. При вызове подпрограммы на месте такого параметра можно использовать константы и выражения. Пример подпрограммы:

        function NumberOfSetBits(A: Cardinal): Byte;
begin
  Result := 0;
  while A <> 0 dobegin
    Result := Result + (A mod 2); 
    A := A div 2;
  end;
end;

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

Разные способы передачи параметров (const, out, var и без них) можно совмещать в одной подпрограмме. В следующем законченном примере процедура Average принимает четыре параметра. Первые два (X и Y) являются входными и служат для передачи исходных данных. Вторые два параметра являются выходными и служат для приема в вызывающей программе результатов вычисления среднего арифметического (M) и среднего геометрического (P) от значений X и Y:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

procedure Average(const X, Y: Double; out M, P: Double);
begin
  M := (X + Y) / 2;
  P := Sqrt(X * Y);
end;

var
  M, P: Double;

begin
  Average(10, 20, M, P);
  Writeln('Среднее арифметическое = ', M);
  Writeln('Среднее геометрическое = ', P);
  Writeln('Press Enter to exit...');
  Readln;
end.

Существует разновидность параметров без типа. Они называются нетипизированными и предназначены для передачи и для приема данных любого типа. Нетипизированные параметры описываются с помощью ключевых слов const и var, при этом тип данных опускается:

        procedure JustProc(const X; var Y; out Z);

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

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

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

2.8.6. Опущенные параметры процедур и функций

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

        procedure Initialize(var X; MemSize: Integer; InitValue: Byte = 0);

Для параметра InitValue задано стандартное значение, поэтому его можно опустить при вызове процедуры Initialize:

Initialize(MyVar, 10); // Эквивалентно Initialize(MyVar, 10, 0);

Подпрограмма может содержать любое количество параметров со стандартными значениями, однако такие параметры должны быть последними в списке. Другими словами, после параметра со стандартным значением не может следовать обычный параметр, поэтому следующее описание будет воспринято компилятором как ошибочное:

        procedure Initialize(var X; InitValue: Byte = 0; MemSize: Integer); // Ошибка!

2.8.7. Перегрузка процедур и функций

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

        procedure IncrementInteger(var Value: Integer);
procedure IncrementReal(var Value: Real);

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

        procedure Increment(var Value: Integer); overload; // процедура 1procedure Increment(var Value: Real); overload;    // процедура 2

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

        var
  X: Integer;
  Y: Real;
begin
  X:=1;
  Y:=2.0;
  Increment(X); // Вызывается процедура 1
  Increment(Y); // Вызывается процедура 2end.

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

        procedure Print(X: Shortint); overload; // процедура 1procedure Print(X: Longint); overload;  // процедура 2

Если мы попробуем вызвать процедуру Print, указав в качестве фактического аргумента целочисленную константу, то увидим, что выбор компилятором варианта процедуры зависит от значения константы.

Print(5);    // Вызывается процедура 1
Print(150);  // Вызывается процедура 2
Print(-500); // Вызывается процедура 2
Print(-1);   // Вызывается процедура 1

Очевидно, что одно и то же число может интерпретироваться и как Longint, и как Shortint (например, числа 5 и –1). Логика компилятора в таких случаях такова: если значение фактического параметра попадает в диапазон значений нескольких типов, по которым происходит перегрузка, то компилятор выбирает процеудуру (функцию), у которой тип параметра имеет меньший диапазон значений. Например, вызов Print(5) будет означать вызов того варианта процедуры, который имеет тип параметра Shortint. А вот вызов Print(150) будет означать вызов того варианта процедуры, который имеет тип параметра Longint, т.к. число 150 не вмещается в диапазон значений типа данных Shortint.

Поскольку в нынешней версии среды Delphi обощенный тип данных Integer совпадает с фундаментальным типом данных Longint, следующий вариант перегрузки является ошибочным:

        procedure Print(X: Integer); overload;
procedure Print(X: Longint); overload; // Ошибка!

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

        type
  TMyInteger = Integer;

procedure Print(X: Integer); overload;
procedure Print(X: TMyInteger); overload; // Ошибка!

Что делать в тех случаях, когда такая перегрузка просто необходима? Для этого пользовательский тип данных необходимо создавать с использованием ключевого слова type:

        type
  TMyInteger = type Integer;

procedure Print(X: Integer); overload;
procedure Print(X: TMyInteger); overload; // Правильно

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

        procedure Increment(var Value: Real; Delta: Real = 1.0); overload; // процедура 1procedure Increment(var Value: Real); overload;                    // процедура 2

Вызов процедуры Increment с одним параметром вызовет неоднозначность:

        var
  X: Real;
begin
  Increment(X, 10); // Вызывается процедура 1
  Increment(X);     // Ошибка! Неоднозначностьend.

Запрещается также перегружать функции, которые отличаются лишь типом возвращаемого значения.

        function SquareRoot(X: Integer): Single; overload;
function SquareRoot(X: Integer): Double; overload; // Ошибка!

2.8.8. Соглашения о вызове подпрограмм

В различных языках программирования используются различные правила вызова подпрограмм. Для того чтобы из программ, написанных на языке Delphi, возможно было вызывать подпрограммы, написанные на других языках (и наоборот), в языке Delphi существуют директивы, соответствующие четырем известным соглашениям о вызове подпрограмм: register, stdcall, pascal, cdecl.

Директива, определяющая правила вызова, помещается в заголовок подпрограммы, например:

        procedure Proc; register;
function Func(X: Integer): Boolean; stdcall;

Директива register задействует регистры процессора для передачи параметров и поэтому обеспечивает наиболее эффективный способ вызова подпрограмм. Эта директива применяется по умолчанию. Директива stdcall используется для вызова стандартных подпрограмм операционной системы. Директивы pascal и cdecl используются для вызова подпрограмм, написанных на языках Delphi и C/C++ соответственно.

2.8.9. Рекурсивные подпрограммы

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

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

X! = 1 * 2 * ... * (X – 2) * (X – 1) * X

Из определения следует, что факториал числа X равен факториалу числа (X – 1), умноженному на X. Математическая запись этого утверждения выглядит так:

X! = (X – 1)! * X, где 0! = 1

Последняя формула используется в функции Factorial для вычисления факториала:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

function Factorial(X: Integer): Longint;
beginif X = 0  then// Условие завершения рекурсии
    Factorial := 1
  else
    Factorial := Factorial(X - 1) * X;
end;

begin
  Writeln('4! = ', Factorial(4)); // 4! = 1 * 2 * 3 * 4 = 24
  Writeln('Press Enter to exit...');
  Readln;
end.

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

Бывает встречается такая рекурсия, когда первая подпрограмма вызывает вторую, а вторая — первую. Такая рекурсия называется косвенной. Очевидно, что записанная первой подпрограмма будет содержать еще неизвестный идентификатор второй подпрограммы (компилятор не умеет заглядывать вперед). В результате компилятор сообщит об ошибке использования неизвестного идентификатора. Эта проблема решается с помощью упреждающего (предварительного) описания процедур и функций.

2.8.10. Упреждающее объявление процедур и функций

Для реализации алгоритмов с косвенной рекурсией в языке Delphi предусмотрена специальная директива предварительного описания подпрограмм forward. Предварительное описание состоит из заголовка подпрограммы и следующего за ним зарезервированного слова forward, например:

        procedure Proc; forward;
function Func(X: Integer): Boolean; forward;

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

        procedure Proc2(<формальные параметры>); forward;

procedure Proc1;
begin
  ...
  Proc2(<фактические параметры>);
  ...
end;

procedure Proc2; // Список формальных параметров опущенbegin
  ...
  Proc1;
  ...
end;

begin
  ...
  Proc1;
  ...
end.

2.8.11. Процедурные типы данных

Наряду с уже известными типами данных в языке Delphi введен так называемый процедурный тип, с помощью которого обычные процедуры и функции можно интерпретировать как некоторую разновидность переменных. Определение процедурного типа состоит из зарезервированного слова procedure или function, за которым следует полное описание параметров. Для функции дополнительно указывается тип результата. Символические имена параметров никакой роли не играют, поскольку нигде не используются.

        type
  TProc = procedure (X, Y: Integer);
  TFunc = function (X, Y: Integer): Boolean;

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

        var
  P: TProc;
  F: TFunc;

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

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

function Power(X, Y: Double): Double;
begin
  Result := Exp(Y * Ln(X));
end;

type
  TFunc = function (X, Y: Double): Double;

var
  F: TFunc;

begin
  F := Power; // В переменную F заносится адрес функции Power
  Writeln('2 power 4 = ', F(2, 4)); // Вызов Power посредством F
  Writeln('Press Enter to exit...');
  Readln;
end.

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

2.9. Программные модули

2.9.1. Структура модуля

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

Заголовок модуля 	unit <имя модуля>;
    Директивы компилятора	{$<директивы>}

Интерфейсная часть	interface
    Подключение модулей	uses <имя>, ..., <имя>;
    Константы	const ... ;
    Типы данных	type  ... ;
    Переменные	var   ... ;
    Заголовки процедур	procedure <имя> (<параметры>);
    Заголовки функций	function  <имя> (<параметры>): <тип>;

Часть реализации	implementation
    Подключение модулей	uses <имя>, ..., <имя>;
    Константы	const ... ;
    Типы данных	type  ... ;
    Переменные	var   ... ;
    Реализация процедур	procedure <имя>; begin ... end;
    Реализация функций	function  <имя>; begin ... end;

Код инициализации	initialization <операторы>
Код завершения	finalization <операторы> 
	end.

После слова unit записывается имя модуля. Оно должно совпадать с именем файла, в котором находится исходный текст модуля. Например, если файл называется MathLib.pas, то модуль должен иметь имя MathLib. Заголовок модуля формируется автоматически при сохранении файла на диске, поэтому его не следует изменять вручную. Чтобы дать модулю другой заголовок, просто сохраните его на диске под другим именем.

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

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

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

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

Если модуль не нуждается в инициализации и завершении, блоки initialization и finalization можно опустить.

В качестве упражнения давайте создадим модуль и подключим его к основной программе (для этого сначала запустите среду Delphi):

1. Выберите в главном меню команду File | New..., в появившемся диалоговом окне активизируйте значок с подписью Unit и щелкните на кнопке OK (рисунок 2.6).

Рисунок 2.6. Окно среды Delphi для создания нового модуля

2. Вы увидите, что среда Delphi создаст в редакторе кода новую страницу с текстом нового модуля Unit1 (рисунок 2.7):

Рисунок 2.7. Текст нового модуля в редакторе кода

3. Сохраните модуль под именем MathLib, выбрав в меню команду File | Save (рисунок 2.8):

Рисунок 2.8. Окно сохранения модуля

4. Заметьте, что основная программа Console изменилась: в списке подключаемых модулей появилось имя модуля MathLib(рисунок 2.9). После слова in среда Delphi автоматически помещает имя файла, в котором находится модуль. Для стандартных модулей, таких как SysUtils, это не нужно, поскольку их местонахождение хорошо известно.

Рисунок 2.9. Текст программы Console в окне редактора

Теперь перейдем к содержимому модуля. Давайте объявим в нем константу Pi и две функции: Power — вычисление степени числа, и Average — вычисление среднего арифметического двух чисел:

        unit MathLib;

interfaceconst
  Pi = 3.14;

function Power(X, Y: Double): Double;
function Average(X, Y: Double): Double;

implementationfunction Power(X, Y: Double): Double;
begin
  Result := Exp(Y * Ln(X));
end;

function Average(X, Y: Double): Double;
begin
  Result := (X + Y) / 2;
end;

end.

Вот как могла бы выглядеть программа, использующая модуль Math:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils,
  MathLib in'MathLib.Pas';

begin
  Writeln(Pi);
  Writeln(Power(2, 4));
  Writeln(Average(2, 4));
  Writeln('Press Enter to exit...');
  Readln;
end.

После компиляции и запуска программы вы увидите на экране три числа(рисунок 2.10):

Рисунок 2.10. Результат работы программы Console

2.9.2. Стандартные модули языка Delphi

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

К системным модулям относятся System, SysUtils, ShareMem, Math. В них содержатся наиболее часто используемые в программах типы данных, константы, переменные, процедуры и функции. Модуль System — это сердце среды Delphi; содержащиеся в нем подпрограммы обеспечивают работу всех остальных модулей системы. Модуль System подсоединяется автоматически к каждой программе и его не надо указывать в операторе uses.

Модули визуальных компонентов (VCL — Visual Component Library) используются для визуальной разработки полнофункциональных GUI-приложений — приложений с графическим пользовательским интерфейсом (Graphical User Interface). Эти модули в совокупности представляют собой высокоуровневую объектно-ориентированную библиотеку со всевозможными элементами пользовательского интерфейса: кнопками, надписями, меню, панелями и т.д. Кроме того, модули этой библиотеки содержат простые и эффективные средства доступа к базам данных. Данные модули подключаются автоматически при помещении компонентов на форму, поэтому вам об этом заботиться не надо. Их список слишком велик, поэтому мы его не приводим.

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

Исходные тексты стандартных модулей среды Delphi находятся в каталоге Delphi/Source.

2.9.3. Область действия идентификаторов

При программировании необходимо соблюдать ряд правил, регламентирующих использование идентификаторов:

• каждый идентификатор должен быть описан перед тем, как он будет использован;
• областью действия идентификатора является блок, в котором он описан;
• все идентификаторы в блоке должны быть уникальными, т.е. не повторяться;
• один и тот же идентификатор может быть по-разному определен в каждом отдельном блоке, при этом блоки могут быть вложенными;
• если один и тот же идентификатор определен в нескольких вложенных блоках, то в пределах вложенного блока действует вложенное описание;
• все глобальные описания подключенного модуля видны программе (подключающему модулю), как если бы они были сделаны в точке подключения;
• если подключаются несколько модулей, в которых по-разному определен один и тот же идентификатор, то определение, сделанное в последнем подключенном модуле перекрывает все остальные;
• если один и тот же идентификатор определен и в подключенном модуле, и в программе (подключающем модуле), то первый игнорируется, а используется идентификатор, определенный в программе (подключающем модуле). Доступ к идентификатору подключенного модуля возможен с помощью уточненного имени. Уточненное имя формируется из имени модуля и записанного через точку идентификатора. Например, чтобы в предыдущем примере получить доступ к стандартному значению числа ?, нужно записать System.Pi.

2.10. Строки

2.10.1. Строковые значения

Строка — это последовательность символов. При программировании строковые значения заключаются в апострофы, например:

Writeln('Я тебя люблю');

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

Writeln('Object Pascal is Delphi''s and Kylix''s language');

Для записи отсутствующих на клавиатуре символов используется символ #, за которым следует десятичный номер символа в кодовой таблице ASCII, например:

Writeln('Copyright '#169' А.Вальвачев, К.Сурков, Д.Сурков, Ю.Четырько');

Строка, которая не содержит символов, называется пустой:

Writeln('');

Теперь, когда известно, что представляют собой строковые значения, займемся строковыми переменными.

2.10.2. Строковые переменные

Строковая переменная объявляется с помощью зарезервированного слова string или с помощью идентификатора типа данных AnsiString, например:

        var
  FileName: string;
  EditText: AnsiString;

Строку можно считать бесконечной, хотя на самом деле ее длина ограничена 2 ГБ. В зависимости от присваиваемого значения строка увеличивается и сокращается динамически. Это удобство обеспечивается тем, что физически строковая переменная хранит не сами символы, а адрес символов строки в области динамически распределяемой памяти (о динамически распределяемой памяти мы расскажем ниже). При создании строки всегда инициализируются пустым значением (''). Управление динамической памятью при операциях со строками выполняется автоматически с помощью стандартных библиотек языка Delphi.

Вы конечно же можете описывать строковые типы данных и использовать их при объявлении переменных и типизированных констант, например:

        type
  TName = string;
var
  Name: TName;
const
  FriendName: TName = 'Alexander';

Символы строки индексируются от 1 до N+1, где N — реальная длина строки. Символ с индексом N+1 всегда равен нулю (#0). Для получения длины следует использовать функцию Length, а для изменения длины — процедуру SetLength (см. ниже).

Для того чтобы в программе обратиться к отдельному символу строки, нужно сразу за идентификатором строковой переменной или константы в квадратных скобках записать его номер. Например, FriendName[1] возвращает значение ‘A’, а FriendName[4] — ‘x’. Символы, получаемые в результате индексирования строки, принадлежат типу Char.

Достоинство строки языка Delphi состоит в том, что она объединяет в себе свойства строки самого языка Delphi и строки языка C. Оперируя строкой, вы оперируете значением строки, а не адресом в оперативной памяти. В то же время строка не ограничена по длине и может передаваться вместо C-строки (как адрес первого символа строки) в параметрах процедур и функций. Чтобы компилятор позволил это сделать, нужно, записывая строку в качестве параметра, преобразовать ее к типу PChar (тип данных, используемый в языке Delphi для описания нуль-терминированных строк языка C). Такое приведение типа допустимо по той причине, что строка всегда завершается нулевым символом (#0), который хоть и не является ее частью, тем не менее всегда дописывается сразу за последним символом строки. В результате формат строки удовлетворяет формату C-строки. О работе с нуль-терминированными строками мы поговорим чуть позже.

2.10.3. Строки в формате Unicode

Для поддержки работы со строками формата Unicode в язык Delphi имеется строковый тип данных WideString. Работа со строками типа WideString почти не отличается от работы со строками типа AnsiString; существуют лишь два отличия.

Первое отличие состоит в представлении символов. В строках типа WideString каждый символ кодируется не одним байтом, а двумя. Соответственно элементы строки WideString — это символы типа WideChar, тогда как элементы строки AnsiString — это символы типа AnsiChar.

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

2.10.4. Короткие строки

Короткая строка объявляется с помощью идентификатора типа ShortString или зарезервированного слова string, за которым следует заключенное в квадратные скобки значение максимально допустимой длины, например:

        var
  Address: ShortString;
  Person: string[30];

Короткая строка может иметь длину от 1 до 255 символов. Предопределенный тип данных ShortString эквивалентен объявлению string[255].

Реальная длина строки может быть меньше или равна той, что указана при ее объявлении. Например, максимальная длина строки Friend в примере выше составляет 30 символов, а ее реальная длина — 9 символов. Реальную длину строки можно узнать с помощью встроенной функции Length. Например, значение Length(Friend) будет равно 9 (количество букв в слове Alexander).

Все символы в строке типа ShortString пронумерованы от 0 до N, где N — максимальная длина, указанная при объявлении. Символ с номером 0 — это служебный байт, в нем содержится реальная длина короткой строки. Значащие символы нумеруются от 1. Очевидно, что в памяти строка занимает на 1 байт больше, чем ее максимальная длина. Поэтому значение SizeOf(Friend) будет равно 31.

        type
  TName = string[30];
var
  Name: TName;
const
  FriendName: TName = 'Alexander';

Обратиться к отдельному символу можно так же, как и к символу обычной строки. Например, выражения FriendName[1] и FriendName[9] возвращают соответственно символы 'A' и 'r'. Значения FriendName[10] .. FriendName[30] будут случайными, так как при объявлении типизированной константы FriendName символы с номерами от 10 до 30 не были инициализированы. Символы, получаемые в результате индексирования короткой строки, принадлежат типу Char.

Поскольку существует два типа строк: обычные (длинные) строки и короткие строки, возникает закономерный вопрос, можно ли их совмещать. Да, можно! Короткие и длинные строки могут одновременно использоваться в одном выражении, поскольку компилятор языка Delphi автоматически генерирует код, преобразующий их тип. Более того, можно выполнять явные преобразования строк с помощью конструкций вида ShortString(S) и AnsiString(S).

2.10.5. Операции над строками

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

Операция сцепления (+) применяется для сцепления нескольких строк в одну строку.

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

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

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

2.10.6. Строковые ресурсы

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

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

        resourcestring
  SCreateFileError = 'Cannot create file: ';
  SOpenFileError = 'Cannot open file: ';

Использование строковых ресурсов ничем не отличается от использования строковых констант:

        var
  S: string;
begin
  S := SCreateFileError + 'MyFile.txt';
  ...
end;

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

2.10.7. Форматы кодирования символов

Существуют различные форматы кодирования символов. Отдельный символ строки может быть представлен в памяти одним байтом (стандарт Ansi), двумя байтам (стандарт Unicode) и даже четырьмя байтами (стандарт UCS-4 — Unicode). Строка “Wirth” (фамилия автора языка Pascal — прародителя языка Delphi) будет представлена в указанных форматах следующим образом (рисунок 2.11):

Рисунок 2.11. Форматы кодирования символов

Существует также формат кодирования MBCS (Multibyte Character Set), согласно которому символы одной строки кодируются разным количеством байт (одним или двумя байтами в зависимости от алфавита). Например, буквы латинского алфавита кодируются одним байтом, а иероглифы японского алфавита — двумя. При этом латинские буквы и японские иероглифы могут встречаться в одной и той же строке.

2.10.8. Стандартные процедуры и функции для работы со строками

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

• Concat(S1, S2, ... , Sn): string — возвращает строку, полученную в результате сцепления строк S1, S2, ..., Sn. По своей работе функция Concat аналогична операции сцепления (+).
• Copy(S: string, Index, Count: Integer): string — выделяет из строки S подстроку длиной Count символов, начиная с позиции Index.
• Delete(var S: string, Index, Count: Integer) — удаляет Count символов из строки S, начиная с позиции Index.
• Insert(Source: string; var S: string, Index: Integer) — вставляет строку Source в строку S, начиная с позиции Index.
• Length(S: string): Integer — возвращает реальную длину строки S в символах.
• SetLength(var S: string; NewLength: Integer) — устанавливает для строки S новую длину NewLength.

Примеры:

• Pos(Substr, S: string): Byte — обнаруживает первое появление подстроки Substr в строке S. Возвращает номер той позиции, где находится первый символ подстроки Substr. Если в S подстроки Substr не найдено, результат равен 0.

• Str(X [: Width [: Decimals] ], var S: string) — преобразует числовое значение величины X в строку S. Необязательные параметры Width и Decimals являются целочисленными выражениями. Значение Width задает ширину поля результирующей строки. Значение Decimals используется с вещественными числами и задает количество символов в дробной части.

• Val(S: string, var V; var Code: Integer) — преобразует строку S в величину целого или вещественного типа и помещает результат в переменную V. Если во время операции преобразования ошибки не обнаружено, значение переменной Code равно нулю; если ошибка обнаружена (строка содержит недопустимые символы), Code содержит номер позиции первого ошибочного символа, а значение V не определено.

Описанные процедуры и функции являются базовыми для всех остальных подпрограмм обработки строк из модуля SysUtils.

• AdjustLineBreaks(const S: string): string — возвращает копию строки S, в которой все мягкие переносы строк (одиночные символы #13 или #10) заменены жесткими переносами строк (последовательность символов #13#10).
• AnsiCompareStr(const S1, S2: string): Integer — сравнивает две строки, делая различие между заглавными и строчными буквами; учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.
• AnsiCompareText(const S1, S2: string): Integer — сравнивает две строки, не делая различий между заглавными и строчными буквами; учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.
• AnsiDequotedStr(const S: string; Quote: Char): string — удаляет специальный символ, заданный параметром Quote, из начала и конца строки и заменяет парные спецсимволы на одиночные; если специальный символ отсутствует в начале или конце строки, то функция возвращает исходную строку без изменений.
• AnsiExtractQuotedStr(var Src: PChar; Quote: Char): string — делает то же, что и функция AnsiDequotedStr, но результат возвращается вместо исходной строки, которая имеет тип PChar.
• AnsiLowerCase(const S: string): string— преобразует заглавные буквы строки S к строчным буквам с учетом местного языка.
• AnsiPos(const Substr, S: string): Integer — выполняет те же действия, что и функция Pos, но в отличие от нее поддерживает работу с многобайтовой MBCS-кодировкой.
• AnsiQuotedStr(const S: string; Quote: Char): string — преобразует строку, заменяя все вхождения специального символа, заданного параметром Quote, на парные спецсимволы, а также помещает специальный символ в начало и конец строки. Поддерживает работу с MBCS-кодировкой.
• AnsiSameCaption(const Text1, Text2: string): Boolean — сравнивает две строки, не делая различие между заглавными и строчными буквами, а также не учитывая символ ‘&’; учитывает местный язык.
• AnsiSameStr(const S1, S2: string): Boolean— сравнивает строки, делая различие между строчными и заглавными буквами; учитывает местный язык.
• AnsiSameText(const S1, S2: string): Boolean — сравнивает строки, не делая различие между строчными и заглавными буквами; учитывает местный язык.
• AnsiUpperCase(const S: string): string — преобразует все строчные буквы в заглавные; учитывает местный язык.
• CompareStr(const S1, S2: string): Integer— выполняет сравнение двух строк, делая различие между строчными и заглавными буквами; не учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.
• CompareText(const S1, S2: string): Integer — выполняет сравнение двух строк, не делая различий между строчными и заглавными буквами; не учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.
• DateTimeToStr(const DateTime: TDateTime): string— преобразует значение даты и времени в строку.
• DateTimeToString(var Result: string; const Format: string; DateTime: TDateTime) — преобразует значение даты и времени в строку, выполняя при этом форматирование в соответствии со значением строки Format. Управляющие символы строки Format подробно описаны в справочнике по среде Delphi.
• DateToStr(const DateTime: TDateTime): string — преобразует числовое значение даты в строку.
• Format(const Format: string; const Args: array of const): string — форматирует строку в соответствии с шаблоном Format, заменяя управляющие символы шаблона на значения элементов открытого массива Args. Управляющие символы подробно описаны в справочнике по среде Delphi.
• FormatDateTime(const Format: string; DateTime: TDateTime): string — преобразует значение даты и времени в строку, выполняя при этом форматирование в соответствии со значением строки Format. Управляющие символы строки Format подробно описаны в справочнике по среде Delphi.
• BoolToStr(B: Boolean; UseBoolStrs: Boolean = False): string — преобразует булевское значение в строку. Если параметр UseBoolStrs имеет значение False, то результатом работы функции является одно из значений '0' или ‘–1’. Если же параметр UseBoolStrs имеет значение True, то результатом работы является одно из значений ‘FALSE’ или ‘TRUE’ (программист может задать другие значения; о том, как это сделать, читайте в справочнике по системе Delphi).
• IntToHex(Value: Integer; Digits: Integer): string — возвращает шестнадцатиричное представление целого числа Value. Параметр Digits задает количество цифр результирующей строки.
• IntToStr(Value: Integer): string — преобразует целое число Value в строку.
• IsDelimiter(const Delimiters, S: string; Index: Integer): Boolean — проверяет, является ли символ S[Index] одним из символов строки Delimiters. Функция поддерживает работу с многобайтовой MBCS-кодировкой.
• IsValidIdent(const Ident: string): Boolean — возвращает True, если строка Ident является правильным идентификатором языка Delphi.
• LastDelimiter(const Delimiters, S: string): Integer — возвращает индекс последнего вхождения одного из символов строки Delimiters в строку S.
• LowerCase(const S: string): string — преобразует все заглавные буквы строки S к строчным; не учитывает местный язык (в преобразовании участвуют лишь символы в диапазоне от 'A' до 'Z').
• QuotedStr(const S: string): string — преобразует исходную строку в строку, взятую в одиночные кавычки; внутри строки символы кавычки дублируются.
• SameText(const S1, S2: string): Boolean — сравнивает строки, не делая различие между строчными и заглавными буквами; учитывает местный язык.
• SetString(var S: string; Buffer: PChar; Len: Integer) — копирует строку с типом PChar в строку с типом string. Длина копируемой строки задается параметром Len.
• StringOfChar(Ch: Char; Count: Integer): string — возвращает строку, в которой повторяется один и тот же символ. Количество повторений задается параметром Count.
• StringToGUID(const S: string): TGUID — преобразует строковое представление глобального уникального идентификатора в стандартный тип TGUID.
• StrToBool(const S: string): Boolean — преобразует строку в булевское значение.
• StrToBoolDef(const S: string; const Default: Boolean): Boolean — преобразует строку в булевское значение. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.
• StrToDate(const S: string): TDateTime — преобразует строку со значением даты в числовой формат даты и времени.
• StrToDateDef(const S: string; const Default: TDateTime): TDateTime — преобразует строку со значением даты в числовой формат даты и времени. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.
• StrToDateTime(const S: string): TDateTime — преобразует строку в числовое значение даты и времени.
• StrToDateTimeDef(const S: string; const Default: TDateTime): TDateTime — преобразует строку в числовое значение даты и времени. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.
• StrToInt(const S: string): Integer— преобразует строку в целое число. Если строка не может быть преобразована в целое число, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).
• StrToIntDef(const S: string; Default: Integer): Integer — преобразует строку в целое число. Если строка не может быть преобразована в целое число, функция возвращает значение, заданное параметром Default.
• StrToInt64(const S: string): Int64 — 64-битный аналог функции StrToInt — преобразует строку в 64-битное целое число. Если строка не может быть преобразована в 64-битное число, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).
• StrToInt64Def(const S: string; const Default: Int64): Int64 — 64-битный аналог функции StrToIntDef — преобразует строку в 64-битное целое число. Если строка не может быть преобразована в 64-битное число, функция возвращает значение, заданное параметром Default.
• StrToTime(const S: string): TDateTime — преобразует строку в числовой формат времени. Если строка не может быть преобразована в числовой формат времени, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).
• StrToTimeDef(const S: string; const Default: TDateTime): TDateTime — преобразует строку в числовой формат времени. В случае ошибки преобразования, функция возвращает значение, заданное параметром Default.
• TimeToStr(Time: TDateTime): string — преобразует числовое значение времени в строку.
• Trim(const S: string): string — возвращает часть строки S без лидирующих и завершающих пробелов и управляющих символов.
• Trim(const S: WideString): WideString — Unicode-аналог функции Trim — возвращает часть строки S без лидирующих и завершающих пробелов и управляющих символов.
• TrimLeft(const S: string): string — возвращает часть строки S без лидирующих пробелов и управляющих символов.
• TrimLeft(const S: WideString): WideString — Unicode-аналог функции TrimLeft — возвращает часть строки S без лидирующих пробелов и управляющих символов.
• TrimRight(const S: string): string — возвращает часть строки S без завершающих пробелов и управляющих символов.
• TrimRight(const S: WideString): WideString — Unicode-аналог функции TrimRight — возвращает часть строки S без завершающих пробелов и управляющих символов.
• UpperCase(const S: string): string — преобразует все строчные буквы строки S в заглавные; не учитывает местный язык (в преобразовании участвуют лишь символы в диапазоне от 'a' до 'z').
• WideFormat(const Format: WideString; const Args: array of const): WideString — Unicode-аналог функции Format, учитывающий символы местного языка, — форматирует строку в соответствии с шаблоном Format, заменяя управляющие символы в шаблоне на значения элементов открытого массива Args. Управляющие символы подробно описаны в справочнике по системе Delphi.
• WideFmtStr(var Result: WideString; const Format: WideString; const Args: array of const) — аналог функции WideFormat. Отличие в том, что WideFmtStr возвращает результат через параметр Result, а не как значение функции.
• WideLowerCase(const S: WideString): WideString — Unicode-аналог функции LowerCase (учитывает местный язык) — преобразует все заглавные буквы строки S к строчным буквам.
• WideSameCaption(const Text1, Text2: WideString): Boolean — Unicode-аналог функции AnsiSameCaption — сравнивает две строки, не делая различие между строчными и заглавными буквами, а также не учитывая символ ‘&’; учитывает местный язык.
• WideSameStr(const S1, S2: WideString): Boolean — Unicode-аналог стандартной операции сравнения строк — сравнивает две строки, делая различие между строчными и заглавными буквами.
• WideSameText(const S1, S2: WideString): Boolean — Unicode-аналог функции SameText (учитывает местный язык) — сравнивает строки, не делая различие между строчными и заглавными буквами.
• WideUpperCase(const S: WideString): WideString — Unicode-аналог функции UpperCase (учитывает местный язык) — преобразует все строчные буквы строки S в заглавные.
• WrapText(const Line: string; MaxCol: Integer = 45): string — разбивает текст Line на строки, вставляя символы переноса строки. Максимальная длина отдельной строки задается параметром MaxCol.
• WrapText(const Line, BreakStr: string; const BreakChars: TSysCharSet; MaxCol: Integer): string — более мощный аналог предыдущей функции — разбивает текст Line на строки, вставляя символы переноса строки.
• AnsiToUtf8(const S: string): UTF8String — перекодирует строку в формат UTF8.
• PUCS4Chars(const S: UCS4String): PUCS4Char — возвращает указатель на первый символ строки формата UCS-4 для работы со строкой, как с последовательностью символов, заканчивающейся символом с кодом нуль.
• StringToWideChar(const Source: string; Dest: PWideChar; DestSize: Integer): PWideChar — преобразует стандартную строку к последовательности Unicode-символов, завершающейся символом с кодом нуль.
• UCS4StringToWideString(const S: UCS4String): WideString — преобразует строку формата UCS-4 к строке формата Unicode.
• Utf8Decode(const S: UTF8String): WideString — преобразует строку формата UTF-8 к строке формата Unicode.
• Utf8Encode(const WS: WideString): UTF8String — преобразует строку формата Unicode к строке формата UTF-8.
• Utf8ToAnsi(const S: UTF8String): string — преобразует строку формата UTF-8 к стандратной строке.
• WideCharLenToString(Source: PWideChar; SourceLen: Integer): string — преобразует строку формата Unicode к стандартной строке. Длина исходной строки задается параметром SourceLen.
• WideCharLenToStrVar(Source: PWideChar; SourceLen: Integer; var Dest: string) — аналог предыдущей функции — преобразует строку формата Unicode к стандартной строке. Длина исходной строки задается параметром SourceLen, а результат возвращается через параметр Dest.
• WideCharToString(Source: PWideChar): string — преобразует последовательность Unicode-символов, завершающуюся символом с кодом нуль, к стандартной строке.
• WideCharToStrVar(Source: PWideChar; var Dest: string) — аналог предыдущей функции — преобразует последовательность Unicode-символов, завершающуюся символом с кодом нуль, к стандартной строке. Результат возвращается через параметр Dest.
• WideStringToUCS4String(const S: WideString): UCS4String — преобразует строку формата Unicode к строке формата UCS-4.

2.11. Массивы

2.11.1. Объявление массива

Массив — это составной тип данных, состоящий из фиксированного числа элементов одного и того же типа. Для описания массива предназначено словосочетание arrayof. После слова array в квадратных скобках записываются границы массива, а после слова of — тип элементов массива, например:

        type
  TStates = array[1..50] ofstring;
  TCoordinates = array[1..3] of Integer;

После описания типа можно переходить к определению переменных и типизированных констант:

        var
  States: TStates; { 50 strings }const
  Coordinates: TCoordinates = (10, 20, 5); { 3 integers }

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

Массив может быть определен и без описания типа:

        var
  Symbols: array[0..80] of Char; { 81 characters }

Чтобы получить доступ к отдельному элементу массива, нужно в квадратных скобках указать его индекс, например

Symbols[0]

Объявленные выше массивы являются одномерными, так как имеют только один индекс. Одномерные массивы обычно используются для представления линейной последовательности элементов. Если при описании массива задано два индекса, массив называется двумерным, если n индексов — n-мерным. Двумерные массивы используются для представления таблицы, а n-мерные — для представления пространств. Вот пример объявления таблицы, состоящей из 5 колонок и 20 строк:

        var
  Table: array[1..5] ofarray[1..20] of Double;

То же самое можно записать в более компактном виде:

        var
  Table: array[1..5, 1..20] of Double;

Чтобы получить доступ к отдельному элементу многомерного массива, нужно указать значение каждого индекса, например

Table[2][10]

или в более компактной записи

Table[2, 10]

Эти два способа индексации эквивалентны.

2.11.2. Работа с массивами

Массивы в целом участвуют только в операциях присваивания. При этом все элементы одного массива копируются в другой. Например, если объявлены два массива A и B,

        var
  A, B: array[1..10] of Integer;

то допустим следующий оператор:

A := B;

Оба массива-операнда в левой и правой части оператора присваивания должны быть не просто идентичны по структуре, а описаны с одним и тем же типом, иначе компилятор сообщит об ошибке. Именно поэтому все массивы рекомендуется описывать в секции type.

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

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  A: array[1..5] of Double;
  Sum: Double;
  I: Integer;

beginfor I := 1 to 5 do Readln(A[I]);
  Sum := 0;
  for I := 1 to 5 do Sum := Sum + A[I];
  Writeln(Sum);
  Writeln('Press Enter to exit...');
  Readln;
end.

Для массивов определены две встроенные функции — Low и High. Они получают в качестве своего аргумента имя массива. Функция Low возвращает нижнюю, а High — верхнюю границу этого массива. Например, Low(A) вернет значение 1, а High(A) — 5. Функции Low и High чаще всего используются для указания начального и конечного значений в операторе цикла for. Поэтому вычисление суммы элементов массива A лучше переписать так:

        for I := Low(A) to High(A) do Sum := Sum + A[I];

В операциях с многомерными массивами циклы for вкладываются друг в друга. Например, для инициализации элементов таблицы, объявленной как

        var
  Table: array[1..5, 1..20] of Double;

требуются два вложенных цикла for и две целые переменные Col и Row для параметров этих циклов:

        for Col := 1 to 5 dofor Row := 1 to 20 do
    Table[Col, Row] := 0;

2.11.3. Массивы в параметрах процедур и функций

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

        const
  Max = 63;
type
  TStatistics = array [0..Max] of Double;

function Average(const A: TStatistics): Double;
var
  I: Integer;
begin
  Result := 0;
  for I := Low(A) to High(A) do Result := Result + A[I];
  Result := Result / (High(A) - Low(A) + 1);
end;

Функция Average принимает в качестве параметра массив известной размерности. Требование фиксированного размера для массива-параметра часто является чрезмерно сдерживающим фактором. Процедура для нахождения среднего значения должна быть способна работать с массивами произвольной длины. Для этой цели в язык Delphi введены открытые массивы-параметры. Такие массивы были заимствованы разработчиками языка Delphi из языка Modula-2. Открытый массив-параметр описывается с помощью словосочетания arrayof, при этом границы массива опускаются:

        function Average(const A: arrayof Double): Double;
var
  I: Integer;
begin
  Result := 0;
  for I := Low(A) to High(A) do Result := Result + A[I];
  Result := Result / (High(A) - Low(A) + 1);
end;

Внутри подпрограммы Average нижняя граница открытого массива A равна нулю (Low(A) = 0), а вот значение верхней границы (High(A)) неизвестно и выясняется только на этапе выполнения программы.

Существует только два способа использования открытых массивов: обращение к элементам массива и передача массива другой подпрограмме, принимающей открытый массив. Нельзя присваивать один открытый массив другому, потому что их размеры заранее неизвестны.

Вот пример использования функции Average:

        var
  Statistics: array[1..10] of Double;
  Mean: Double;
begin
  ...
  Mean := Average(Statistics);
  Mean := Average([0, Random, 1]);
  ...
end;

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

И еще одно важное замечание по поводу открытых массивов. Некоторые библиотечные подпрограммы языка Delphi принимают параметры типа array of const — открытые массивы констант. Массив, передаваемый в качестве такого параметра, обязательно конструируется в момент вызова подпрограммы и может состоять из элементов различных типов (!). Физически он состоит из записей типа TVarRec, кодирующих тип и значение элементов массива (записи рассматриваются ниже). Открытый массив констант позволяет эмулировать подпрограммы с переменным количеством разнотипных параметров и используется, например, в функции Format для форматирования строки (см. выше).

2.11.4. Уплотнение структурных данных в памяти

С целью экономии памяти, занимаемой массивами и другими структурными данными, вы можете предварять описание типа зарезервированным словом packed, например:

        var
  A: packedarray[1..10] of Byte;

Ключевое слово packed указывает компилятору, что элементы структурного типа должны храниться плотно прижатыми друг к другу, даже если это замедляет к ним доступ. Если структурный тип данных описан без ключевого слова packed, компилятор выравнивает его элементы на 2- и 4-байтовых границах, чтобы ускорить к ним доступ.

Заметим, что ключевое слово packed применимо к любому структурному типу данных, т.е. массиву, множеству, записи, файлу, классу, ссылке на класс.

2.12. Множества

2.12.1. Объявление множества

Множество — это составной тип данных для представления набора некоторых элементов как единого целого. Область значений множества — набор всевозможных подмножеств, составленных из его элементов. Все элементы множества должны принадлежать однобайтовому порядковому типу. Этот тип называется базовым типом множества.

Для описания множественного типа используется словосочетание set of, после которого записывается базовый тип множества:

        type
  TLetters = setof'A'..'Z';

Теперь можно объявить переменную множественного типа:

        var
  Letters: TLetters;

Можно объявить множество и без предварительного описания типа:

        var
  Symbols: setof Char;

В выражениях значения элементов множества указываются в квадратных скобках: [2, 3, 5, 7], [1..9], ['A', 'B', 'C']. Если множество не имеет элементов, оно называется пустым и обозначается как [ ]. Пример инициализации множеств:

        const
  Vowels: TLetters = ['A', 'E', 'I', 'O', 'U'];
begin
  Letters := ['A', 'B', 'C'];
  Symbols := [ ]; { пустое множество }end;

Количество элементов множества называется мощностью. Мощность множества в языке Delphi не может превышать 256.

2.12.2. Операции над множествами

При работе с множествами допускается использование операций отношения (=, <>, >=, <=), объединения, пересечения, разности множеств и операции in.

Операции сравнения (=, <>). Два множества считаются равными, если они состоят из одних и тех же элементов. Порядок следования элементов в сравниваемых множествах значения не имеет. Два множества A и B считаются не равными, если они отличаются по мощности или по значению хотя бы одного элемента.

Операции принадлежности (>=, <=). Выражение A >= B равно True, если все элементы множества B содержатся в множестве A. Выражение A <= B равно True, если выполняется обратное условие, т.е. все элементы множества A содержатся в множестве B.

Операция in. Используется для проверки принадлежности элемента указанному множеству. Обычно применяется в условных операторах.

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

        if (X = 1) or (X = 2) or (X = 3) or (X = 5) or (X = 7) then

можно заменить более коротким:

        if X in [1..3, 5, 7] then

Операцию in иногда пытаются записать с отрицанием: X notin S. Такая запись является ошибочной, так как две операции следуют подряд. Правильная запись имеет вид: not (X in S).

Объединение множеств (+). Объединением двух множеств является третье множество, содержащее элементы обоих множеств.

Пересечение множеств (*). Пересечение двух множеств — это третье множество, которое содержит элементы, входящие одновременно в оба множества.

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

В язык Delphi введены две стандартные процедуры Include и Exclude, которые предназначены для работы с множествами.

Процедура Include(S, I) включает в множество S элемент I. Она дублирует операцию + (плюс) с той лишь разницей, что при каждом обращении включает только один элемент и делает это более эффективно.

Процедура Exclude(S, I) исключает из множества S элемент I. Она дублирует операцию – (минус) с той лишь разницей, что при каждом обращении исключает только один элемент и делает это более эффективно.

Использование в программе множеств дает ряд преимуществ: значительно упрощаются сложные операторы if, улучшается наглядность программы и понимание алгоритма решения задачи, экономится время разработки программы. Поэтому множества широко используются в библиотеке компонентов среды Delphi.

2.13. Записи

2.13.1. Объявление записи

Запись — это составной тип данных, состоящий из фиксированного числа элементов одного или нескольких типов. Описание типа записи начинается словом record и заканчивается словом end. Между ними заключен список элементов, называемых полями, с указанием идентификаторов полей и типа каждого поля:

        type
  TPerson = record
    FirstName: string[20]; // имя
    LastName: string[20];  // фамилия
    BirthYear: Integer;    // год рожденияend;

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

Чтобы получить в программе реальную запись, нужно создать переменную соответствующего типа:

        var
  Friend: TPerson;

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

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

Friend.FirstName := 'Alexander';
Friend.LastName := 'Ivanov';
Friend.BirthYear := 1991;

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

        with <запись> do
  <оператор>;

Однажды указав имя записи в операторе with, можно работать с именами ее полей как с обычными переменными, т.е. без указания идентификатора записи перед идентификатором поля:

        with Friend dobegin
  FirstName := 'Alexander';
  LastName := 'Ivanov';
  BirthYear := 1991;
end;

Допускается применение оператора присваивания и к записям в целом, если они имеют один и тот же тип. Например,

Friend := BestFriend;

После выполнения этого оператора значения полей записи Friend станут равными значениям соответствующих полей записи BestFriend.

2.13.2. Записи с вариантами

Строго фиксированная структура записи ограничивает возможность ее применения. Поэтому в языке Delphi имеется возможность задать для записи несколько вариантов структуры. Такие записи называются записями с вариантами. Они состоят из необязательной фиксированной и вариантной частей.

Вариантная часть напоминает условный оператор case. Между словами case и of записывается особое поле записи – поле признака. Оно определяет, какой из вариантов в данный момент будет активизирован. Поле признака должно быть равно одному из расположенных следом значений. Каждому значению сопоставляется вариант записи. Он заключается в круглые скобки и отделяется от своего значения двоеточием. Пример описания записи с вариантами:

        type
  TFigure = record
    X, Y: Integer;
    case Kind: Integer of
      0: (Width, Height: Integer); // прямоугольник
      1: (Radius: Integer);        // окружностьend;

Обратите внимание, что у вариантной части нет отдельного end, как этого можно было бы ожидать по аналогии с оператором case. Одно слово end завершает и вариантную часть, и всю запись.

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

2.14. Файлы

2.14.1. Понятие файла

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

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

В зависимости от типа элементов различают три вида файла:

• файл из элементов фиксированного размера; элементами такого файла чаще всего являются записи;
• файл из элементов переменного размера (нетипизированный файл); такой файл рассматривается просто как последовательность байтов;
• текстовый файл; элементами такого файла являются текстовые строки.

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

Для работы с файлом, состоящим из типовых элементов переменная объявляется с помощью словосочетания file of, после которого записывается тип элемента:

        var
  F: fileof TPerson;

К моменту такого объявления тип TPerson должен быть уже описан (см. выше).

Объявление переменной для работы с нетипизированным файлом выполняется с помощью отдельного слова file:

        var
  F: file;

Для работы с текстовым файлом переменная описывается с типом TextFile:

        var
  F: TextFile;

2.14.2. Работа с файлами

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

Приступая к работе с файлом, нужно первым делом вызвать процедуру AssignFile, чтобы файловой переменной поставить в соответствие имя файла на диске:

AssignFile(F, 'MyFile.txt');

В результате этого действия поля файловой переменной F инициализируются начальными значениями. При этом в поле имени файла заносится строка 'MyFile.txt'.

Так как файла еще нет на диске, его нужно создать:

Rewrite(F);

Теперь запишем в файл несколько строк текста. Это делается с помощью хорошо вам знакомых процедур Write и Writeln:

Writeln(F, 'Pi = ', Pi);
Writeln(F, 'Exp = ', Exp(1));

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

После работы файл должен быть закрыт:

CloseFile(F);

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

Reset(F);

Для чтения элементов используются процедуры Read и Readln, в которых первый параметр показывает, откуда происходит ввод данных. После работы файл закрывается. В качестве примера приведем программу, распечатывающую в своем окне содержимое текстового файла 'MyFile.txt':

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  F: TextFile;
  S: string;

begin
  AssignFile(F, 'MyFile.txt');
  Reset(F);
  whilenot Eof(F) dobegin
    Readln(F, S);
    Writeln(S);
  end;
  CloseFile(F);
  Writeln('Press Enter to exit...');
  Readln;
end.

Так как обычно размер файла заранее не известен, перед каждой операцией чтения вызывается функция Eof, которая возвращает True, если достигнут конец файла.

Внимание! Текстовые файлы можно открывать только для записи или только для чтения, но не для того и другого одновременно. Для того чтобы сначала записать текстовый файл, а потом прочитать, его нужно закрыть после записи и снова открыть, но уже только для чтения.

2.14.3. Стандартные подпрограммы управления файлами

Для обработки файлов в языке Delphi имеется специальный набор процедур и функций:

• AssignFile(var F; FileName: string) — связывает файловую переменную F и файл, имя которого указано в FileName.
• Reset(var F [: File; RecSize: Word ] ) — открывает существующий файл. Если открывается нетипизированный файл, то RecSize задает размер элемента файла.
• Rewrite(var F [: File; RecSize: Word ] ) — создает и открывает новый файл.
• Append(var F: TextFile) — открывает текстовый файл для добавления текста.
• Read(F, V1 [, V2, ..., Vn ]) — начиная с текущей позиции, читает из типизированного файла подряд расположенные элементы в переменные V1, V2, ..., Vn.
• Read(var F: TextFile; V1 [, V2, ..., Vn ] ) — начиная с текущей позиции, читает из текстового файла символы или строки в переменные V1, V2, ..., Vn.
• Write(F, V1 [, V2, ..., Vn ]) — начиная с текущей позиции, записывает в типизированный файл значения V1, V2, ..., Vn.
• Write(var F: TextFile; V1 [, V2, ..., Vn ] ) — начиная с текущей позиции указателя чтения-записи, записывает в текстовый файл значения V1, V2, ..., Vn.
• CloseFile(var F) — закрывает ранее открытый файл.
• Rename(var F; NewName: string) — переименовывает неоткрытый файл F любого типа. Новое имя задается в NewName.
• Erase(var F) — удаляет неоткрытый внешний файл любого типа, заданный переменной F.
• Seek(var F; NumRec: Longint) — устанавливает позицию чтения-записи на элемент с номером NumRec; F — типизированный или нетипизированный файл.
• SetTextBuf(var F: TextFile; var Buf [; Size: Word]) — назначает текстовому файлу F новый буфер ввода-вывода Buf объема Size.
• SetLineBreakStyle(var T: Text; Style: TTextLineBreakStyle) — устанавливает способ переноса строк в файле (одиночный символ #10 или пара символов #13#10).
• Flush(var F: TextFile) — записывает во внешний файл все символы, переданные в буфер для записи.
• Truncate(var F) — урезает файл, уничтожая все его элементы, начиная с текущей позиции.
• IOResult: Integer — возвращает код, характеризующий результат (была ошибка или нет) последней операции ввода-вывода.
• FilePos(var F): Longint — возвращает для файла F текущую файловую позицию (номер элемента, на которую она установлена, считая от нуля). Не используется с текстовыми файлами.
• FileSize(var F): Longint — возвращает число компонент в файле F. Не используется с текстовыми файлами.
• Eoln(var F: Text): Boolean — возвращает булевское значение True, если текущая позиция чтения-записи находится на маркере конца строки. Если параметр F не указан, функция применяется к стандартному устройству ввода с именем Input.
• Eof(var F): Boolean — возвращает булевское значение True, если текущая позиция чтения-записи находится сразу за последним элементом, и False в противном случае.
• SeekEoln(var F: Text): Boolean — возвращает True при достижении маркера конца строки. Все пробелы и знаки табуляции, предшествующие маркеру, пропускаются.
• SeekEof(var F: Text): Boolean — возвращает значение True при достижении маркера конца файла. Все пробелы и знаки табуляции, предшествующие маркеру, пропускаются.

Для работы с нетипизированными файлами используются процедуры BlockRead и BlockWrite. Единица обмена для этих процедур 128 байт.

• BlockRead(var F: File; var Buf; Count: Word [; Result: Word] ) — считывает из файла F определенное число блоков в память, начиная с первого байта переменной Buf. Параметр Buf представляет любую переменную, используемую для накопления информации из файла F. Параметр Count задает число считываемых блоков. Параметр Result является необязательным и содержит после вызова процедуры число действительно считанных записей. Использование параметра Result подсказывает, что число считанных блоков может быть меньше, чем задано параметром Count.
• BlockWrite(var F: File; var Buf; Count: Word [; Result: Word]) — предназначена для быстрой передачи в файл F определенного числа блоков из переменной Buf. Все параметры процедуры BlockWrite аналогичны параметрам процедуры BlockRead.
• ChDir(const S: string) — устанавливает текущий каталог.
• CreateDir(const Dir: string): Boolean — создает новый каталог на диске.
• MkDir(const S: string) — аналог функции CreateDir. Отличие в том, что в случае ошибки при создании каталога функция MkDir создает исключительную ситуацию.
• DeleteFile(const FileName: string): Boolean — удаляет файл с диска.
• DirectoryExists(const Directory: string): Boolean — проверяет, существует ли заданный каталог на диске.
• FileAge(const FileName: string): Integer — возвращает дату и время файла в числовом системно-зависимом формате.
• FileExists(const FileName: string): Boolean — проверяет, существует ли на диске файл с заданным именем.
• FileIsReadOnly(const FileName: string): Boolean — проверяет, что заданный файл можно только читать.
• FileSearch(const Name, DirList: string): string — осуществляет поиск заданого файла в указанных каталогах. Список каталогов задается параметром DirList; каталоги разделяются точкой с запятой для операционной системы Windows и запятой для операционной системы Linux. Функция возвращает полный путь к файлу.
• FileSetReadOnly(const FileName: string; ReadOnly: Boolean): Boolean — делает файл доступным только для чтения.
• FindFirst/FindNext/FindClose
• ForceDirectories(Dir: string): Boolean — создает новый каталог на диске. Позволяет одним вызовом создать все каталоги пути, заданного параметром Dir.
• GetCurrentDir: string — возвращает текущий каталог.
• SetCurrentDir(const Dir: string): Boolean — устанавливает текущий каталог. Если это сделать невозможно, функция возвращет значение False.
• RemoveDir(const Dir: string): Boolean — удаляет каталог с диска; каталог должен быть пустым. Если удалить каталог невозможно, функция возвращет значение False.
• RenameFile(const OldName, NewName: string): Boolean — изменяет имя файла. Если это сделать невозможно, функция возвращет значение False.
• ChangeFileExt(const FileName, Extension: string): string — возвращает имя файла с измененным расширением.
• ExcludeTrailingPathDelimiter(const S: string): string — отбрасывает символ-разделитель каталогов (символ ‘/’ — для Linux и ‘\’ — для Windows), если он присутствует в конце строки.
• IncludeTrailingPathDelimiter(const S: string): string — добавляет символ-разделитель каталогов (символ ‘/’ — для Linux и ‘\’ — для Windows), если он отсутствует в конце строки.
• ExpandFileName(const FileName: string): string — возвращает полное имя файла (с абсолютным путем) по неполному имени.
• ExpandUNCFileName(const FileName: string): string — возвращает полное сетевое имя файла (с абсолютным сетевым путем) по неполному имени. Для операционной системы Linux эта функция эквивалентна функции ExpandFileName.
• ExpandFileNameCase(const FileName: string; out MatchFound: TFilenameCaseMatch): string — возвращает полное имя файла (с абсолютным путем) по неполному имени, допуская несовпадения заглавных и строчных букв в имени файла для тех файловых систем, которые этого не допускают (например, файловая система ОС Linux).
• ExtractFileDir(const FileName: string): string — выделяет путь из полного имени файла; путь не содержит в конце символ-разделитель каталогов.
• ExtractFilePath(const FileName: string): string — выделяет путь из полного имени файла; путь содержит в конце символ-разделитель каталогов.
• ExtractRelativePath(const BaseName, DestName: string): string — возвращает относительный путь к файлу DestName, отсчитанный от каталога BaseName. Путь BaseName должен заканчиваться символом-разделителем каталогов.
• ExtractFileDrive(const FileName: string): string — выделяет имя диска (или сетевого каталога) из имени файла. Для операционной системы Linux функция возвращает пустую строку.
• ExtractFileExt(const FileName: string): string — выделяет расширение файла из его имени.
• ExtractFileName(const FileName: string): string — выделяет имя файла, отбрасывая путь к нему.
• IsPathDelimiter(const S: string; Index: Integer): Boolean — проверяет, является ли символ S[Index] разделителем каталогов.
• MatchesMask(const Filename, Mask: string): Boolean — проверяет, удовлетворяет ли имя файла заданной маске.

2.15. Указатели

2.15.1. Понятие указателя

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

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

        var
  P: Pointer; // переменная-указатель
  N: Integer; // целочисленная переменная

Переменная P занимает 4 байта и может содержать адрес любого участка памяти, указывая на байты со значениями любых типов данных: Integer, Real, string, record, array и других. Чтобы инициализировать переменную P, присвоим ей адрес переменной N. Это можно сделать двумя эквивалентными способами:

P := Addr(N); // с помощью вызова встроенной функции Addr

или

P := @N;      // с помощью оператора @

В дальнейшем мы будем использовать более краткий и удобный второй способ.

Если некоторая переменная P содержит адрес другой переменной N, то говорят, что P указывает на N. Графически это обозначается стрелкой, проведенной из P в N (рисунок 2.12 выполнен в предположении, что N имеет значение 10):

Рисунок 2.12. Графическое изображение указателя P на переменную N

Теперь мы можем изменить значение переменной N, не прибегая к идентификатору N. Для этого слева от оператора присваивания запишем не N, а P вместе с символом ^:

P^ := 10; // Здесь умышленно опущено приведение типа

Символ ^, записанный после имени указателя, называется оператором доступа по адресу. В данном примере переменной, расположенной по адресу, хранящемуся в P, присваивается значение 10. Так как в переменную P мы предварительно занесли адрес N, данное присваивание приводит к такому же результату, что и

N := 10;

Однако в примере с указателем мы умышленно допустили одну ошибку. Дело в том, что переменная типа Pointer может содержать адреса переменных любого типа, не только Integer. Из-за сильной типизации языка Delphi перед присваиванием мы должны были бы преобразовать выражение P^ к типу Integer:

Integer(P^) := 10;

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

        var
  P: ^Integer;

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

        type
  PInteger = ^Integer;
var
  P: PInteger;

PInteger — это указательный тип данных. Чтобы отличать указательные типы данных от других типов, будем назначать им идентификаторы, начинающиеся с буквы P (от слова Pointer). Объявление указательного типа данных является единственным способом введения указателей на составные переменные, такие как массивы, записи, множества и другие. Например, объявление типа данных для создания указателя на некоторую запись TPerson может выглядеть так:

        type
  PPerson = ^TPerson;
  TPerson = record
    FirstName: string[20]; 
    LastName: string[20]; 
    BirthYear: Integer; 
  end;

var
  P: PPerson;

Переменная P, описанная с типом данных PPerson, является указателем и может содержать адрес любой переменной типа TPerson. Впредь все указатели мы будем вводить через соответствующие указательные типы данных. Типом Pointer будем пользоваться лишь тогда, когда это действительно необходимо или оправдано.

2.15.2. Динамическое распределение памяти

После объявления в секции var указатель содержит неопределенное значение. Поэтому переменные-указатели, как и обычные переменные, перед использованием нужно инициализировать. Отсутствие инициализации указателей является наиболее распространенной ошибкой среди новичков. Причем если использование обычных неинициализированных переменных приводит просто к неправильным результатам, то использование неинициализированных указателей обычно приводит к ошибке "Access violation" (доступ к неверному адресу памяти) и принудительному завершению приложения.

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

Для размещения динамической переменной вызывается стандартная процедура

New(var P: Pointer);

Она выделяет требуемый по размеру участок памяти и заносит его адрес в переменную-указатель P. В следующем примере создаются 4 динамических переменных, адреса которых присваиваются переменным-указателям P1, P2, P3 и P4:

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

type
  PInteger = ^Integer;
  PDouble = ^Double;
  PShortString = ^ShortString;

var
  P1, P2: PInteger;
  P3: PDouble;
  P4: PShortString;

begin
  New(P1);
  New(P2);
  New(P3);
  New(P4);
  ...
end.

Далее по адресам в указателях P1, P2, P3 и P4 можно записать значения:

P1^ := 10;
P2^ := 20;
P3^ := 0.5;
P4^ := 'Hello!';

В таком контексте динамические переменные P1^, P2^, P3^ и P4^ ничем не отличаются от обычных переменных соответствующих типов. Операции над динамическими переменными аналогичны подобным операциям над обычными переменными. Например, следующие операторы могут быть успешно откомпилированы и выполнены:

        if P1^ < P2^ then
  P1^ := P1^ + P2^; // в P1^ заносится 30
P3^ := P1^;         // в P3^ заносится 30.0

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

Dispose(var P: Pointer);

Например, в приведенной выше программе явно не хватает следующих строк:

Dispose(P4);
Dispose(P3);
Dispose(P2);
Dispose(P1);

После выполнения данных утверждений указатели P1, P2, P3 и P4 опять перестанут быть связаны с конкретными адресами памяти. В них будут случайные значения, как и до обращения к процедуре New. Не стоит делать попытки присвоить значения переменным P1^, P2^, P3^ и P4^, ибо в противном случае это может привести к нарушению нормальной работы программы.

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

Поэтому следует четко придерживаться последовательности действий при работе с динамическими переменными:

• создать динамическую переменную;
• выполнить с ней необходимые действия;
• разрушить динамическую переменную.

2.15.3. Операции над указателями

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

P3^ := 20;
P1^ := 50;
P3 := P1;  // теперь P3^ = 50

После выполнения этого оператора оба указателя P1 и P3 будут указывать на один и тот же участок памяти. Однако будьте осторожны при операциях с указателями. Только что сделанное присваивание приведет к тому, что память, выделенная ранее для указателя P3, будет потеряна. Отдавая программе участок свободной памяти, система помечает его как занятый. После работы вся память, которая была выделена динамически, должна быть возвращена системе. Поэтому изменение значения указателя P3 без предварительного освобождения связанной с ним динамической переменной является ошибкой.

Использование одинаковых значений в разных указателях открывает некоторые интересные возможности. Так после оператора P3 := P1 изменение значения переменной P3^ будет равносильно изменению значения P1^.

P3^ := 70; // теперь P3^ = P1^ = 70

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

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

        if P1 = P2 then ... // Указатели ссылаются на одни и те же данныеif P1 <> P2 then ... // Указатели ссылаются на разные данные

Чаще всего операции сравнения указателей используются для проверки того, связан ли указатель с динамической переменной. Если еще нет, то ему следует присвоить значение nil (зарезервированное слово):

P1 := nil;

Установка P1 в nil однозначно говорит о том, что указателю не выделена динамическая память. Если всем объявленным указателям присвоить значение nil, то внутри программы можно легко выполнить тестирование наподобие этого:

        if P1 = nilthen New(P1);

или

        if P1 <> nilthen Dispose(P1);

2.15.4. Процедуры GetMem и FreeMem

Для динамического распределения памяти служат еще две тесно взаимосвязанные процедуры: GetMem и FreeMem. Подобно New и Dispose, они во время вызова выделяют и освобождают память для одной динамической переменной:

• GetMem(var P: Pointer; Size: Integer) — создает в динамической памяти новую динамическую переменную c заданным размером Size и присваивает ее адрес указателю P. Переменная-указатель P может указывать на данные любого типа.
• FreeMem(var P: Pointer [; Size: Integer] ) — освобождает динамическую переменную.

Если в программе используется этот способ распределения памяти, то вызовы GetMem и FreeMem должны соответствовать друг другу. Обращения к GetMem и FreeMem могут полностью соответствовать вызовам New и Dispose.

Пример:

New(P4);     // Выделить блок памяти для указателя P4
...
Dispose(P4); // Освободить блок памяти

Следующий отрывок программы даст тот же самый результат:

GetMem(P4, SizeOf(ShortString)); // Выделить блок памяти для P4
...
FreeMem(P4);                     // Освободить блок памяти

С помощью процедуры GetMem одной переменной-указателю можно выделить разное количество памяти в зависимости от потребностей. В этом состоит ее основное отличие от процедуры New.

GetMem(P4, 20); // Выделить блок в 20 байт для указателя P4
...
FreeMem(P4);    // Освободить блок памяти

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

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

ReallocMem(var P: Pointer; Size: Integer) — освобождает блок памяти по значению указателя P и выделяет для указателя новый блок памяти заданного размера Size. Указатель P может иметь значение nil, а параметр Size — значение 0, что влияет на работу процедуры:

• если P = nil и Size = 0, процедура ничего не делает;
• если P = nil и Size <> 0, процедура выделяет новый блок памяти заданного размера, что соответствует вызову процедуры GetMem.
• если P <> nil и Size = 0, процедура освобождает блок памяти, адресуемый указателем P и устанавливает указатель в значение nil. Это соответствует вызову процедуры FreeMem, с той лишь разницей, что FreeMem не очищает указатель;
• если P <> nil и Size <> 0, процедура перевыделяет память для указателя P. Размер нового блока определяется значением Size. Данные из прежнего блока копируются в новый блок. Если новый блок больше прежнего, то приращенный участок остается неинициализированным и содержит случайные данные.

2.16. Представление строк в памяти

В некоторых случаях динамическая память неявно используется программой, например для хранения строк. Длина строки может варьироваться от нескольких символов до миллионов и даже миллиардов (теоретический предел равен 2 ГБ). Тем не менее, работа со строками в программе осуществляется так же просто, как работа с переменными простых типов данных. Это возможно потому, что компилятор автоматически генерирует код для выделения и освобождения динамической памяти, в которой хранятся символы строки. Но что стоит за такой простотой? Не идет ли она в ущерб эффективности? С полной уверенностью можем ответить, что эффективность программы не только не снижается, но даже повышается.

Физически переменная строкового типа представляет собой указатель на область динамической памяти, в которой размещаются символы. Например, переменная S на самом деле представляет собой указатель и занимает всего четыре байта памяти (SizeOf(S) = 4):

      var
  S: string; // Эта переменная физически является указателем

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

SetLength(S, 100); // S получает адрес распределенного блока динамической памяти

За оператором присваивания строковых переменных на самом деле кроется копирование значения указателя, а не копирование блока памяти, в котором хранятся символы.

S2 := S1; // Копируются лишь адреса

Такой подход весьма эффективен как с точки зрения производительности, так и с точки зрения экономного использования оперативной памяти. Его главная проблема состоит в том, чтобы обеспечить удаление блока памяти, содержащего символы строки, когда все адресующие его строковые переменные прекращают свое существование. Эта проблема эффективно решается с помощью механизма подсчета количества ссылок (reference counting). Для понимания его работы рассмотрим формат хранения строк в памяти подробнее.

Пусть в программе объявлены две строковые переменные:

      var
  S1, S2: string; // Физически эти переменные являются указателями

И пусть в программе существует оператор, присваивающий переменной S1 значение некоторой функции:

Readln(S1); // В S1 записывается адрес считанной строки

Для хранения символов строки S1 по окончании ввода будет выделен блок динамической памяти. Формат этого блока после ввода значения 'Hello' показан на рисунке 2.13:

Рисунок 2.13. Представление строковых переменных в памяти

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

Если в программе встречается оператор присваивания значения одной строковой переменной другой строковой переменной,

S2 := S1; // Теперь S2 указывает на тот же блок памяти, что и S1

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

Рисунок 2.14. Результат копирования строковой переменной S1 в строковую переменную S2

При присваивании переменной S1 нового значения (например, пустой строки):

S1 := '';

количество ссылок на предыдущее значение уменьшается на единицу (рисунок 2.15).

Рисунок 2.15. Результат присваивания строковой переменной S1 нового значения (пустой строки)

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

Интересно, а что происходит при изменении символов строки, с которой связано несколько строковых переменных? Правила семантики языка требуют, чтобы две строковые переменные были логически независимы, и изменение одной из них не влияло на другую. Это достигается с помощью механизма копирования при записи (copy-on-write).

Например, в результате выполнения операторов

  S1 := S2;                // S1 указывает на ту же строку, что и S2
  S1[3] := '-';            // Автоматически создается копия строки

получим следующую картину в памяти (рисунок 2.16):

Рисунок 2.16. Результат изменения символа в строке S1

Работая сообща, механизмы подсчета количества ссылок и копирования при записи позволяют наиболее эффективно работать со строками. Это как раз тот случай, когда простота и удобство сочетается с мощью и эффективностью.

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

2.17. Динамические массивы

Одним из мощнейших средств языка Delphi являются динамические массивы. Их основное отличие от обычных массивов заключается в том, что они хранятся в динамической памяти. Этим и обусловлено их название. Чтобы понять, зачем они нужны, рассмотрим пример:

      var
  N: Integer;
  A: array[1..100] of Integer; // обычный массивbegin
  Write('Введите количество элементов: ');
  ReadLn(N);
  ...
end.

Задать размер массива A в зависимости от введенного пользователем значения невозможно, поскольку в качестве границ массива необходимо указать константные значения. А введенное пользователем значение никак не может претендовать на роль константы. Иными словами, следующее объявление будет ошибочным:

      var
  N: Integer;
  A: array[1..N] of Integer; // Ошибка!begin
  Write('Введите количество элементов: ');
  ReadLn(N);
  ...
end.

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

• На какое количество элементов объявить массив?
• Что делать, если пользователю все-таки понадобится большее количество элементов?

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

      const
  MaxNumberOfElements = 100;
var
  N: Integer;
  A: array[1.. MaxNumberOfElements] of Integer;
begin
  Write('Введите количество элементов (не более ', MaxNumberOfElements, '): ');
  ReadLn(N);
  if N > MaxNumberOfElements thenbegin
    Write('Извините, программа не может работать ');
    Writeln('с количеством элементов больше , ' MaxNumberOfElements, '.');
  endelsebegin
    ... // Инициализируем массив необходимыми значениями и обрабатываем егоend;
end.

Такое решение проблемы является неоптимальным. Если пользователю необходимо всего 10 элементов, программа работает без проблем, но всегда использует объем памяти, необходимый для хранения 100 элементов. Память, отведенная под остальные 90 элементов, не будет использоваться ни Вашей программой, ни другими программами (по принципу «сам не гам и другому не дам»). А теперь представьте, что все программы поступают таким же образом. Эффективность использования оперативной памяти резко снижается.

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

Динамический массив объявляется без указания границ:

      var
  DynArray: arrayof Integer;

Переменная DynArray представляет собой ссылку на размещаемые в динамической памяти элементы массива. Изначально память под массив не резервируется, количество элементов в массиве равно нулю, а значение переменной DynArray равно nil.

Работа с динамическими массивами напоминает работу с длинными строками. В частности, создание динамического массива (выделение памяти для его элементов) осуществляется той же процедурой, которой устанавливается длина строк — SetLength.

SetLength(DynArray, 50);       // Выделить память для 50 элементов

Изменение размера динамического массива производится этой же процедурой:

SetLength(DynArray, 100);      // Теперь размер массива 100 элементов

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

При уменьшении размера динамического массива лишние элементы теряютяся.

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

Определение количества элементов производится с помощью функции Length:

N := Length(DynArray);          // N получит значение 100

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

DynArray[0] := 5;               // Присвоить начальному элементу значение 5
DynArray[High(DynArray)] := 10; // присвоить конечному элементу значение 10

К динамическим массивам, как и к обычным массивам, применимы функции Low и High, возвращающие минимальный и максимальный индексы массива соответственно. Для динамических массивов функция Low всегда возвращает 0.

Освобождение памяти, выделенной для элементов динамического массива, осуществляется установкой длины в значение 0 или присваиванием переменной-массиву значения nil (оба варианта эквивалентны):

SetLength(DynArray, 0); // Эквивалентно: DynArray := nil;

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

Также, как и при работе со строками, при присваивании одного динамического массива другому, копия уже существующего массива не создается.

      var
  A, B: arrayof Integer;
begin
  SetLength(A, 100);  // Выделить память для 100 элементов
  A[0] := 5;
  B := A;             // A и B указывают на одну и ту же область памяти!
  B[1] := 7;          // Теперь A[1] тоже равно 7!
  B[0] := 3;          // Теперь A[0] равно 3, а не 5!end.

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

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

      var
  A, B: arrayof Integer;
begin
  SetLength(A, 100); // Выделить память для 100 элементов
  A[0] := 10;
  B := A;            // B указывает на те же элементы, что и A
  A := nil;          // Память еще не освобождается, поскольку на нее указывает B
  B[1] := 5;         // Продолжаем работать с B, B[0] = 10, а B[1] = 5
  B := nil;          // Теперь ссылок на блок памяти нет. Память освобождаетсяend;

Для работы с динамическими массивами вы можете использовать знакомую по строкам функцию Copy. Она возвращает часть массива в виде нового динамического массива.

Не смотря на сильное сходство динамических массивов со строками, у них имеется одно существенное отличие: отсутствие механизма копирования при записи (copy-on-write).

2.18. Нуль-терминированные строки

Кроме стандартных строк ShortString и AnsiString, в языке Delphi поддерживаются нуль-терминированные строки языка C, используемые процедурами и функциями Windows. Нуль-терминированная строка представляет собой индексированный от нуля массив ASCII-символов, заканчивающийся нулевым символом #0. Для поддержки нуль-терминированных строк в языке Delphi введены три указательных типа данных:

      type
  PAnsiChar = ^AnsiChar;
  PWideChar = ^WideChar;
  PChar = PAnsiChar;

Типы PAnsiChar и PWideChar являются фундаментальными и на самом деле используются редко. PChar — это обобщенный тип данных, в основном именно он используется для описания нуль-терминированных строк.

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

      const
  S1: PChar = 'Object Pascal';               // #0 дописывается автоматически
  S2: array[0..12] of Char = 'Delphi/Kylix'; // #0 дописывается автоматическиvar
  S3: PChar;

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

S3 := S1;

переменная S3 получит адрес уже существующей строки 'Object Pascal'.

Для удобной работы с нуль-терминированными строками в языке Delphi предусмотрена директива $EXTENDEDSYNTAX. Если она включена (ON), то появляются следующие дополнительные возможности:

• массив символов, в котором нижний индекс равен 0, совместим с типом PChar;
• строковые константы совместимы с типом PChar.
• указатели типа PChar могут участвовать в операциях сложения и вычитания с целыми числами; допустимо также вычитание (но не сложение!) указателей.

В режиме расширенного синтаксиса допустимы, например, следующие операторы:

S3 := S2;     // S3 указывает на строку 'Delphi/Kylix'
S3 := S1 + 7; // S3 указывает на подстроку 'Pascal'

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

2.19. Переменные с непостоянным типом значений

2.19.1. Тип данных Variant

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

        program Console;

{$APPTYPE CONSOLE}uses
  SysUtils;

var
  V1, V2, V3, V4: Variant;

begin
  V1 := 5;             // целое число
  V2 := 0.8;           // вещественное число
  V3 := '10';          // строка
  V4 := V1 + V2 + V3;  // вещественное число 15.8
  Writeln(V4);         // 15.8
  Writeln('Press Enter to exit...');
  Readln;
end.

2.19.2. Значения переменных с типом Variant

Переменные с непостоянным типом содержат целые, вещественные, строковые, булевские значения, дату и время, массивы и др. Кроме того, переменные с типом Variant принимают два специальных значения: Unassigned и Null.

Значение Unassigned показывает, что переменная является нетронутой, т.е. переменной еще не присвоено значение. Оно автоматически устанавливается в качестве начального значения любой переменной с типом Variant.

Значение Null показывает, что переменная имеет неопределенное значение. Если в выражении участвует переменная со значением Null, то результат всего выражения тоже равен Null.

Переменная с типом Variant занимает в памяти 16 байт. В них хранятся текущее значение переменной (или адрес значения в динамической памяти) и тип этого значения.

Тип значения выясняется с помощью функции

VarType(const V: Variant): Integer;

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

        if VarType(V) and varTypeMask = varString then ...

Функция

VarAsType(const V: Variant; VarType: Integer): Variant;

позволяет вам преобразовать значение варьируемой переменной к нужному типу, например:

V1 := '100';
V2 := VarAsType(V1, varInteger);

Пока это все, что нужно знать о типе Variant, но мы к нему еще вернемся при обсуждении технологии COM Automation.

2.20. Delphi + ассемблер

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

2.20.1. Встроенный ассемблер

Пользователю предоставляется возможность делать вставки на встроенном ассемблере в исходный текст на языке Delphi.

К встроенному ассемблеру можно обратиться с помощью зарезервированного слова asm, за которым следуют команды ассемблера и слово end:

        asm
  <оператор ассемблера>
  ...
  <оператор ассемблера>
end;

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

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

        function Min(A, B: Integer): Integer; register;
asm
  CMP    EDX, EAX
  JGE    @@1
  MOV    EAX, EDX
  @@1:
end;

function Max(A, B: Integer): Integer; register;
asm
  CMP    EDX, EAX
  JLE    @@1
  MOV    EAX, EDX
  @@1:
end;

Обращение к этим функциям имеет привычный вид:

Writeln(Min(10, 20));
Writeln(Max(10, 20));

2.20.2. Подключение внешних подпрограмм

Программисту предоставляется возможность подключать к программе или модулю отдельно скомпилированные процедуры и функции, написанные на языке ассемблера или C. Для этого используется директива компилятора $LINK и зарезервированное слово external. Директива {$LINK <имя файла>} указывает подключаемый объектный модуль, а external сообщает компилятору, что подпрограмма внешняя.

Предположим, что на ассемблере написаны и скомпилированы функции Min и Max, их объектный код находится в файле MINMAX.OBJ. Подключение функций Min и Max к программе на языке Delphi будет выглядеть так:

        function Min(X, Y: Integer): Integer; external;
function Max(X, Y: Integer): Integer; external;
{$LINK MINMAX.OBJ}

В модулях внешние подпрограммы подключаются в разделе implementation.

2.21. Итоги

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

Сообщений 14    Оценка 115 [+2/-0]         Оценить