Ord — Функция Delphi


Содержание
Владимир Скуратов Реализация функции Ord в Delphi December 2020 1.3k раз Чисто как упражнение в домашних условиях , с целью лучше понять некоторые основы языка, я пытался переопределить Ord функцию, но я столкнулся с проблемой. В самом деле, существующая Ord функция может принимать аргументы множества различных типов ( AnsiChar , Char , WideChar , Enumeration , Integer , Int64 ) и может возвращать целое число или Int64. Я не могу понять, как объявить несколько версий одного и того же функции. Как это должно быть закодировано в Delphi? 2 ответы Ord не могут быть закодированы в Delphi. Хотя вы можете использовать в overload директиву , чтобы написать несколько функций с тем же именем, вы не можете написать Ord функцию , что путь , потому что он работает для произвольного числа типов аргументов без необходимости нескольких определений. (Независимо от того , сколько Ord перегружает вы пишете, я всегда могу придумать типа , что ваши функции не будут принимать , но это воли составителя.) Она работает таким образом из — за магии компилятора . Компилятор знает о Ord и о всех порядковых типах в программе, поэтому он выполняет действия функции в режиме реального времени . Другие компилятор магии функция включает в себя Length (магии , поскольку он принимает произвольные типы массива), Str (магии , потому что он принимает ширину и точность модификаторов), и ReadLn (магии , потому что она принимает произвольное число параметров). Я не могу понять, как объявить несколько версий одного и того же функции. Это называется функция перегрузки . Входные параметры должны быть различны для каждой версии, типа возвращаемого значения не имеет значения. Например: DelphiComponent.ru — бесплатно видеоуроки по Delphi, статьи, исходники Функции и процедуры для порядковых типов данных в Delphi XE Для порядковых типов есть несколько очень полезных функций и проце­дур, некоторыми из которых мы уже пользовались. Pred — функция, которая возвращает предыдущее значение выражения порядкового типа, указанного в скобках: Succ — функция, которая возвращает следующее значение: Легко заметить, что действие этой функции противоположно действию функции Pred , и наоборот. Ord — функция, которая возвращает порядковый номер значения в списке: Low — функция, которая возвращает минимальное значение указанного типа данных: High — функция, которая возвращает максимальное значение указанного типа данных: С помощью этих двух функций вы легко сможете определять диапазон значений любого порядкового типа. Ну, и ещё две процедуры, с которыми мы уже знакомы: Dec — функция декремента; уменьшает значение переменной типа integer на единицу: После выполнения функции Dec ( n ) значение переменной n станет равным 1. Можно уменьшить значение переменной на любое целое число: По своему действию эта функция эквивалентна оператору присваивания: но выполняется быстрее. Inc — процедура инкремента; увеличивает значение на единицу. После выполнения функции Inc ( n ) значение переменной n станет равным 3. Можно увеличить значение переменной на любое целое число: По своему действию эта функция эквивалентна оператору присваивания:
  • Глава 3.Типы данных
  • Ord — Функция Delphi
  • Реализация функции Ord в Delphi
  • 2 ответы
  • DelphiComponent.ru — бесплатно видеоуроки по Delphi, статьи, исходники
  • Функции и процедуры для порядковых типов данных в Delphi XE
  • Ord — Функция Delphi

    Здравствуйте
    Как работает функция Ord в delphi?
    Включил debug dcu — но отладчик не заходить в нее.

    Дело в том что я даю ей китайский знак «△» .
    и программа вываливается с Range Check error.
    Почему?
    Delphi 2009.

    Есть ли подобная функция для юникода?

    > Peace of cake (14.02.2010 00:10:01) [1]

    Врятли она вернёт что-то больше байта:

    function Ord(X: Char): Byte;

    читайте доки — они рулез :)

    >Включил debug dcu — но отладчик не заходить в нее.

    Она реализована т.н. compiler magic — ничего и не увидишь.

    >Есть ли подобная функция для юникода?

    Не знаю — наверняка что-то есть стандартное.

    Или доки таки неполные?


    > Есть ли подобная функция для юникода?

    var
    WC: WideChar;
    begin
    WC := «△»;
    Edit2.Text := WC + Format(» is %.4x», [Integer(WC)]);
    end;


    > и программа вываливается с Range Check error.
    > Почему?

    Возвращаемое фукнцией Ord значение имеет тип Byte


    > Игорь Шевченко © (14.02.10 00:36) [5]

    Т.е. в Дельфи 2009 и старше ее юзать низя?
    З.Ы. Сам я пока еще в шестерке работаю. Так, интересуюсь.


    > KilkennyCat © (14.02.10 12:51) [8]

    Да? И че она вернет? Byte или Integer? Или еще чего?

    The result is the ordinal position of X; its type is the smallest standard integer type that can hold all values of X»s type.

    Ord — Функция Delphi

    Описание
    Функция возвращает порядковый номер (индекс) выражения перечислимого (кроме Int64) или символьного типа, переданного в параметре X. Если аргумент имеет перечислимый тип, то функция возвращает индекс элемента (1-й элемент имеет индекс 0). Если Х представляет собой значение типа Char, то функция возвращает ASCII код символа.

    Пример
    type
    MyType = (x1, x2, x3, x4);
    var
    S: string;
    begin
    S:= ‘x3 имеет порядковый номер ‘+ IntToStr( Ord( x3 ))+ #13;
    S:= S+ ‘ASCII код символа «Б» — ‘ + IntToStr( Ord( ‘Б’ ))+ #13;
    S:= S+ ‘ASCII код символа «б» — ‘ + IntToStr( Ord( ‘б’ ));
    MessageDlg( S, mtInformation, [mbOk], 0);
    end;

    Реализация функции Ord в Delphi

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

    на самом деле, существующий Ord функция может принимать аргументы различных типов ( AnsiChar , Char , WideChar , Enumeration , Integer , Int64 ) и может возвращать Integer или Int64.

    Я не могу понять, как объявить несколько версий одной и той же функции.

    как это должно быть закодировано в Дельфи?

    2 ответов

    Ord невозможно закодировать в Delphi. Хотя вы можете использовать на overload директива чтобы написать несколько функций с тем же именем, вы не можете написать Ord функция таким образом, потому что она работает для произвольного числа типов аргументов без необходимости нескольких определений. (Сколько бы их ни было!—0 перегрузки вы пишете, Я всегда могу придумать тип, который ваши функции не примут, но что компилятор будет.)

    это работает, потому компилятор магии. Компилятор знает о Ord и обо всех порядковых типах в программе, поэтому он выполняет действия функции в строке. Другие функции компилятора-magic включают Length (магия, потому что она принимает произвольные типы массивов), Str (магия, потому что она принимает модификаторы ширины и точности) и ReadLn (магия, потому что она принимает произвольное количество параметров).

    Классификация типов данных в Delphi. Типы с плавающей точкой (Double, Single, Real, Extended)

    Типы бывают: 1)Простые/Порядковые (целый, логический, символьный, перечисляемый, диапазон (интервальный тип)); 2)Вещественный; 3)Структурированные(массивы, записи, файлы, классы, интерфейсы); 4)Строки; 5)Указатели; 6)Вариант; 7)Процедурный тип.

    Типы с плавающей точкой:

    Тип Размер(byte) Кол-во значащих цифр Диапазон
    Single 7-8 1.5e-45 … 3.4e38
    Double 15-16 5.0e-324 . 1.7e308
    Real 11-12 2.9e-39 … 1.7e38
    Extended 19-20 3.4e-4951 … 1.1e4932

    S-e-m

    Здесь m – знаковый разряд числа; e – экспоненциальная часть (содержит двоичный порядок); m – мантисса числа.

    Мантисса m имеет длину от 23 (для Single) до 63 (для Extended) двоичных разрядов, что и обеспечивает точность 7-8 для Single и 19-20 для Extended десятичных цифр. Десятичная точка(запятая) подразумевается перед левым (старшим) разрядом мантиссы, но при действиях с числом она сдвигается влево и вправо в соответствии с двоичным порядком числа, хранящимся в экспоненциальной части, поэтому действия над вещественными числами называют арифметикой с плавающей точкой(запятой).
    Особые операции :
    Round( r ) – 3 округление (r= 2.6);
    Trunc ( 2.8 ) – 2 целая часть;
    Int (2.8 ) – 2.0 округление дробной части;
    Frac (2.8) – 0.7 дробная часть.
    11. Порядковые типы. Целые типы в Delphi, тип диапазон

    К порядковым типам относятся целые типы, логический и символьный типы, а так же перечисления и тип-диапазон(пользовательский тип). К любому из них применима функция ORD(X) , которая возвращает порядковый номер значения выражения X. Для целых типов ORD(X) возвращает само значение X. Применение к логическому, символьному и к перечислениям дает «+» целое число в диапазоне 0-1(лог. тип), 0-255 (символьный), 0-65535 (перечисление). У типа-диапазон результат применения ord(x) зависит от свойств базового порядкового типа.
    Так же к порядковым типам можно применять функции:
    PRED(X) – возвращает предыдущее значение порядкового типа ( ord(pred(x)) = ord(x)-1).

    SUCC(X)– возвращает следующее значение порядкового типа( ord(succ(x)) = ord(x)+1).
    Вот некоторые целые типы :

    Название типа Размер в байтах Диапазон
    Byte 0…255
    Shortint -128…127
    Word 0…65535
    Integer -2147483647…2147483295

    К типам применимы следующие функции :

    Abs(x)–возвращает модуль X

    Chr(x)–возвращает символ по его коду

    Dec(x)–уменьшает значение на 1

    Inc(x)–увеличивает значение на 1
    Div–целочисленное деление

    Mod–дробная часть деления

    Sqr(x)–возвращает квадрат X

    А так же операции *,/,+,.
    При работе с данными, нужно следить за тем, чтобы они не выходили за границы диапазона значений.
    Тип-диапазон – это подмножество своего базового типа, в качестве которого может выступать любой порядковый тип, кроме типа-диапазона. Задается границами своих значений внутри базового типа : .. .Есть две функции : HIGH(x) — возвращает максимальное значение типа-диапазона, к которому принадлежит переменная Х.
    LOW(x) — возвращает минимальное значение типа-диапазона.

    12.Порядковые типы. Символьный тип. Таблица символов.
    Значениями символьного типа является множество символов компьютера. Каждому символу присваивается целое число в диапазоне от 0 до 255. Это число служит кодом внутреннего представления символа, его возвращает функция ORD. В Delphi 7 есть три символьных типа :

    Тип ANSIChar представляет собой так называемые Ansi-символы. Это символы, которые используются в операционных системах семейства Windows(размером 1 байт). Тип WideChar предназначен для хранения так называемых Unicode-символов, которые в отличие от Ansi-симвояов занимают два байта. Это позволяет кодировать символы числами от 0 до 65535 и используется для представления различных азиатских алфавитов. Первые 256 символов в стандарте Unicode совпадают с символами Аnsi.Тип Char в Delphi 7 эквивалентен типу AnsiChar и обеспечивает наибольшую производительность. Для отображения множества символов в подмножество натуральных чисел и обратно имеются следующие две стандартные функции:

    ord(c) — дает порядковый номер символа с;
    chr(i) — дает символ с порядковым номером i.
    UpCase(CH) – возвращает прописную букву, если CH– строчная латинская буква, в противном случае возвращает сам символ.
    Length( ) – функция, результатом которой является длина указанной строки.
    13.Логический тип. Логические операторы и операции сравнения.
    Значениями логического типа может быть одна из предварительно объявленных констант False или True.
    Ord (False) =0; Ord (True) = 1; False

    14.Порядковые типы. Перечисляемый тип.(пользовательский тип)
    Перечисление, или перечисляемый тип
    , задается перечислением тех значений, которые он может получать. Каждое значение именуется некоторым идентификатором и располагается в списке, обрамленном круглыми скобками, например :
    Type
    TSound = (‘ click, clack, clock’);

    Описание переменных : var snd:TSound;
    Особые операции:
    ord(snd) – возвращает номер значения по порядку начиная с нуля(нумерацию можно начинать с единицы, если в типе указать : Type TSound = (‘click’=1,’ clack, clock’).

    15.Тип массив(статический) : описание, ввод, вывод. Форматный вывод.
    Это пользовательский тип.
    Отличительная особенность массивов заключается в том, что все их компоненты – суть данные одного типа. Эти компоненты можно легко упорядочить и обеспечить доступ к любому из них простым указанием его порядкового номера.
    Описание типа массива : = array [ ] of ;
    – правильный идентификатор; array,of – зарезервированные слова(массив, из); – список из одного или нескольких индексных типов, разделенных запятыми; – любой тип Паскаля.
    В качестве индексных типов в Паскале можно использовать любые порядковые типы, кроме LongInt и типов-диапазонов с базовым типом LongInt.
    Обычно в качестве индексного типа используется тип-диапазон, в котором задаются границы индексов. Так как тип за словом of,– это любой тип Паскаля, он может быть, в частности, и другим массивом, например :
    type mat = array [0..5,-1..2,Char] of Byte.

    Ввод и вывод begin a.b : =100; writeln(a.b); End.

    16.Тип запись : описание, ввод, вывод, Оператор With. Запись с вариантами.
    Запись
    – это структура данных, состоящая из фиксированного количества компонентов, называемых полями записи. В отличие от массива компоненты (поля) записи могут быть различного типа. Чтобы можно было ссылаться на тот или иной компонент записи, поля именуются.
    Структура объявления типа записи такова :
    = record end;
    – правильный идентификатор ;record,end – зарезервированные слова(запись, конец); – список полей, представляющий собой последовательность разделов записи, между которыми ставится точка с запятой. Каждый раздел записи состоит из одного или нескольких идентификаторов полей, отделяемых друг от друга запятыми. За идентификатором(-ми) ставится двоеточие и описание типа поля(-ей).
    Описание : type BirthDay = record
    day, month : Byte;
    year : Word end;
    var a, b: BirthDay;

    К каждому из компонентов записи можно получить доступ, если использовать составное имя, то есть указать имя переменной, затем точку и имя поля : a. Day : = 27
    Для вложенных полей приходится продолжать уточнения :
    Type BirthDay = record …. End;
    var c : record
    name : String ;
    bd : BirthDay ;
    end;
    begin
    …. If c. bd. Year = 1939 then
    end.
    Чтобы упростить доступ к полям записи, используется оператор присоединения WITH :
    with do
    with, do – ключевые слова ( с, делать) ; – имя переменной типа запись, за которой, возможно, следует список вложенных полей; – любой оператор Паскаля.
    Например : with c. bd do month : = 9;
    В Паскале допускается использовать записи с так называемыми вариантными полями, например :
    Type Forma = record
    Name :String ;
    case Byteof
    0 : (BirthPlace : String [40] ) ;
    1 : ( Country : String [20] ) ;
    end;
    17.Тип множество : описание, ввод, вывод, операции над множествами.
    Множество
    – это наборы однотипных, логически связанных друг с другом объектов. Характер связей между объектами лишь подразумевается программистом и никак не контролируется в Паскалем. Количество элементов, входящих в множество, может меняться в пределах от 0 до 256. Именно непостоянством количества своих элементов множества отличаются от массивов и записей.
    Два множества эквивалентны ó все их элементы одинаковые, причем порядок следования может быть разным. Если одни элементы одного множества входят также и в другое, то говорят о включении первого множества во второе.
    Пример определения и задания множеств :
    type
    digitChat = set of ‘0’ .. ‘9’ ;
    var s1,s2,s3: digitChar;

    Ввод и вывод : S1:=[ 1..10]; … Writeln(s1); End.

    S2:=[‘2’,’3’,’1’];
    s3:=[‘2’,’3’];

    end.
    В этом примере s1 и s2 эквивалентны, а s3 включено в s2, но не эквивалентно ему.
    Описание :
    = set of
    – правильный идентификатор;set, of – зарезервированные слова (множество, из); – базовый тип элементов множества, в качестве которого может использоваться любой порядковый тип, кроме Word, Integer, LongInt.
    Над множествами определены следующие операции :
    а) пересечение множеств (*) – результат содержит элементы, общие для обоих множеств.
    б) объединение множеств (+) – результат содержит элементы первого множества, дополненные элементами из второго множества.
    в) разность множеств (-) – результат содержит элементы первого множества, которые не принадлежат второму.
    г) проверка эквивалентности (=) – возвращает True, если оба множества эквивалентны.
    д) проверка неэквивалентности (<>) – возвращает True, если оба множества неэквивалентны.
    е) проверка вхождения первого множества во второе ( =) – возвращает True, если второе множество включено в первое.
    з)проверка принадлежности (in) – в этой бинарной операции первый элемент – выражение, а второй – множество одного и того же типа; возвращает True если выражение имеет значение, принадлежащее множеству, (см. предыдущий пример) 1 in s1 возвращает True, а 2*2 in s2 возвращает False.
    и) Include – включает новый элемент в множество ( Include (S, I), здесь S- множество, I – элемент)
    Exclude – исключает элемент из множества ( Exclude (S, I)).

    18.Текстовый файл : описание файловой переменной, основные операции. Использование параметров программы для передачи программе имен файлов.
    Текстовый файл – совокупность строк (последовательностей символов) переменной длины, заканчивающихся специальным символом eoln (конец строки; на клавиатуре набирается нажатием клавиши Enter).
    Описание файловой переменной : : TextFile; или просто Text.
    Первоначально любой файл данных создается как текстовый. Набранные на клавиатуре данные представляют собой стандартный входной файл. Содержимое дисплея при просмотре любого файла – стандартный выходной файл. Эти файлы используются при задании и просмотре данных. Для хранения данных последние записываются в файл на внешнем запоминающем устройстве (диске).

    Основные операторы для работы с текстовыми файлами:
    assignFile( ,’ ’) – связывает файловую переменную с файлом;
    rewrite( ) – создание и открытие нового файла для записи;
    reset ( ) – открытие существующего текстового файла (файла, связанного с файловой переменной ) для чтения;
    append( ) – открытие существующего текстового файла (файла, связанного с файловой переменной ) для дозаписи в конец;
    closeFile( ) – закрытие открытого файла.

    Операторы ввода-вывода:
    read( , ) – чтение данных; элемент списка ввода для текстового файла – число или символ или строка string;
    write( , ) — запись данных согласно списку вывода; элемент списка вывода для текстового файла – число или символ или строка string.
    readln( , ) — чтение данных согласно списку ввода и переход на следующую строку; если в строке данных остались данные, не вошедшие в список ввода, они игнорируются
    writeln( , ) — запись данных в файл согласно списку вывода с добавлением в конце выведенной строки маркера конца строки (переход на следующую строку).
    Параметры :
    assignFile(dat, ParamStr(1));
    assignFile(res, ParamStr(2));
    ParamStr – стандартная функция для работы с параметрами в Delphi, она возвращает параметр с заданным номером. Ее синтаксис:
    function ParamStr( : word): string;

    Все параметры трактуются как отдельные строки (string). Параметры пользователя нумеруются, начиная с единицы. В нулевом параметре ParamStr(0) ОС передает программе полное имя запускаемого приложения (например, D:\Гречкина\Project1.exe). Этот (нулевой) параметр не входит в общее число параметров, которое можно узнать с помощью функции ParamCount: function ParamCount: word.
    19.Назначение и отличие процедур общего вида и функций.
    Назначение
    . Подпрограммы (процедуры и функции) представляет собой инструмент, с помощью которого любая программа может быть разбита на ряд в известной степени независимых друг от друга частей. Такое разбиение необходимо по двум причинам :
    1)Средство экономии памяти.
    2)Применение методики нисходящего проектирования, благодаря которой достигаются достаточно простые алгоритмы, которые можно легко запрограммировать.
    Отличие : Процедуры и функции представляют собой относительно самостоятельные фрагменты программы, оформленные особым образом и снабженные именем. Отличие процедуры от функции заключается в том, что результатом исполнения операторов, образующие тело функции, всегда является некоторое единственное значение или указатель, поэтому вызов функции, поэтому вызов функции можно использовать в соответствующих выражениях наряду с переменными и константами.
    20. Описание и вызов процедур.
    Формат описания процедуры имеет вид:

    procedure имя процедуры (формальные параметры);

    раздел описаний процедурыbegin исполняемая часть процедурыend;
    Вызов:
    имя процедуры (формальные параметры);


    21. Описание и вызов функций.
    Формат описания функции:

    function имя функции (формальные параметры):тип результата;

    раздел описаний функции

    begin
    исполняемая часть функции
    end;Вызов:
    Имя переменной:=имя функции (формальные параметры);…
    ИЛИ
    имя процедуры (имя функции (формальные параметры));
    22. Классы формальных параметров: параметры-константы, параметры-значения, параметры-переменные. Ключевые слова const, var, out при описании параметров.Параметры-значения

    Формальный параметр-значение обрабатывается, как локальная по отношению к процедуре или функции переменная, за исключением того, что он получает свое начальное значение из соответствующего фактического параметра при активизации процедуры или функции. Изменения, которые претерпевает формальный параметр-значение, не влияют на значение фактического параметра.
    Соответствующее фактическое значение параметра-значения должно быть выражением и его значение не должно иметь файловый тип или какой-либо структурный тип, содержащий в себе файловый тип.
    Фактический параметр должен иметь тип, совместимый по присваиванию с типом формального параметра-значения. Если параметр имеет строковый тип, то формальный параметр будет иметь атрибут размера, равный 255.
    Параметры-константы
    Формальные параметры-константы работают аналогично локальной переменной, доступной только по чтению, которая получает свое значение при активизации процедуры или функции от соответствующего фактического параметра. Присваивания формальному параметру-константе не допускаются. Формальный параметр-константа также не может передаваться в качестве фактического параметра другой процедуре или функции.
    Параметр-константа, соответствующий фактическому параметру в операторе процедуры или функции, должен подчиняться тем же правилам, что и фактическое значение параметра.
    В тех случаях, когда формальный параметр не изменяет при выполнении процедуры или функции своего значения, вместо параметра-значения следует использовать параметр-константу. Параметры-константы позволяют при реализации процедуры или функции защититься от случайных присваиваний формальному параметру. Кроме того, для параметров структурного и строкового типа компилятор при использовании вместо параметров-значений параметров-констант может генерировать более эффективный код.
    Параметры-переменные
    Параметр-переменная используется, когда значение должно передаваться из процедуры или функции вызывающей программе. Соответствующий фактический параметр в операторе вызова процедуры или функции должен быть ссылкой на переменную. При активизации процедуры или функции формальный параметр-переменная замещается фактической переменной, любые изменения в значении формального параметра-переменной отражаются на фактическом параметре.
    Внутри процедуры или функции любая ссылка на формальный параметр-переменную приводит к доступу к самому фактическому параметру. Тип фактического параметра должен совпадать с типом формального параметра-переменной (вы можете обойти это ограничение с помощью нетипизированного параметра-переменной).
    Примечание: Файловый тип может передаваться только, как параметр-переменная.
    23. Массивы и записи как формальные параметры процедур и функций.
    Объявление :
    Type mas = array [1..100] of integer;
    procedure massiv ( a : mas);

    Открытый массив представляет собой формальный параметр подпрограммы, описывающий базовый тип элементов массива, но не определяющий его размерности и границы
    procedure MyProc( OpenArray : array of Integer);
    Внутри такой параметр трактуется как одномерный массив с нулевой нижней границей. Верхняя граница открытого массива возвращается функцией High.Используя 0 как минимальный индекс, подпрограмма может обрабатывать одномерные массивы произвольной длины.
    24. Имена процедур и функций как фактические параметры процедур( Процедурный тип).
    Процедурные типы — это нововведение фирмы Borland (в стандартном Паскале таких типов нет). Основное назначение этих типов — дать программисту гибкие средства передачи функций и процедур в качестве фактических параметров обращения к другим процедурам и функциям.
    Для объявления процедурного типа используется заголовок процедур, в котором опускается ее имя, например:
    type
    Proc = procedure (a, b, с : Real; Var d : Real);
    Proc2 = procedure (var a, b);
    РгосЗ = procedure;
    Func1 = function : String;
    Func2 = function ( var s : String) : Real;
    В программе могут быть объявлены переменные процедурных типов, например,так:
    var
    р1 : Proc;
    ар : array [1..N] of Proc1;
    Переменным процедурных типов допускается присваивать в качестве значений имена соответствующих подпрограмм. После такого присваивания имя переменной становится синонимом имени подпрограмм.
    В отличие от стандартного Паскаля, в Турбо Паскале разрешается использовать в передаваемой процедуре как параметры-значения, так и параметры-переменные
    <ознакомиться с файлом ProcType на сайте Гречкиной>
    25.Модули в Паскале : назначение, описание, использование. Обязательные и дополнительные разделы.
    Модуль
    – это автономно контролируемая программная единица, включающая в себя различные компоненты раздела описаний ( типы, константы, переменные, процедуры и функции) и, возможно, некоторые исполняемые операторы инициализирующей части.
    Структура модуля :
    unit ;
    interface

    implementation

    begin

    end.
    Если в модуле используются другие модули, то нужно объявить их словом uses,оно можется следовать сразу за словом interface, либо сразу за словом implementation, либо и там и там.
    unit – зарезервированное слово( единица); interface – зарезервированное слово (интерфейс), начинающее интерфейсную часть модуля; implementation – зарезервированное слово(выполнение), начинающее исполняемую часть модуля; begin – зарезервированное слово, начинающее инициализирующую часть модуля(эта конструкция begin необязательна); end – зарезервированное слово, являющееся признаком конца модуля.
    В части interface содержатся объявления всех глобальных объектов модуля, которые должны стать доступными основной программе и(или) другим модулям.
    В части implementation содержит описания подпрограмм, объявленных в интерфейсной части. В ней могут объявляться локальные для модуля объекты – вспомогательные типы, константы, переменные и блоки, а так же метки, если они используются в инициализирующей части.
    В инициализирующей части (begin как это слово, так и вся эта часть может отсутствовать или быть пустой) размещаются исполняемые операторы, содержащие некоторый фрагмент программы. Эти операторы исполняются до передачи управления основной программе и обычно используются для подготовки ее к работе. Например, в них могут инициализироваться переменные, открываться нужные файлы и т.д.
    Для использования в программе модуля или списка модулей необходимо в начале программы поместить оператор uses, после которого уже указывать модули :
    program Lalala;
    uses aUnit, bUnit, cUnit;
    26.Составление функциональных и структурированных тестов.
    Функциональные тесты проверяют правильность работы программы по принципу: «не знаю как сделано, но знаю, что должно быть в результате, и именно это и проверяю».
    К функциональным тестам относятся:
    · «тепличные», проверяющие программу при корректных, нормальных значениях исходных данных
    · «экстремальные» («стресс–тесты»), находящиеся на границе области определения (например, наибольшая или наименьшая нагрузка системы по количеству или по времени), проверяющие поведение системы в экстремальных ситуациях, которые могут произойти и на которые программа должна корректно реагировать.
    · «запредельные» («тесты обезьяны»), выходящие за границы области определения (а возможно, и здравого смысла), проверяющие ситуации, бессмысленные с точки зрения постановки задачи, но которые могут произойти из-за ошибок пользователя (корректная реакция системы на запрещенный или неподдерживаемый ввод и т.п., так называемая «защита от дурака»)
    Структурные тесты контролируют (тестируют) работу всех структурных частей программы (функций, процедур, модулей, основной программы) по всем возможным маршрутам (ветвям программы).
    При структурном тестировании необходимо осуществлять контроль:
    · обращений к данным (т.е. проверять правильность инициализации переменных; а также размеры массивов и строк; отслеживать, не перепутаны ли строки со столбцами; соответствуют ли входных и выходных значений выбранным типам данных; проверять правильность обращения к файлам и т.п.);
    · вычислений (порядок следования операторов и запись выражений; переполнение разрядной сетки или получение машинного нуля; соответствие результата заданной точности и т.п.);
    · передачи управления (завершение циклов, функций, программы);
    · межмодульных интерфейсов (списки формальных и фактических параметров; отсутствие побочных эффектов, когда подпрограмма изменяет аргументы, которые не должны меняться и т.п.).
    Искусство тестирования сводится к разработке простого, полного и не избыточного набора тестов, а технология тестирования – к испытанию программы на всем наборе тестов, после внесения в нее каждого изменения.
    20. Нисходящее и восходящее тестирование программ. Достоинства и недостатки. Использование заглушек и драйверов.
    Восходящее тестирование.

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

    Реализация функции Ord в Delphi

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

    В самом деле, существующая Ord функция может принимать аргументы множества различных типов ( AnsiChar , Char , WideChar , Enumeration , Integer , Int64 ) и может возвращать целое число или Int64.

    Я не могу понять, как объявить несколько версий одного и того же функции.

    Как это должно быть закодировано в Delphi?

    Я не могу понять, как объявить несколько версий одного и того же функции.

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

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

    Она работает таким образом из — за магии компилятора . Компилятор знает о Ord и о всех порядковых типах в программе, поэтому он выполняет действия функции в режиме реального времени . Другие компилятор магии функция включает в себя Length (магии , поскольку он принимает произвольные типы массива), Str (магии , потому что он принимает ширину и точность модификаторов), и ReadLn (магии , потому что она принимает произвольное число параметров).

    Использование процедур и функций в Delphi

    Скобки

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

    Возможность перегрузки

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

    procedure Test (I: integer); overload;
    procedure Test (S: string); overload;
    procedure Test (D: double); overload;

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

    Передача параметров

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

    Передача параметров по значению

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

    procedure Test(s: string);

    При вызове указанной процедуры будет создана копия передаваемой ей в качестве параметра строки s, с которой и будет работать процедура Test. При этом все внесенные в строку изменения никак не отразятся на исходной переменной s.

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

    Передача параметров по ссылке

    Pascal позволяет также передавать параметры в функции или процедуры по ссылке — такие параметры называются параметрами-переменными. Передача параметра по ссылке означает, что функция или процедура сможет изменить полученные значения параметров. Для передачи параметров по ссылке используется ключевое слово var, помещаемое в список параметров вызываемой процедуры или функции.

    procedure ChangeMe(var x: longint);
    begin
    x := 2; // Параметр х изменен вызванной процедурой
    end;

    Вместо создания копии переменной x, ключевое слово var требует передачи адреса самой переменной x, что позволяет процедуре непосредственно изменять ее значение.

    Передача параметров констант

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

    procedure Test(const s: string );

    Передача открытых массивов

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

    function AddEmUp(A: array of integer): integer;

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

    Для получения информации о фактически передаваемом массиве параметров в функции или процедуре могут использоваться функции High, Low и SizeOf.

    Object Pascal также поддерживает тип array of const, который позволяет передавать в одном массиве данные различных типов. Синтаксис объявления функций или процедур, использующих такой массив для получения параметров, следующий:

    procedure WhatHaveIGot( A: array of const );

    Вызвать объявленную выше функцию можно, например, с помощью такого оператора:

    procedure WhatHaveIGot( [‘Text’, 10, 5.5, @WhatHaveIGot, 3.14, true, ‘c’] );

    При передаче функции или процедуре массива констант все передаваемые параметры компилятор неявно конвертирует в тип TVarRec. Тип данных TVarRec объявлен в модуле System следующим образом:

    PVarRec = ^TVarRec;
    TVarRec = record
    case Byte of
    vtInteger: (VInteger: Integer; VType: Byte);
    vtBoolean: (VBoolean: Boolean);
    vtChar: (VChar: Char);
    vtExtended: (VExtended: PExtended);
    vtString: (VString: PShortString);
    vtPointer: (VPointer: Pointer);
    vtPChar: (VPChar: PChar);
    vtObject: (VObject: TObject);
    vtClass: (VClass: TClass);
    vtWideChar: (VWideChar: WideChar);
    vtPWideChar: (VPWideChar: PWideChar);
    vtAnsiString: (VAnsiString: Pointer);
    vtCurrency: (VCurrency: PCurrency);
    vtVariant: (VVariant: PVariant);
    vtInterface: (VInterface: Pointer);
    vtWideString: (VWideString: Pointer);
    vtInt64: (VInt64: PInt64);
    end;

    Поле VType определяет тип содержащихся в данном экземпляре записи TVarRec данных и может принимать одно приведенных значений.

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

    procedure WhatHaveIGot( A: array of const );
    var
    i: integer;
    TypeStr: string;
    begin
    for i := Low(A) to High(A) do
    begin
    case A[i].VType of
    vtInteger : TypeStr := ‘Integer’;
    vtBoolean : TypeStr := ‘Boolean’;
    vtChar : TypeStr := ‘Char’;
    vtExtended : TypeStr := ‘Extended’;
    vtString : TypeStr := ‘String’;
    vtPointer : TypeStr := ‘Pointer’;
    vtPChar : TypeStr := ‘PChar’;
    vtObject : TypeStr := ‘Object’;
    vt ;
    vtW ;
    vtPW ;
    vtAnsiString : TypeStr := ‘AnsiString’;
    vtCurrency : TypeStr := ‘Currency’;
    vtVariant : TypeStr := ‘Variant’;
    vtInterface : TypeStr := ‘Interface’;
    vtW ;
    vtInt64 : TypeStr := ‘Int64’;
    end;
    ShowMessage( Format( ‘Array item %d is a %s’, [i, TypeStr] ) );
    end;
    end;

    Значения параметров по умолчанию

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

    procedure HasDefVal( s: string; i: integer = 0 );

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

    procedure HasDefVal( ‘Hello’, 26 );

    Во втором случае можно задать только значение параметра s, а для параметра i использовать значение, установленное по умолчанию:

    procedure HasDefVal( ‘Hello’ );

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

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

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

    function Add( I1, I2: integer ): integer;
    begin
    Result := I1 + I2;
    end;

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

    function Add( I1, I2: integer; I3: integer = 0 ): integer;
    begin
    Result := I1 + I2 + I3;
    end;

    Директива

    Директива <$X->запрещает вызов функций как процедур (с игнорированием возвращаемого результата). По умолчанию этот режим включен (<$X+>). Так вот, запомните, использование переменной Result недопустимо при сброшенном флажке опции Extended Syntax, расположенном во вкладке Compiler диалогового окна Project Options, или при указании директивы компилятора <$X->.

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

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

    Глава 3.Типы данных

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

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

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

    Что же касается объявлений var, то они задают компилятору некоторые действия, связанные с ранее объявленными типами. Тип переменной ограничивает как ее значения, так и операции, которые можно выполнять с этими значениями.

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

    type1 = type definition; //Новые типы данных определяются в разделе //«type».

    // типу присваивается имя, затем он определяется через уже

    type2 = typedefinition2; // В одном разделе «type» можно

    //объявить несколько типов.

    //Самое простое определение типа состоит из имени типа,

    type3 = type1; // определенного ранее.

    // Новые переменные объявляются в

    var // разделе «var». Каждой новой

    var1: type definitions; // переменной сначала присваивается имя, а затем — тип (на основе

    // ранее определенных типов).

    var2, var3: type definition4; // В одном разделе «var» можно объявить несколько переменных.

    // Нескольким переменным можно присваивать один и тот же тип.

    var4: type1; // Программу легче читать, если переменным присвоены

    Синтаксис Object Pascal позволяет одновременно конструировать исключительно сложные типы и определение переменных. Однако определение типов в разделах type тех или иных блоков дает возможность использовать эти типы в разных частях программы. Новые типы определяются из типов следующих категории.

    Простые типы для хранения информации в форме чисел и других «упорядоченных» значении.

    Строковые типы для хранения последовательностей символов.

    Структурные типы для одновременного хранения информации разных типов.

    Указательные типы для косвенного обращения к переменным заданных типов.

    Процедурные типы для обращения к процедурам и функциям, рассматриваемым как переменные.

    Вариантные типы для хранения в одной переменной данных различных типов.

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

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

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

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

    Из простых типов данных порядковые — самые простые. В этих типах информация представляется в виде отдельных элементов. Связь между отдельными элементами и их представлением в памяти определяет естественные отношения порядка между этими элементами. Отсюда и название порядковые.

    В Object Pascal определены три группы порядковых типов и два типа, определяемых пользователем. Группы — это целые, символьные и булевы типы. Порядковые типы, задаваемые пользователем, — это перечисления и поддиапазоны.

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

    Для всех порядковых типов в Object Pascal существует операция задания типа для преобразования целых значений в значения соответствующих порядковых типов. Если Т — имя порядкового типа, а Х — целое выражение, то Т (X) воз-вращает значение Т с порядковым номером X.

    Совет: Программисты, работающие на С и C++, для приращения или уменьшения значений переменных привыкли заметку использовать операторы «++» и «-», возвращающие следующее и предыдущее значения. Программисты Delphi всегда разбивают эти операции на более простые составляющие с помощью функций Pred, Succ. Dec и Inc.

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

    Обратите внимание, что один из этих целых типов назван именно целым (integer). Это может иногда приводить к путанице, но мы легко сможем ее избежать, применяя термин целый к группе типов, a integer — к конкретному типу, определяемому в программе этим ключевым словом. Переменные физических целых типов имеют разные диапазоны значений в зависимости от того, сколько байтов памяти они занимают (что равно значению, возвращаемому функцией SizeOf для данного типа). Диапазоны значений для всех физических типов перечислены в табл. 1.2.

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

    Диапазоны значений логических целых типов (Integer и Cardinal) определяются совершенно иным образом. Как видно из табл. 1.3, они никак не связаны с диапазонами соответствующих физических типов. Обратите внимание, что в Delphi по умолчанию задано 32-разрядное представление.

    Совет: В С и C++ для целых значений определены типы int, short int (или просто short) и long int (или просто long). Тип int из C/C++ соответствует типу Integer из Delphi, a long из C/C++ — Longint из Delphi. Однако Shortint из C/C++ соответствует в Delphi не Shortint, a Smalltlnt. Эквивалент Shortint из Delphi в C/C++— это signed char. Тип unsigned char в C/C++ соответствует типу Byte из Delphi. В C/C++ существует еще тип unsigned long, аналога которому в Delphi нет.

    Над целыми данными выполняются все операции, определенные для порядковых типов, но с ними все же удобнее работать как с числами, а не с «нечисленными порядковыми типами». Как и «живые» числа, данные целых типов можно складывать (+), вычитать (-) и умножать (*). Однако некоторые операции и функции, применяемые к данным целых типов, имеют несколько иной смысл.

    Abs (X) Возвращает абсолютное целое значение Х

    Х Div Y Возвращает целую часть частного деления Х на Y

    Х Mod Y Возвращает остаток частного деления Х на Y

    Odd (X) Возвращает булево True (истина), если Х — нечетное целое, и False (ложь) — в противном случае

    Sqr (X) Возвращает целый квадрат Х (т. е. Х*Х)

    Совет: Будьте внимательны при перенесении численных выражений из одного языка в другой. В Basic, например, функция SQR вычисляет квадратный корень. В C/C++ целое деление обозначается косой чертой (/). В Delphi косая между двумя целыми даст действительный результат с плавающей запятой.

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

    В реализациях языка Pascal для первых микропроцессоров была применена 7-битовая схема, названная ASCII (American Standard Code for Information Interchange — Американский стандартный код для обмена информацией). Эта схема и поныне широко распространена, но информация хранится, как правило, в 8-битовых участках памяти. Дополнительный бит удваивает число возможных представлений символов, но реализации расширенного набора символов ASCII часто бывают далеки от стандарта. В данной версии Delphi определен набор 8-битовых символов, известный как расширенный (extended) ANSI (American National Standards Institute — Американский национальный институт стандартов). Как бы то ни было, символьную схему приходится воспринимать так, как ее воспринимает операционная система. Для оконных операционных систем фирмы Microsoft это схема ANSI, включающая ограниченное число предназначенных для вывода международных знаков. В стремлении же применить более обширный набор международных знаков весь компьютерный мир переходит к 16-битовой схеме, именуемой UNICODE, в которой первые 256 знаков совпадают с символами, определенными в схеме ANSI.

    Для совместимости со всеми этими представлениями в Object Pascal определены два физических символьных типа и один логический.

    Физические типы перечислены ниже.

    Однобайтовые символы, упорядоченные в соответствии с расширенным набором символов ANSI

    Символы объемом в слово, упорядоченные в соответствии с международным набором символов UNICODE. Первые 256 символов совпадают с символами ANSI

    Символьные типы объемом в двойное слово (32 бит) отсутствуют.

    Логический символьный тип именуется char. В классическом языке Pascal char— единственный символьный тип. В Delphi char всегда соответствует физическому типу данных AnsiChar. У американских программистов ассоциация символа с однобайтовой ячейкой памяти укоренилась за долгие годы настолько, что им зачастую просто не приходит в голову, что можно использовать другие схемы кодирования. Однако дискуссии по интернационализации программ в Internet и World Wide Web могут существенно изменить их отношение к проблеме объема символьных данных. Применяя логический тип char, следует делать реализации для других микропроцессоров и операционных систем, в которых char может определяться как WideChar. При написании программ, которые могут обрабатывать строки любого размера, для указания этого размера рекомендуется применять функцию SizeOf, не задавая ее жестко постоянной. Функция Ord (С), где С — любая переменная символьного типа, возвращает целое значение, которым символ С представлен в памяти.

    Преобразует целую переменную в переменную типа char с тем же порядковым номером. В Delphi это эквивалентно заданию типа Char (X)

    Преобразует строчную букву в прописную

    Совет: Процессор не различает типы char, определенные в C/C++ и Delphi. Однако функционально каждый из этих языков трактует данный тип совершенно по-разному. В C/C++ это целый тип, переменной которого можно присваивать целые значения. Переменной int можно присвоить символьное значение, а переменной char — целое. В Delphi символьные типы жестко отделены от численных. Для присвоения численному значению символьного здесь необходимо воспользоваться функцией Ord. В языке Basic один символ представляется так же, как и строка символов. Функция Chr из Delphi эквивалентна функции CHRS из Basic. Функция Ord из Delphi, возвращающая код ANSI символьной переменной, подобна функции A3 С из Basic, аргумент которой представляет односимвольную строку.

    На ранней стадии обучения программисты осваивают понятие бита, два состояния которого можно использовать для записи информации о чем-либо, представляющем собой одно из двух. Бит может обозначать 0 или 1, ДА или НЕТ, ВКЛЮЧЕНО или ВЫКЛЮЧЕНО, ВЕРХ или НИЗ, СТОЯТЬ или ИДТИ. В Object Pascal информация о чем-либо, что можно представить как ИСТИНА (True) или ЛОЖЬ (False), хранится в переменных булевых типов. Всего таких типов четыре, и они представлены в табл. 1.4.

    По аналогии с целыми и символьными типами, подразделяющимися на физические и логические, естественно предположить, что ByteBool, WordBool и LongBool — физические типы, Boolean — логический. Но в данном случае это не совсем так. Все четыре типа различны. Для Object Pascal предпочтителен тип Boolean, остальные определены для совместимости с другими языками программирования и операционными системами.

    Переменным типа Boolean можно присваивать только значения True (истина) и False (ложь). Переменные ByteBool, WordBool и LongBool могут принимать и другие порядковые значения, интерпретируемые обычно как False в случае нуля и True — при любом ненулевом значении.

    Совет: Булевы типы в Delphi можно сравнить с типом logical языка FORTRAN. В Basic, С и C++ булевы типы как таковые отсутствуют. Булевы выражения в этих языках применяются точно так же, как во всех остальных, однако результаты этих выражений интерпретируются не как значения отдельного типа, а как целые числа. Как в Basic, так и в C/C++ булевы выражения дают численные результаты, интерпретируемые как False в случае 0 и True — в случае любого ненулевого значения. Это совместимо с порядковыми значениями булевых выражений в Delphi. В C/C++ простые сравнения дают результат 1 (True) или 0 (False). Это эквивалентно булевым значениям Delphi. Только результат сравнения в Delphi выводится как булевый, а не целый. В большинстве случаев типу Boolean из Delphi соответствует тип char в C/C++. В Basic зарезервированы слова TRUE (эквивалентно константе –1) и FALSE (эквивалентно константе 0). В Basic TRUE меньше FALSE, в Delphi, наоборот, False меньше True.

    Type enum type = (first value, value2, value3, last value);

    Обычно данные перечислимых типов содержат дискретные значения, представляемые не числами, а именами. Тип Boolean— простейший перечислимый тип в Object Pascal. Булевы переменные могут принимать два значения, выражаемые именами True и False, а сам тип определен в Object Pascal так, как будто он объявлен следующим образом:

    Type Boolean = (False, True);

    С помощью типа Boolean в Object Pascal выполняются сравнения, большинство же перечислимых типов — это просто списки уникальных имен или идентификаторов, зарезервированных с конкретной целью. Например, можно создать тип MyColor (мой цвет) со значениями myRed, myGreen и myBlue (мой красный, мой зеленый, мой синий). Это делается совсем просто:

    Type MyColor = (myRed, myGreen, myBlue);

    В этой строке объявлены четыре новых идентификатора: MyColor, myRed, myGreen и myBlue. идентификатором MyColor обозначен порядковый тип, следовательно, в синтаксисе Object Pascal можно применять этот идентификатор везде, где разрешены перечислимые типы. Остальные три идентификатора — это значения типа MyColor. Подобно символьным и булевым типам перечислимые не являются числами, и использовать их наподобие чисел не имеет смысла. Однако перечислимые типы относятся к порядковым, так что значения любого такого типа упорядочены. Идентификаторам в списке присваиваются в качестве порядковых номеров последовательные числа. Первому имени присваивается порядковый номер 0, второму — 1 и т. д.

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

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

    Type subrange type = low value…high value;

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

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

    В переменных действительных типов содержатся числа, состоящие из целой и дробной частей. В Object Pascal определено шесть действительных типов. Все типы могут представлять число 0, однако они различаются пороговым (минимальным положительным) и максимальным значениями, которые могут представлять, а также точностью (количеством значащих цифр) и объемом. Действительные типы описываются в табл. 1.5.

    Совет: Тип real предназначен для совместимости с ранними версиями Delphi и Borland Pascal. Формат этого типа неудобен для семейства процессоров Intel, поэтому операции с типом Real выполняются несколько медленнее операций над остальными действительными типами.

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

    Заметьте, именно почти. Несмотря на название действительные, переменные этих типов отличаются от математических действительных чисел. В Object Pascal действительный тип — это подмножество математических действительных чисел, которые можно представить в формате с плавающей запятой и фиксированным числом цифр. Для невнимательных программистов ситуация усугубляется тем, что в стандартных форматах IEEE (Institute of Electrical and Electronic Engineers — Институт инженеров — электриков и электронщиков), применяемых в программах Delphi и вообще в большинстве программ для Windows, возможно точное представление только чисел с фиксированным числом бит в дробной части. Удивительно, но такое простое число, как 0,1, записывается в расширенном формате IEEE с некоторой погрешностью, пусть очень небольшой. Из-за этого представление с плавающей запятой оказывается несколько неудобным для программ, в которых сохраняется и выводится фиксированное число десятичных разрядов численных значений. Это относится и к программам, работающим с «живыми» деньгами.

    Для частичного решения этой проблемы в Object Pascal определены два формата с фиксированной запятой. Тип Comp (computational — вычислительный) содержит только целые числа в диапазоне от –263 +1 до 263 –1, что примерно соответствует диапазону от —9,2х10 18 до 9,2х10 18 . При программировании операций с американской валютой разработчикам обычно приходится искать естественный способ записи денежных сумм, в котором целая часть числа определяет количество долларов, дробная — центов. Если такие значения записывать в переменные типа Comp, придется представлять их в виде целого числа центов. В этом случае следует умножать значение на 100 для обращения центов в доллары, а затем делить на 100, чтобы снова получить центы.

    Этих забот можно избежать, если воспользоваться типом Currency. В этом случае задачу выбора масштаба возьмет на себя компилятор. Физически значения Currency записываются в память того же объема, что и Comp, как целые числа, однако компилятор не забывает вовремя разделить значение на 10 000 (не на 100!) для его приведения в соответствие с денежным знаком и умножить на 10 000 перед записью в память. Это обеспечивает абсолютную точность в четыре десятичных знака после запятой.

    В Delphi есть модуль System, содержащий ряд процедур обработки данных действительных типов. Наиболее распространенные из них перечислены в табл. 1.6. Много полезных процедур содержится также в модулях SysUtils и Math.

    Совет: Будьте внимательны при переносе численных выражений из одного языка в другой. В Basic функция SQR вычисляет квадратный корень, а функция Sqr из Delphi — квадрат числа. Для вычисления квадратного корня в Delphi применяется функция Sqrt.

    В выражениях Delphi поддерживает три физических строковых формата: короткий (ShortString), длинный (LongString) и широкий (WideString). Их можно комбинировать в операторах присваивания и выражениях (все необходимые преобразования Delphi выполняет автоматически).

    Переменные типов AnsiString и WideString — это динамически распределяемые массивы символов, максимальная длина которых ограничивается только наличием памяти. Разница между ними состоит в том, что в AnsiString знаки записываются в формате char, а в WideString— в формате WideChar. Обычно вполне достаточно одного типа AnsiString, однако при работе с международными наборами символов, такими как UNICODE, удобнее использовать WideString.

    Тип ShortString — это, по существу, массив Array [0..255] of char. Первый его элемент задает динамическую длину строки, которая может принимать значения от 0 до 255 символов. Символы, составляющие строку, занимают места от 1 до 255. Тип ShortString предназначен, в основном, для обеспечения совместимости с ранними версиями Delphi и Borland Pascal.

    Логический строковый тип именуется просто String. Отнесение его к типу AnsiString или ShortString задается командой $Н. По умолчанию задается < $Н+>, и String совпадает с AnsiString. Если задать команду <$Н— >, то String будет совпадать с ShortString и иметь максимальную длину, равную 255 символам.

    Для совместимости с другими языками программирования в Delphi поддерживается класс строк с конечным нулем. Зарезервированных слов или идентификаторов для этого класса не существует.

    Строки с конечным нулем состоят из ненулевых символов и оканчиваются символом с порядковым номером 0 (#0). В отличие от типов AnsiString, ShortString и WideString, строки с нулевым окончанием не имеют указателя длины. Конец в этих стоках обозначается нулем.

    Физически строки с нуль-окончанием подобны массивам символов с нумерацией элементов от нуля, наподобие array [0. X] of char, где Х — некоторое положительное целое, большее нуля, хотя никаких объявлении подобного рода не происходит. Вместо этого определяется переменная-указатель P Char и распределяется необходимый объем памяти. При необходимости строке AnsiString можно присвоить тип P Char.

    В табл. 1.7 перечислены некоторые процедуры и функции обработки данных строковых типов.

    Совет: Программисты, работающие на С, привыкли записывать все строки в массивы с нуль-окончанием. Фактически они применяют в выражениях не строковые переменные, а указатели на них. Программисты, работающие на Basic, привыкли использовать строку как одно целое. Для типа AnsiString из Delphi годятся оба подхода.

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

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

    Ниже перечислены структурные типы, определенные в Delphi.

    Указатели на классы

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

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

    fieldname2, fieldname3: fieldtype2;

    case optional tagfield: required ordinal type of

    1: variantnamel: varianttype3;

    2, 3: variantname2: varianttype4;

    Данное объявление состоит из фиксированной и вариантной частей. Однако вовсе не обязательно вставлять в одно объявление записи обе эти части. Обычно удобнее работать с каждой из этих частей отдельно.

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

    fieldname2, fieldname3: fieldtype2;

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

    Для доступа ко всей записи просто укажите ее имя.

    Совет: В языке С эквивалентом фиксированного типа record из Delphi является struct. В C++ также определен тип struct, синтаксис которого совместим с типом struct из С. Однако в C++ этот тип имеет дополнительные особенности, благодаря чему напоминает тип Class из Delphi.

    Вариантная часть типа record дает возможность по-разному трактовать область памяти, совместно занимаемую вариантами поля:

    case optional tagfield: required ordinal type of

    1: variantnamel: varianttype3;

    2, 3: variantname2: varianttype4;

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

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

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

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

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

    Данные некоторых типов бессмысленно интерпретировать различным образом, и в Object Pascal на некоторые критические типы наложено соответствующее ограничение. Как следствие, в вариантную часть записи нельзя включать длинные строки и переменные типа Variant, а также структурные переменные, содержащие эти типы.

    Совет: В С и C++ эквивалентом вариантному типу записи из Delphi является тип union.

    Массивы могут быть одно — или многомерными, как в следующем примере.

    array [ordinaltype] of typedefinition;

    array [ordinal typel, ordinal type2] of type definition;

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

    Количество элементов массива равно произведению количеств элементов во всех измерениях.

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

    var MyArray: Array [1..10] of Integer;

    Тогда обращение к его третьему элементу будет выглядеть, как MyArray[З], и выполняться, как к переменной Integer.

    Совет: Понятие массива существует в большинстве языков программирования, однако синтаксис, как правило, в каждом случае свой. В языках Basic и FORTRAN вместо квадратных скобок применяются круглые. В С и C++ элементы массива нумеруются с нуля, в FORTRAN — с единицы. В Basic нумерация начинается с нуля или единицы, в зависимости от результата последнего выполнения оператора OPTION BASE. В некоторых версиях Basic можно задавать верхнее и нижнее значения индексов, как это делается в Delphi. В С и C++ обращение к массиву эквивалентно обращению к его первому (нулевому) элементу. В Delphi это будет обращением ко всему массиву.

    Зарезервированное слово set (множество) определяет множество не более чем из 256 порядковых значений:

    Set of ordinal type

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

    Type CharSet = set of AnsiChar; // Тип множества символов. ANSI.

    var MyAlphaSet: CharSet; // Переменная типа CharSet.

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

    MyAlphaSet:= [‘А’, ‘Е’, ‘Г, ‘О’, ‘U’, ‘Y’]; // Все прописные гласные.

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

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

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

    file of Typel // Файл определенного типа, содержащий

    // записи фиксированной длины.

    file // Файл без типа или „блочный“.

    textfile // Файл с записями переменной длины, разделенными символами CR

    //и LF („возврат каретки“ и „новая строка“).

    Механизм ввода-вывода информации как никакой другой аспект программирования зависит от языка и реализации. В большинстве случаев предполагается, что программисту незачем вникать во внутреннюю структуру переменных, управляющих вводом-выводом, и при передаче информации следует полностью полагаться на предназначенные для этого процедуры. Их реализация должна оставаться чем-то наподобие черной магии. В Basic файлы обозначаются числовыми значениями — дескрипторами. В C/C++ программисты манипулируют указателями на структуру FILE. И только в Delphi файловая структура — это переменная.

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

    pointer // Указатель без типа.

    ^typel // Указатель с типом.

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

    Только исходный тип указателей может совпадать с собственно типом.

    Указатели и адресные функции

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

    Addr Возвращает адрес указанного объекта

    Assigned Проверяет, равно ли значение процедурной функции Nil

    Ptr Преобразует адрес в указатель

    Зарезервированное слово Nil указывает значение указателя, который ни на что не указывает. Такие указатели называют неопределенными. В Object Pascal только при определении указателей можно нарушать правило, по которому все указываемые идентификаторы, в том числе идентификаторы типов, должны быть объявлены выше. Здесь можно указать идентификатор еще необъявленного типа, как в следующем примере:

    Однако необъявленный тип необходимо объявить ниже в том же блоке объявления типов.

    Определенный в Object Pascal тип Pointer— это указатель без типа. Обратиться к переменной через такой указатель невозможно (к переменной типа Pointer нельзя дописывать символ „^“). Однако можно задать ей другой указательный тип.

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

    Совет: Во многих языках указательные типы как таковые отсутствуют. Однако в С и C++ они есть и определяются звездочкой перед типом объявляемой переменной. Указатели в C/C++ трактуются наподобие целых переменных. Программисты Delphi избегают подобного манипулирования указателями.

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

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

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

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

    В Delphi указатели процедурного типа на методы применяются для сопоставления событий с образцами текста программы. С точки зрения синтаксиса, единственное отличие процедурного типа для метода от обычного процедурного типа состоит в фразе of object, следующей за прототипом процедуры или функции в случае метода. Особым образом применяется в процедурных методах указательное значение Nil. Это единственное указательное значение, которое можно присвоить процедурной переменной. После присвоения такого значения процедурная переменная становится неопределенной. Состояние определенности можно проверить с помощью функции Assigned.

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

    Физически процедурные типы в Delphi совпадают с указательными, однако они различаются синтаксически, поэтому нельзя обращаться к функции или процедуре через указатель. Тем не менее при обращении к процедурной переменной задействуется именно значение указательного типа. В C/C++ переменная может иметь тип указателя на функцию. В версиях языка С до введения стандарта ANSI для обращения к соответствующей функции приходилось явно адресовать указатель. В версиях С, со-ответствующих стандартам ANSI, возможны как явная, так и неявная адресации указателей. Delphi удобна для тех, кому близок стиль ANSI.

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

    При рассмотрении типа Record мы ознакомились с вариантной частью записи, где в одном фрагменте памяти можно хранить информацию нескольких типов. Такой метод недостаточно нагляден. Много ли пользы от того, чтобы найти в памяти действительное значение с фиксированной запятой и интерпретировать его, как целое! Тип Variant (не имеющий ничего общего с вариантной частью записи) более „проворен“ и полезен в управлении данными разных типов. Переменным типа Variant можно присваивать любые значения любых целых, действительных, строковых и булевых типов. Для совместимости с другими языками программирования предусмотрена также возможность присвоения этим переменным значений даты/времени и объектов OLE Automation. Кроме того, вариантные переменные могут содержать массивы переменной длины и размерности с элементами указанных типов.

    Все целые, действительные, строковые, символьные и булевы типы совместимы с типом Variant в отношении операции присваивания. Вариантные переменные можно сочетать в выражениях с целыми, действительными, строковыми, символьными и булевыми; при этом все необходимые преобразования Delphi выполняет автоматически. Можно произвольно задавать для выражении тип Variant в форме Variant (X).

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

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

    Интересна проблема использования вариантной переменной как массива. Элементы этого массива должны быть одного типа. На первый взгляд, это вполне естественное условие. Однако элементам массива можно присвоить и тип Variant! Тогда каждый элемент сможет содержать информацию разных типов, в том числе массив Variant. Как правило, вариантные массивы создаются с помощью процедуры VarArrayCreate.

    Для передачи двоичной информации между контроллерами автоматизации OLE и серверами обычно применяются вариантные массивы с элементами varByte. Вариантные массивы типа varByte не могут подвергаться никаким преобразованиям. Нельзя также переформатировать содержащуюся в них двоичную информацию. Эффективный доступ к ним осуществляется с помощью процедур VarArrayLock и VarArrayUnlock.

    Элементы вариантного массива не могут иметь тип varString. Для создания вариантных массивов со строковыми элементами следует выбрать тип varOleStr.

    Процедуры обработки вариантных массивов

    В табл. 1.9 перечислены стандартные процедуры и функции обработки вариантных массивов, определенные в модуле System.

    В табл. 1.10 перечислены типы значении, которые можно присваивать вариантным переменным, и вариантные типы результата.

    Вариантные переменные в отношении операции присвоения совместимы с элементарными типами данных Object Pascal (Integer, Real, String и Boolean). Все нужные преобразования Delphi выполняет автоматически. При необходимости конкретно указать, что вариантное значение надо интерпретировать как целое, действительное, строковое или булево, следует задать тип в форме TypeName (V), где TypeName — идентификатор соответствующего типа, V— выражение Variant. Задание типа изменяет только способ считывания значения из вариантной переменной, а не само значение внутри ее. Внутреннее же представление изменяется с помощью процедур VarAsType и VarCast.

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

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

    Что же касается идентификаторов методов объекта OLE Automation, то они могут содержать любые алфавитные символы из международного набора, в том числе а, ь и ш.

    Ord — Функция Delphi

    От Delphi 4 к Delphi 5
    Программный модуль Delphi состоит из раздела interface (интерфейс) и раздела implementation (реализации).

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

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

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

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

    Синтаксис объявления констант следующий:


    Const
    ИмяКонстанты1=значение константы;
    ИмяКонстанты2=константное выражение;

    ИмяКонстантыN=значение константы;

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

    Примеры объявления констант:

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

    Примеры константных выражений:

    Имеются предопределенные константы: True — истина, False — ложь, Nil — нулевой указатель.

    Константное выражение может использовать константы, ранее объявленные именованные константы, арифметические операции, значения переменных типов, конструкторы множеств, а также следующие встроенные функции: Abs, Addr, ArcTan, Chr, Cos, Exp, Frac, Hi, High, Int, Lenght, Ln, Lo, Low, Odd, Ord, Pi, Pred, Round, Sin, SizeOf, Sqr, Sqrt, Succ, Swap, Trunc.

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

    Объявление именованной константы является указанием для компилятора произвести замену во всем тексте идентификатора константы его значением. Такое объявление делает текст более осмысленным.

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

    Имеется такой вид констант, как строки ресурсов. Они включаются в проект с помощью ключевого слова resourcestring вместо const.

    Пример строки ресурсов:


    resourcestring
    ThisGoodText=’
    Это хороший текст ‘;
    Константы записи.

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

    TPoint=record
    X, Y: Single;
    end;
    TVector=array[0..1] of TPoint;
    TMonth=(Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
    TDate=record
    D: 1..31;
    M: TMonth;
    Y: 1900..1999;
    end;
    const
    Origin: TPoint=(X: 0.0; Y: 0.0);
    Line: TVector=((X: -3.1; Y: 1.5), (X: 5.8; Y: 3.0));
    SomeDay: TDate=(D: 2; M: Dec; Y: 1960);

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


    const Digits: array[0..9] of Char=(‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’);

    объявляется типизированная константа, с именем «цифры», которая содержит массив символов.

    Более удобно это объявление можно представить как:


    const Digits: array[0..9] of Char=’0123456789′;

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


    type TCube=array[0..1, 0..1, 0..1] of Integer;
    const Maze: TCube=(((0, 1), (2, 3)), ((4, 5), (6,7)));

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

    Переменная имеет следующие характеристики.


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


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

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

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

    Синтаксис объявления имеет вид:

    Блок объявлений переменных начинает ключевое слово var.

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

    Пример объявления переменных:


    var
    Summa: Integer;
    Divident,
    Divisor: Real;
    BinaryNamber: Byte;
    SurmameOfAuthor: String;

    Переменные можно разделить на локальные и на глобальные.


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

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

    Глобальные переменные можно инициализировать в их объявлениях, т.е. задавать им начальные значения.

    Пример инициализации глобальной переменной:

    Локальные переменные инициализировать нельзя.

    Можно создавать динамические переменные, выделяя для них место в динамически распределяемой области памяти heap (куча), с использованием процедур GetMem и New. Освобождение памяти производится процедурами FreeMem и Dispose. Можно также использовать для динамических переменных функции ReallocMem, Initialize, StrAlloc, StrDispose.

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


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


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

    Язык программирования Object Pascal определяет ряд типов данных, называемых стандартными типами данных. К ним относятся следующие типы: целые, действительные или вещественные, символы, строки, указатели, булевы, variant.

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

    Это слово начинает раздел объявления типов, синтаксис объявления которых следующий:


    type <
    Когда один идентификатор типа объявлен, используем другой идентификатор типа, без определения типа, оба обозначают тот же тип >
    T1=Integer;
    T2=T1;
    T3=Integer;
    T4=T2;
    type TMyString=string;
    Объявление типа можно использовать для создания псевдонима встроенного типа >
    type TMyInteger=type Integer; <
    Для того чтобы создавать четкий тип, повторите слово type в описании >
    type MyString=string[10]; <
    определение переменных для введенного пользователем типа >
    var
    S1: MyString;
    S2: MyString;

    Целые типы данных.

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

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

    Ниже приведены значения, которые определены для Delphi 5.

    Тип Byte, диапазон значений 0 255, размер 1 байт.

    Тип Word, диапазон значений 0 65535, размер 2 байта.

    Тип Longword, диапазон значений 0 4294967295, размер 4 байта

    Тип ShortInt, диапазон значений -128 127, размер 1 байт.

    Тип SmallInt, диапазон значений -32768 32767, размер 2 байта.

    Тип Cardinal, диапазон значений 0 4294967295, размер 4 байта.

    Тип Integer, диапазон значений -2147483648 2147483647, размер 4 байта.

    Тип LongInt, диапазон значений -2147483648 2147483647, размер 4 байта.

    Тип Int64, диапазон значений -2 63 (2 63 – 1), размер 8 байт.

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

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

    Попытка увеличения значения переменной, уже имеющей максимальное для данного типа значение, приведет к циклическому переходу на минимальное значение. Это произойдет, если не включена директива проверки диапазона целочисленных значений и не установлена опция Range Checking в окне опций проекта. Иначе в процессе выполнения будет генерироваться исключение с сообщением «Range check error».

    Рассмотрим пример использования целых типов в приложениях.

    В данном примере объявляется четыре целые переменные Minute, Hour, Day, Year. После ключевого слова begin производится инициализация переменной Minute со значением 60, столько секунд содержится в минуте. Следующая строка вычисляет, сколько секунд содержится в часе, переменная Hour присваивается результат вычисления Minute * 60, т.е. увеличивается в 60 раз значение, хранящееся в переменной Minute. Результат помещается в переменную Hour, и так далее .

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

    Переменные булевых типов данных представляют логические значения, например, true (истина) и false (ложь). Булевы типы относятся к целым порядковым типам. Ниже приведены основные булевы типы для Delphi 5 . Столь большое число одинаковых по смыслу типов связано с желанием обеспечить совместимость Delphi с другими системами. Предпочтительнее всегда использовать тип Boolean, кроме обращений к каким-нибудь процедурам, явным образом требующим другой тип.

    Тип Boolean — булева величина в один байт.

    Тип ByteBool — булева величина в один байт.

    Тип WordBool — булева величина в одно слово.

    Тип LongBool — булевая величина в два слова.

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

    Рассмотрим пример использования булевых переменных.


    var
    Cell, Cell1: Boolean;
    Result: Boolean;
    begin
    Cell:=True;
    Cell1:=not Cell;
    Result:=Cell and Cell1;
    end;

    В данном примере объявляется три переменные булевого типа. Переменные Cell и Cell1 объявлены вместе. Переменная Result объявлена отдельно. В первой строке после ключевого слова begin переменной Cell присвоено значение True. Во второй строке переменной Cell1 присвоено значение логически противоположное тому, которое имеет переменная Cell. Выражение not Cell значит: возьмите значение Cell и проинвертируйте его, т.е. сделайте отрицание. Следующая строка Result:=Cell and Cell1 означает: возьмите значение Cell и объедините его со значением Cell1, используя логический оператор and. Результат этого выражения присвойте значению Result.

    Действительные типы данных.

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

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

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

    Форма с фиксированной точкой совпадает с обычной записью чисел: 299 <точка в конце числа опущена>, 3.14

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

    Тип Real 48, диапазон значений 2.9*10 –39 1.7*10 38 , число значащих разрядов 11–12, размер 6 байт.

    Тип Real, диапазон значений 5.0*10 -324 1.7*10 308 , число значащих разрядов 15–16, размер 8 байт.

    Тип Single, диапазон значений 1.5*10 -45 3.4*10 38 , число значащих разрядов 7–8, размер 4 байта.

    Тип Double, диапазон значений 5.0*10 -324 1.7*10 308 , число значащих разрядов 15–16, размер 8 байт.

    Тип Extended, диапазон значений 3.6*10 -4932 1.1*10 4392 , число значащих разрядов 19–20, размер 10 байт.

    Тип Comp, диапазон значений, -2 63 2 62 , число значащих разрядов 19–20, размер 8 байт.

    Тип Currency, диапазон значений -922337203685477.5808 922337203685477.5807, число значащих разрядов 19–20, размер 8 байт.

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

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

    Рассмотрим пример использования действительных (вещественных) чисел.


    const
    DefaultDaily=300.00;
    var
    Form1: TForm1;
    implementation
    <$R *.DFM>
    procedure TForm1.Button1Click(Sender: TObject);
    var
    Hour: Real;
    Day, Month: Single;
    Annually: Double;
    begin
    Day :=DefaultDaily;
    Hour :=Day/8;
    Month:=Day*20;
    Annually:=Month*12;
    end;
    end.

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

    Объявлены четыре переменные действительного типа Real, Single, Double.

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

    Символьные типы предназначены для хранения одного символа. Они относятся к целым порядковым типам. Ниже приведены значения символьных типов данных. Наличие двух разных типов — ANSIChar и WideChar связано с двумя различными множествами символов: ANSI, каждый символ которого занимает 1 байт, и Unicode, каждый символ которого занимает 2 байта. Первые 256 символов в этих множествах одинаковы и соответствуют символам ASCII от 0 до 255.

    Тип ANSIChar, размер 1 байт, хранит один символ ANSI.

    Тип WideChar, размер 2 байта, один символ Unicode.

    Тип Char, размер 1 байт, хранит один символ. Сейчас эквивалентен ANSIChar . В будущих версиях Delphi, может быть, будет эквивалентен WideChar .

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

    Для символьного типа предопределена функция Chr, возвращающая символ любого целого значения в пределах AnsiChar или WideChar. Например, Chr (65) возвращает букву «A». Поскольку символьные типы относятся к порядковым типам, для них предопределены такие функции и процедуры, как Ord, Pred, Succ, Inc, Dec и др. Функция Ord, возвращающая номер символа, противоположна по смыслу функции Chr . Т.е. Ord (Chr(65)) вернет 65, а Chr (Ord(‘A’)) вернет символ «A».

    Рассмотрим пример использования символов в приложении.

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

    В программе объявлены две символьные переменные, Tetta и Etta. Переменной Tetta присвоено значение f. Переменной Etta присвоено значение F.

    Тип данных строки.

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

    Тип ShortString, максимальная длина 255, используется для обратной совместимости.
    Тип AnsiString, максимальная длина 2 31 (2 Гб) символов ANSI .
    Тип String, максимальная длина или 255, или до 2 Гб символов ANSI или Unicode .
    Тип WideString, максимальная длина 2 30 (1 Гб) символов Unicode, используется в серверах COM и интерфейсах.

    Родовым является тип String, который имеет разный смысл в зависимости от директивы компилятора $H. Если включена директива (она включена по умолчанию), то String интерпретируется компилятором как тип AnsiString — длинная строка с нулевым символом в конце. Если же включить директиву <$H->, то String интерпретируется компилятором как тип ShortString — короткая строка без нулевого символа в конце. Если в объявлении типа после ключевого слова String следует число символов в квадратных скобках (например, String[4]), то, независимо от директив компилятора, тип трактуется как строка без нулевого символа в конце с указанным числом символов.

    Рассмотрим пример использования строк в приложении.

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

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


    var
    SurName,
    Name,
    PatronymicName: String[15];
    Buffer: String [45];
    begin
    SurName:=’Skuratow’;
    Name :=’Wladimir’;
    PatronymicName:=’Petrowich’;
    Buffer:=Surname + Name + PatronymicName;
    end;

    Компонент Image предназначен для размещения на форме одного из поддерживаемых Delphi типов изображений: пиктограммы, растровой картинки или метафайла.

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

    Поместите компонент Image со страницы Additional на форму. Центральное свойство этого компонента, которое может содержать изображение, — свойство Picture. Д ля того чтобы поместить изображение на форму, необходимо произвести двойной щелчок по компоненту Image или щелкнуть по кнопке с тремя точками справа от свойства Picture на странице Properties инспектора объекта. Откроется диалоговое окно Picture Editor, позволяющее загрузить в свойство Picture какой-нибудь графический файл. Для загрузки изображения щелкните по кнопке Load. Откроется диалоговое окно Load Picture (рисунок 1) . При перемещении по открытым графическим файлам в правом окне отображаются содержащиеся в них картинки, а над ним — цифры, характеризующие размер картинки (рисунок 2). Как видите, в Delphi 5 появилось удобное загрузочное окно, позволяющее предварительно просмотреть изображения картинок. Графические файлы в Delphi 4 расположены в каталоге Program Files \ Common Files \ Borland Shared. Графические файлы в Delphi 5 расположены в каталоге Program Files \ Common Files \ Borland \ Borland Shared. Можно использовать изображения из каталога Program Files \ Microsoft Office \ Clipart \ Popular.

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

    Вы можете создать рисунок самостоятельно, используя уже имеющиеся рисунки, например с использованием редактора Word . Редактор Word предлагает воспользоваться рисунками, которые уже созданы. Но просто вставленный рисунок может не удовлетворять вас по своему виду, цвету или по наличию или отсутствию отдельных элементов. Редактор Word предлагает вам преобразовывать рисунки к виду, которые могут быть очень далеки от их оригиналов, причем в лучшую сторону. Чтобы использовать имеющиеся рисунки, необходимо запустить текстовый редактор Word. В строке главного меню Microsoft Word выберите кнопку Вставка, щелкните по ней, из раскрывшегося меню выберите Рисунок и далее Картинки. Щелкните по команде Картинки. Раскроется диалоговое окно Microsoft Clip Gallery 3.0 (рисунок 3). Из предложенного раздела Графика выберите подраздел Хозяйство. Активизируйте, например, рисунок Часы и щелкните по кнопке Вставить. После этого рисунок Часы импортируется в ваш документ на место, указанное курсором (рисунок 4).

    Ваше первое преобразование может быть сразу сведено, возможно, к уменьшению его размера. Произведите выделение рисунка: подведите курсор к значкам, выделяющим данный рисунок. И в момент превращения курсора в двойную стрелку, нажмите левую кнопку мыши и, изменяя положения мыши на коврике, измените размер вашего рисунка. На импортируемом рисунке часы показывают 7 часов 52 минуты, измените время, показываемое часами, на 9 часов. Измените положение часов в текстовом документе и цвет. Для этого подведите курсор к меню Microsoft Word, щелкните правой кнопкой мыши и из раскрывшегося меню выберите команду Рисование . Над панелью задач появится панель Рисование. Подведите маркер к рисунку Часы, и после того как он превратится в четырехстороннюю стрелку, щелкните кнопкой для выделения нашего рисунка. Не снимая выделения, нажмите кнопку Действия. В раскрывшемся меню выберите команду Разгруппировать. Данную процедуру повторите несколько раз, пока команда Разгруппировать не перестанет быть активной. Для данного рисунка необходимо 8 раз проделать данную процедуру, после чего рисунок будет разбит на отдельные составные части, с которыми вы и будете работать дальше.

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

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

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

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

    Рассмотрим свойства компонента Image.

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

    Свойство Center указывает, нужно ли центрировать изображение в границах компонента. Игнорируется, если свойство AutoSize равно True или если свойство Stretch равно True и изображение не является пиктограммой (ICO).

    Свойство Stretch позволяет подгонять не компонент под размер рисунка, а рисунок под размер компонента. Для этого установите свойство AutoSize в False, растяните или сожмите размер компонента Image и установите Stretch в True. Вы увидите, что рисунок займет всю площадь компонента, но здесь возможно искажение рисунка. Поэтому устанавливать размеры Image точно пропорционально размеру рисунка может иметь смысл только для изображений не подверженных искажениям (узоры, линии). Свойство Stretch не распространяется на пиктограммы, которые не изменяют своих размеров.

    Свойство Transparent (прозрачность). Если свойство установлено в True, то изображение в Image становится прозрачным. Данное свойство можно использовать для наложения изображений друг на друга. Чтобы это увидеть, поместите два компонента Image на форму, загрузите в них картинки. Передвиньте компоненты друг на друга, установите для верхнего компонента Image свойство Transparent равное True. Вы увидите, верхняя картинка перестала заслонять нижнюю картинку (рисунок 6). Вы можете поэкспериментировать с данным свойством, возможно, получите оригинальные совмещенные изображения для вашего приложения.

    1. Марко Канту. Delphi 2 для Windows 95/NT. Москва. ООО «Малип». 1997 г.
    2. Джон Матчо. Дэвид Р. Фолкнер. Delphi. Москва. БИНОМ. 1995 г.
    3. Эндрю Возневич. Delphi. Освой самостоятельно. Москва. Восточная книжная компания. 1996 г.
    4. В.В.Фаронов. Delphi 5. Учебный курс. Москва. Издательство Нолидж. 2000 г.
    5. А. Я. Архангельский. Программирование в Delphi 5. Москва. ЗАО «Издательство Бином». 2000 г.

    Владимир Скуратов

    Реализация функции Ord в Delphi

    December 2020

    1.3k раз

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

    В самом деле, существующая Ord функция может принимать аргументы множества различных типов ( AnsiChar , Char , WideChar , Enumeration , Integer , Int64 ) и может возвращать целое число или Int64.

    Я не могу понять, как объявить несколько версий одного и того же функции.

    Как это должно быть закодировано в Delphi?

    2 ответы

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

    Она работает таким образом из — за магии компилятора . Компилятор знает о Ord и о всех порядковых типах в программе, поэтому он выполняет действия функции в режиме реального времени . Другие компилятор магии функция включает в себя Length (магии , поскольку он принимает произвольные типы массива), Str (магии , потому что он принимает ширину и точность модификаторов), и ReadLn (магии , потому что она принимает произвольное число параметров).

    Я не могу понять, как объявить несколько версий одного и того же функции.

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

    DelphiComponent.ru — бесплатно видеоуроки по Delphi, статьи, исходники

    Функции и процедуры для порядковых типов данных в Delphi XE

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

    Pred — функция, которая возвращает предыдущее значение выражения порядкового типа, указанного в скобках:

    Succ — функция, которая возвращает следующее значение:

    Легко заметить, что действие этой функции противоположно действию функции Pred , и наоборот.

    Ord — функция, которая возвращает порядковый номер значения в списке:

    Low — функция, которая возвращает минимальное значение указанного типа данных:

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

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

    Ну, и ещё две процедуры, с которыми мы уже знакомы:

    Dec — функция декремента; уменьшает значение переменной типа integer на единицу:

    После выполнения функции Dec ( n ) значение переменной n станет равным 1.

    Можно уменьшить значение переменной на любое целое число:

    По своему действию эта функция эквивалентна оператору присваивания:

    но выполняется быстрее.

    Inc — процедура инкремента; увеличивает значение на единицу.

    После выполнения функции Inc ( n ) значение переменной n станет равным 3.

    Можно увеличить значение переменной на любое целое число:

    По своему действию эта функция эквивалентна оператору присваивания:

    Илон Маск рекомендует:  Поле с изображением
    Понравилась статья? Поделиться с друзьями:
    Кодинг, CSS и SQL