Slice — Функция Delphi

Содержание

Как нарезать динамический массив?

Как я могу разделить динамический массив на несколько вложенных массивов? Функция Slice() в Delphi не поддерживает динамические массивы. Так как это можно сделать? Общее решение будет приветствоваться.

2 ответа

Используйте Copy(A, 0, 2) вместо Slice(A, 2) .

Дело в том, что либо вам нужен «параметр открытого массива» (в этом случае вам нужен Slice ), либо вам нужен обычный массив, и в этом случае Copy обеспечит хорошее решение.

Можно использовать указатели для доступа к динамическому массиву из разных «начальных точек»

Преимущество заключается в том, что у вас есть прямой доступ, нет необходимости копировать или перемещать данные. Недостатком является то, что такие функции, как «высокий», «низкий» и «длина», НЕ МОГУТ использоваться на этих указателях массива. Или, по крайней мере, нет, если вы хотите использовать результат. Вы должны быть уверены, что никогда не выйдете за пределы MyList SourceArray при обращении к указателям на массивы. Преимущество заключается в том, что он обеспечивает универсальность для динамических массивов. Как мы знаем, динамический массив может быть создан только от 0 .. и до размера. pArrPos2 с другой стороны эффективно превратил динамический массив в указатель массива, который также принимает отрицательную адресацию:

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

Я знаю. сообщение было старым, но я все еще думаю, что мой ответ будет / может быть уместным здесь, особенно для новых читателей.

Диагностические сообщения компилятора Delphi

Типов сообщений компилятора — более двухсот. Рассмотрим перечень наиболее встречающихся сообщений класса Error

    0. expected but found. Обычно это сообщение возникает при синтаксической ошибке.Например,в случае небаланса скобок,компилятор сообщит: ‘)’ expected but ‘;’ found (вместо ожидавшейся скобки найдена запятая).

Компилятор часто сообщает, что ‘end’ ожидается,например:x:= 5,7; здесь неуместен разделитель-запятая, а сообщается про end. (‘END’ expected but ‘,’ found)

  • 1. is not a type identifier. Данное не является именем типа.
  • 2. ‘;’ not allowed before ‘Else’. Перед else нельзя ставить точку с запятой
  • 3. Abstract method must be virtual or dynamic. Абстрактный метод должен быть виртуальным или динамическим.
  • 4. Ambiguous overloaded call to . Компилятор не может однозначно выбрать перегружаемый блок. Измените параметр.
  • 5. Array type required. Ошибка возникает в случаях, когда в индексе элемента массива указано больше уровней, чем предусмотрено описанием, и если массив не описан. Например, после объявления двумерного массива х или простой переменной х ошибочно записывают элемент х[2,1,1] (в нем показано три измерения).
  • 6. Assignment to FOR-loop variable . Присваивание значения параметру FOR-цикла в теле цикла.

    Например, вследствие описки дважды используется имя i в кратном цикле:

  • 7. Break or Continue outs >. Компиляция присоединенного модуля невозможна.
  • 14. Data type too large. Тип определяет структуру размером более 2 Гбайт; это слишком много.
  • 15. Declaration expected but found. Пропущено описание или оператор.
  • 16. Declaration of differs from previous declarations. Данный заголовок блока не соответствует упреждающему объявлению блока.
  • 17. Default parameter must be by-value or constant. Необязательный параметр (со значением по умолчанию) не должен вызываться по ссылке.
  • 18. Expression expected. В этом месте программы должно стоять выражение.
  • 19. Expression too complicated. Выражение излишне сложно для компиляции.
  • 20. File type not allowed here. В этом месте или в этой роли файловую переменную нельзя использовать. Например, она не может быть формальным параметром-значением.
  • 21. For loop control variable must be simple local variable. Параметр цикла должен быть простой локальной (описанной в этом же блоке) переменной.
  • 22. For loop control variable must have ordinal type. Параметр цикла должен иметь порядковый тип.Вещественный тип запрещен.
  • 23. Function needs result type. В заголовке функции надо указывать тип ее результата.
  • 24. Identifier expected but found. В этом месте должно стоять имя. Например, пропущено имя функции после Function.
  • 25. Identifier redeclared . описано повторно, но в пределах блока имя можно описать лишь раз. Проверьте, не обозначена ли локальная переменная тем же именем, что и формальный параметр блока.
  • 26. Illegal character in input file . Запретный знак, например «русская» буква, либо вы оставили скобку >, убрав открывающую скобку <.
  • 27. Illegal type in Read/Readln (Write/Writeln) statement. Элемент запрещенного типа в списке ввода/вывода.
  • 28. Incompatible types . Несоответствие типов по присваиванию или типов операндов одной операции. Сообщение выдается и при неверном использовании структур. Например, z — запись, ошибочно записано присваивание z:= 0 (работать надо с полями записи).
  • 29. Invalid function result type. Недопустимый тип результата функции.
  • 30. Label already defined: . уже помечает другой оператор.
  • 31. Left side cannot be assigned to. He может быть такой левой части в присваивании. Примеры: попытка присвоить значение файловой переменной, присвоение значения формальному параметру-константе.
  • 32. Line too long. В строке программного текста больше 255 знаков.
  • 33. Low bound exceeds high bound. Нижняя граница превышает верхнюю.
  • 34. Missing operator or semicolon.Пропуск операции (например перед скобкой) или пропуск точки с запятой. При пропуске ‘;’ маркер ошибки стоит на очередном предложении (объявлении или операторе).
  • 35. Missing parameter type. He указан тип формального параметра-значения или параметра процедурного типа.
  • 36. Not enough actual parameters. He хватает фактических параметров.
  • 37. Need to specify at least one dimension . Нужно задавать в операторе SetLength хотя бы один размер динамического массива.
  • 38. Number of elements differs from declaration. Число элементов в структурной константе не соответствует ее описанию.
  • 39. Operator not applicable to this operand type. Операция не применима к операндам данного типа. Например: ‘А’ or ‘В’; ‘Text1’* ‘Text2’.
  • 40. Order of fields in record constant differs from declaration. Порядок полей в записи-константе не соответствует описанию записи.
  • 41. Ordinal type required. Требуется порядковый тип (например, в индексе).
  • 42. Out of memory. Компилятору не хватает памяти.
  • 43. Statement expected but found. В этом месте должен стоять оператор. Сообщение выдается во всех случаях, когда в тело блока или секцию инициализации ошибочно помещают описание ( ). Ошибочная форма обращения к процедуре Procedure или к функции Function также вызывает сообщение.
  • 44. Sets may have at most 256 elements. Множество (тип Set) не может содержать более 256 элементов.
  • 45. Slice standard function only allowed as open array argument. Функцию Slice можно использовать лишь как фактический параметр
  • 46. Statement not allowed in interface part. Предложения в секции интерфейса программного модуля недопустимы.
  • 47. Syntax error in real number. Синтаксическая ошибка в записи числа вещственного типа.
  • 48. There is no overload version of that can be called with these arguments.Не предусмотрен перегружаемый блок , который мог бы вызываться с таким аргументом. Пример: IntToStr(x), где х – выражение вещественного типа.
  • 49. Too many actual parameters. Фактических параметров больше, чем формальных.
  • 50. Type actual and formal var parameters must be identical. Тип фактического параметра должен быть идентичен типу формального параметра-переменной.
  • 51. Type of expression must be . Выражение должно быть указанного типа. Например,после While и Until должно стоять логическое выражение.
  • 52. Undeclared identifier: .Не описано . Проверьте есть ли описание в нужном месте,нет ли описок в имени. Если указано имя компонента формы, проверьте,поместили ли компонент на данную форму.
  • 53. Unexpected end of file in comment started on line . Неожиданный конец файла при незавершенном комментарии, начало комментария — в строке N.
  • 54. Unit name mismatch: . Имя модуля ошибочно.
  • 55. Unsatisfied forward or external declaration . Отсутствует описание блока, объявление которого было дано (заголовок в интерфейсе или в описании объектного типа, либо упреждающее описание).
  • 56. Unterminate string. He закрыта апострофом строка-константа типа string.
  • Рассмотрим также некоторые сообщения классов warning и hint.

    • Return value of function might be undefined. В теле функции нет присваивания ее результата.
    • Variable might not have been initialized. Указывает имя переменой, которой не задали значения.
    • For-Loop variable may be undefined after loop. Попытка использования значения параметра For-цикла после завершения этого цикла.
    • Text after final ‘END.’ ignored by compiler. Текст, идущий за конечной строкой модуля, игнорируется компилятором.
    • Variable is declared but never used in . Обращает внимание на переменную , описанную,но не нашедшую применения.
    • Value assigned to never used. Хотя бы одно значение переменной никак не использовано.

    Несколько рекомендаций

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

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

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

    Функции Delphi модуля System

    Модуль System

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

    Abs Предназначена для получения абсолютной величины числа
    Addr Возвращает адрес переменной, функции или процедуры
    ArcTan Арктангенс числа, возвращается в радианах
    Assigned Осуществляет проверку функциональности указателей, объектов, методов
    BeginThread Начинает отдельный поток выполнения кода
    Chr Конвертирует целое число в символ
    Concat Соединяет несколько строк в одну
    Copy Создает копию части строки или части массива
    Cos Косинус числа
    Eof Возвращает true, если позиция курсора находится в конце файла открытого с помощью Reset
    Eoln Возвращает true, если позиция курсора находится в конце строки
    Exp Выдаёт экспоненту числа
    FilePos
    FileSetDate Установка даты и времени последнего изменения файла
    FileSize Выдает размер открытого файла в записях
    GetLastError Выдаёт код ошибки последнего неудачного Windows API вызова.
    GetMem Получает указанное число байтов памяти.
    Hi Возвращает байт старшего разряда от типа Integer.
    High Возвращает самое высокое значение типа или переменной
    Int Целая часть числа с плавающей точкой
    IOResult Содержит возвращаемый код последней операции ввода/вывода
    IsMultiThread Возвращает True, если код выполняет множество потоков
    Length Возвращает число элементов в массиве или строке
    Ln Выдает натуральный логарифм числа
    Lo Возвращает младший байт целого числа (2-байтового)
    Low Возвращает самое низкое значение типа или переменной
    Odd Провеяет, является ли целое число нечетным
    Ord Порядковое значение целого числа, символа или перечисления
    ParamCount Выдает число параметров переданной текущей программе
    ParamStr Возвращается один из параметров используемых для запуска текущей программы
    Pi Математическая константа
    Pos Находит позицию одной строки в другой
    Pred Уменьшает порядковую переменную
    Random Генерирует случайное целое число или число с плавающей запятой
    Round Округление чисел с плавающей запятой до целого числа
    RunError Заканчивает программу с диалогом ошибки
    SeekEof Пропускает символы, пока не встретится конец файла
    SeekEoln Пропускает символы, пока не встретится конец текущей строки или файла
    Sin Синус числа
    SizeOf Возвращает занимаемый размер типа или переменной в байтах
    Slice Создает часть массива с параметром «Открытый Массив»
    Sqr Возвращает квадрат числа
    Sqrt Возвращает квадратный корень числа
    StringOfChar Создает строку из одного символа, повторенного много раз
    StringReplace Заменяет одну или несколько подстрок, найденных в заданной строке
    StringToWideChar Преобразует обычную строку в WideChar-буфер с завершающим 0
    Trunc Целая часть числа с плавающей запятой
    UpCase Преобразует значение Char к верхнему регистру
    WideCharToString Копирует строку WideChar, заканчивающуюся нулём, в нормальную строку
    Append Открывает текстовый файл, для добавления записей в файл (добавляет в конец файла)
    Assign Назначает дескриптор файла на бинарный или текстовый файл
    AssignFile Связывает дескриптор файла с бинарным или текстовым файлом
    BlockRead Читает блок записей данных из нетипизированного двоичного файла
    BlockWrite Записывает блок записей данных в нетипизированный двоичный файл
    Break Выполняет выход из одного цикла
    ChDir Выбор диска и директории ( папки ), в которой будет производиться работа
    Close Закрывает открытый файл
    CloseFile Закрывает открытый файл
    Continue Заставляет перейти к следующей итерации цикла
    Dec Декремент порядковой переменной
    Delete Удаляет часть символов из строки
    Dispose Очищает память на которую указывает указатель
    EndThread Заканчивает поток с кодом завершения
    Erase Стирает файл
    Exclude Исключает значение из переменной набора (множества)
    Exit Осуществляет выход из функции или процедуры
    Frac Дробная часть числа с плавающей запятой
    FillChar Заполняет раздел памяти значением байта или символа-заполнителя
    Flush Сбрасывает буферизованные данные текстового файла в файл
    GetDir Получает текущий каталог (диск плюс путь) для указанного диска.
    Halt Заканчивает программу с дополнительным диалогом.
    Inc Увеличивает порядковую переменную
    Include Включает значение во множество переменных
    Insert Вставляет строку в другую строку
    MkDir Создаёт каталог
    Move Копирует байты данных из источника в место назначения
    New Создаёт новую переменную типа указатель
    Randomize Устанавливает генератор случайного числа на следующее значение
    Read Позволяет прочитать данные из двоичного или текстового файла
    ReadLn Позволяет прочитать полную строку данных из текстового файла
    ReallocMem Позволяет изменить размер существующего блока памяти
    Reset Открывает текстовый файл для чтения, или двоичный файл для чтения/записи
    ReWrite Открывает текстовый или двоичный файл для записи
    RmDir Удаление каталога
    Seek Перемещает указатель в двоичном файле в новую позицию
    SetLength Изменяет размер строки или размер динамического массива
    SetString Копирует символы из буфера в строку
    Str Конвертирует целое число или число с плавающей точкой в строку
    Truncate Уменьшает размер файла — удаляя все данные после текущей позиции
    WriteLn Записывает законченную строку данных в текстовый файл

    Slice — Функция Delphi

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

    О подпрограммах в Object Pascal

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

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

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

    write(‘Hello, world!’); readln;

    Здесь и write, и readln — стандартные подпрограммы Object Pascal. Таким образом, с вызовом подпрограмм мы уже знакомы. Осталось узнать, как создавать собственные, или пользовательские, подпрограммы. Но прежде отметим, что все подпрограммы делятся на 2 лагеря: процедуры и функции. Мы уже использовали эти термины, и даже давали им описание, однако повторимся: процедуры — это такие подпрограммы, которые выполняют предназначенное действие и возвращают выполнение в точку вызова. Функции в целом аналогичны процедурам, за тем исключением, что они еще и возвращают результат своего выполнения. Результатом работы функции могут быть данные любого типа, включая объекты.

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

    Как процедурам, так и функциям могут передаваться данные для обработки. Делается это при помощи списка параметров. Список параметров в описании подпрограммы и список аргументов, указываемых при ее вызове должен совпадать. Иначе говоря, если в описании определено 2 параметра типа Integer, то, вызывая такую подпрограмму, в качестве аргументов так же следует указать именно 2 аргумента и именно типа Integer или совместимого (скажем, Word или Int64).

    ПРИМЕЧАНИЕ
    На самом деле, Object Pascal позволяет довольно гибко обращаться с аргументами, для чего имеются различные методы, включая «перегружаемые» функции, значения параметров по умолчанию и т.д. Тем не менее, в типичном случае, количество, тип, и порядок перечисления аргументов при объявлении и при вызове процедуры или функции, должны совпадать.

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

    Процедуры

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

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

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

    ПРИМЕЧАНИЕ
    Вопросы локальных и глобальных переменных, и вообще видимости в программах, будет рассмотрен позже в этой главе.

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

    procedure TriplePrint(str: string); var i: integer; begin for i := 1 to 3 do begin writeln(‘»‘+str+'»‘); end; // конец цикла for end; // конец процедуры TriplePrint

    Здесь мы определили процедуру TriplePrint, которая будет трижды выводить переданную ей в качестве аргумента строку, заключенную в двойные кавычки. Как видно, данная процедура имеет все составные части: ключевое слово procedure, имя, список параметров (в данном случае он всего один — строковая переменная str), блок объявления собственных переменных (целочисленная переменная i), и собственное тело, состоящее из оператора цикла for.

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

    Отметим так же, что рассмотренная нами процедура сама содержит вызов другой процедуры — writeln. Процедуры могут быть встроенными. Иначе говоря, объявление одной процедуры можно помещать в заголовочную часть другой. Например, наша процедура TriplePrint может иметь вспомогательную процедуру, которая будет «подготавливать» строку к выводу. Для этого перед объявлением переменной i, разместим объявление еще одной процедуры. Назовем ее PrepareStr:

    procedure PrepareStr; begin str := ‘»‘+str+'»‘; end;

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

    Таким образом, мы получаем две процедуры, одна из которых (TriplePrint) может использоваться во всей программе, а другая (PrepareStr) — только внутри процедуры TriplePrint. Чтобы преимущество использования процедур было очевидно, рассмотрим их на примере программы, которая будет использовать ее неоднократно, для чего обратимся к листингу 6.1 (см. так же пример в Demo\Part1\Procs).

    Листинг 6.1. Использование процедур

    program procs; <$APPTYPE CONSOLE>procedure TriplePrint(str: string); procedure PrepareStr; begin str := ‘»‘+str+'»‘; end; var i: integer; begin PrepareStr; for i := 1 to 3 do begin writeln(str); end; end; // конец процедуры TriplePrint begin // начало тела основной программы TriplePrint(‘Hello. ‘); // первый вызов TriplePrint TriplePrint(‘How are you. ‘); // 2-й вызов TriplePrint(‘Bye. ‘); // 3-й readln; end.

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

    Функции

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

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

    Рассмотрим пример функции, которая будет возвращать куб числа, переданного ей в качестве аргумента:

    function cube(value: integer) : integer; result := value * value * value; >

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

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

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

    procedure TriplePrint(str: string); function PrepareStr(s: string) : string; begin result := ‘»‘+s+'»‘; end; var i: integer; begin for i := 1 to 3 do begin writeln(PrepareStr(str)); // функция использована как переменная end; end;

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

    function cube(value: integer) : integer; cube := value * value * value; >

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

    Рекурсия

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

    Рассмотрим вопрос рекурсии на следующем примере:

    function recfunc(x: integer) : integer begin dec(x); // функция декремента, уменьшает целое на 1 if x > 5 then x := recfunc(x); result := 0; // возвращаемое значение тут не используется end;

    Здесь мы объявили функцию recfunc, принимающую один аргумент, и вызывающую саму себя до тех пор, пока значение этого аргумента больше 5. Хотя на первый взгляд может показаться, что такое поведение функции похоже на обычный цикл, на самом деле все работает несколько по-иному: если вы вызовите ее со значением 8, то она выдаст вам 3 сообщения в следующей последовательности: 5, 6, 7. Иначе говоря, функция вызывала саму себя до тех пор, пока значение x было больше 5, и собственно вывод сообщений начала 3-я по уровню получившейся вложенности функция, которая и вывела первое сообщение (в данном случае им стало 5, т.е. уменьшенное на единицу 6).

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

    Листинг 6.2. Рекурсия с комментариями

    program recurse; <$APPTYPE CONSOLE>function recfunc(x, depth: integer) : integer; begin dec(x); if x > 5 then begin write(‘Current recursion depth is: ‘); write(depth); write(‘, current x value is: ‘); writeln(x); inc(depth); depth:=recfunc(x, depth); end else writeln(‘End of recursive calls. ‘); write(‘Current recursion depth is: ‘); write(depth); write(‘, current x value is: ‘); writeln(x); dec(depth); result := depth; end; begin recfunc(8,0); readln; end.

    Исходный код находится в Demo\Part1\Recurse, там же находится и исполняемый файл recurse.exe, результат работы которого вы можете увидеть на своем экране.

    Использование параметров

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

    procedure Circle (square: real; var radius, length: real);

    Данная процедура принимает «на обработку» одно значение — площадь (square), а возвращает через свои параметры два — радиус (radius) и длину окружности (length). Практическая ее реализация может выглядеть таким образом:

    procedure Circle (square: real; var radius, length: real); begin radius := sqrt(square / pi); // функция pi возвращает значение числа ? length := pi * radius * 2; end;

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

    var r,l: real; . Circle(100,r,l);

    После вызова функции Circle, переменные r и l получат значения радиуса и длины окружности. Остается их вывести при помощи writeln. Исходный код программы приведен в листинге 6.3.

    Листинг 6.3. Процедура с параметрами

    program params; <$APPTYPE CONSOLE>procedure Circle (square: real; var radius, length: real); begin //функция sqrt извлекает корень, а функция pi возвращает значение числа ? radius := sqrt(square / pi); length := pi * radius * 2; end; var r,l: real; begin Circle(100,r,l); writeln(r); writeln(l); readln; end.

    Запустив такую программу, можно убедиться, что она работает и выводит верные результаты, однако вид у них получается довольно-таки неудобочитаемый, например, длина окружности будет представлена как «3,54490770181103E+0001». Чтобы сделать вывод более удобным для восприятия, нам понадобится функция FloatToStrF. С ее помощью мы можем определить вывод числа на свое усмотрение, например:

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

    writeln(‘Radius is: ‘+FloatToStrF(r,ffFixed,12,8)); writeln(‘Length is: ‘+FloatToStrF(l,ffFixed,12,8));

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

    . var s,r,l: real; begin write(‘Input square: ‘); readln(s); Circle(s,r,l); writeln(‘Radius is: ‘+FloatToStrF(r,ffFixed,12,8)); writeln(‘Length is: ‘+FloatToStrF(l,ffFixed,12,8)); readln; end.

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

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

    function Circle(square: real; var radius, length: real) : boolean; begin result := false; if (square

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

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

    if Circle(s,r,l) then begin // вывод end else // сообщить об ошибке

    Результатом проделанной работы будет программа, приведенная в листинге 6.4. Она же находится в Demo\Part1\Params.

    Листинг 6.4. Функция с параметрами

    program params; <$APPTYPE CONSOLE>uses sysutils; //этот модуль соджержит функцию FloatToStrF function Circle(square: real; var radius, length: real) : boolean; begin result := false; if (square

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

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

    function MyBetterFunc(val1: integer; const val2: integer = 2); begin result := val1*val2; end;

    Обращение же к такой функции может иметь 2 варианта: с указанием только одного аргумента (для параметра val1), или же с указанием обоих:

    x := MyBetterFunc(5); // получим 10 x := MyBetterFunc(5,4); // получим 20

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

    Области видимости

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

    program Project1; procedure Proc1; var a: integer; begin a := 5; //верно. Локальная переменная a здесь видна end; begin a := 10; //Ошибка! Объявленная в процедуре Proc1 переменнаая здесь не видна end.

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

    program Project2; var a: integer; // глобальная переменная a procedure Proc1; begin a := 5; // верно b := 10; // Ошибка! Переменая b на этот момент еще не объявлена end; var b: integer; // глобальная переменная b begin a := 10; // верно b := 5; // тоже верно. Здесь видны все г var a: integer; // глобальная переменная end.

    Теперь рассмотрим такой вариант, когда у нас имеются 2 переменных с одним и тем же именем. Разумеется, компилятор еще на стадии проверки синтаксиса не допустит, чтобы в программе были объявлены одноименные переменные в рамках одного диапазона видимости (скажем, 2 глобальных переменных X, или 2 локальных переменных X в одной и той же подпрограмме). Речь в данном случае идет о том, что произойдет, если в одной и той же программе будет 2 переменных X, одна — глобальная, а другая — локальная (в какой-либо подпрограмме). Если с основным блоком программы все ясно — в нем будет присутствовать только глобальная X, то как быть с подпрограммой? В таком случае в действие вступает правило близости, т.е. какая переменная ближе (по структуре) к данному модулю, та и есть верная. Применительно к подпрограмме ближней оказывается локальная переменная X, и именно она будет задействована внутри подпрограммы.

    program Project3; var X: integer; procedure Proc1; var X: integer; begin X := 5; // Здесь значение будет присвоено локальной переменной X end; begin X := 10; // Здесь же значение будет присвоено голобальной переменной X end.

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

    program Project1; procedure Proc1; procedure SubProc; begin end; begin SubProc; // Верно. Вложенная процедура здесь видна. end; begin Proc1; // Верно. Процедура Proc1 объявлена в зоне глобальной видимости SubProc; // Ошибка! Процедура SubProc недоступна за пределами Proc1. end.

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

    Видимость в модулях

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

    Для начала вернемся к рассмотрению структуры модуля, которая имеет ряд отличий от структуры программы. Итак, в простейшем случае, модуль состоит из названия, определяемого при помощи ключевого слова unit, и 2 секций — interface и implementation. Так вот как раз первая секция, interface, и служит для определения (декларации) типов данных, переменных, функций и процедур данного модуля, которые должны быть доступны за пределами данного модуля.

    Чтобы лучше в этом разобраться, создадим программу, состоящую из 2 модулей — основного (dpr) и дополнительного (pas). Для этого сначала создайте новый проект типа Console Application, а затем добавьте к нему модуль, для чего из подменю File ‘ New выберите пункт Unit. После этого сохраните проект, щелкнув по кнопке Save All (или File ‘ Save All). Обратите внимание, что первым будет предложено сохранить не файл проекта, а как раз файл дополнительного модуля. Назовем его extunit.pas, а сам проект — miltiunits (см. Demo\Part1\Visibility). При этом вы увидите, что в части uses файла проекта произошло изменение: кроме постоянно добавляемого модуля SysUtils, появился еще один модуль — extunit, т.е. код стал таким:

    uses SysUtils, extunit in ‘extunit.pas’;

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

    uses SysUtils, extunit;

    Тем не менее, оставим код как есть, и приступим к разработке модуля extunit. В нем, в части implementation, напишем 2 процедуры — ExtProc1 и ExtProc2. Обе они будут делать одно и то же — выводить строку со своим названием. Например, для первой:

    Теперь вернемся к главному модулю программы и попробуем обратиться к процедуре ExtProc1:

    . begin ExtProc1; end.

    Попытка компиляции или запуска такой программы приведет к ошибке компилятора «Undeclared identifier», что означает «неизвестный идентификатор». И действительно, одного лишь описания процедуры недостаточно, чтобы она была доступна вне своего модуля. Так что перейдем к редактированию extunit и в секции interface напишем строку:

    Такая строка, помещенная в секцию interface, является объявлением процедуры ExtProc1, и делает ее видимой вне данного модуля. Отметим, что в секции interface допускается лишь объявлять процедуры, но не определять их (т.е. тело процедуры здесь будет неуместно). Еще одним полезным эффектом от объявления процедур является то, что таким образом можно обойти такое ограничение, как необходимость определения подпрограммы до ее вызова. Иначе говоря, поскольку в нашем файле уже есть 2 процедуры, ExtProc1и ExtProc2, причем они описаны именно в таком порядке — сначала ExtProc, а потом ExtProc2, то выведя объявление ExtProc2 в interface, мы сможем обращаться к ExtProc2 из ExtProc1, как это показано в листинге 6.5:

    Листинг 6.5. Объявление процедур в модуле

    unit extunit; interface procedure ExtProc1; procedure ExtProc2; implementation procedure ExtProc1; begin writeln(‘ExtProc1’); ExtProc2; // Если объявления не будет, то компилятор выдаст ошибку end; procedure ExtProc2; begin writeln(‘ExtProc2’); end; end.

    Отметим, что теперь процедуры ExtProc2, так же, как и ExtProc1, будет видна не только по всему модулю extunit, но и во всех использующей этот модуль программе multiunits.

    Разумеется, все, что было сказано о процедурах, верно и для функций. Кроме того, константы и переменные, объявленные в секции interface, так же будут видны как во всем теле модуля, так и вне него. Остается лишь рассмотреть вопрос пересечения имен, т.е. когда имя переменной (константы, процедуры, функции) в текущем модуле совпадает с таковым в подключенном модуле. В этом случае вновь вступает в силу правило «кто ближе, тот и прав», т.е. будет использоваться переменная из данного модуля. Например, если в extunit мы объявим типизированную константу Z, равную 100, а в multiunits — одноименную константу, равную 200, то обратившись к Z из модуля extunit, мы получим значение 100, а из multiunits — 200.

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

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

    Некоторые стандартные функции

    В Object Pascal, как уже отмечалось, имеются огромное количество стандартных процедур и функций, являющихся составной частью языка, и с некоторыми мы уже знакомы (например, приведенные в табл. 5.1 и 5.2 функции преобразования). Детальное описание всех имеющихся в Object Pascal процедур и функций можно получить в справочной системе Delphi, однако мы все-таки рассмотрим здесь некоторые из них, чтобы составить общее представление — см. таблицу 6.1.

    Таблица 6.1. Некоторые стандартные процедуры и функции Delphi

    Синтаксис Группа Модуль Описание
    function Abs(X); арифметические System Возвращает абсолютное значение числа
    procedure ChDir(const S: string); управления файлами System Изменяет текущий каталог
    function Concat(s1 [, s2. sn]: string): string; строковые System Объединяет 2 и более строк в 1
    function Copy(S; Index, Count: Integer): string; строковые System Возвращает часть строки
    function Cos(X: Extended): Extended; тригонометрические System Вычисляет косинус угла
    procedure Delete(var S: string; Index, Count: Integer); строковые System Удаляет часть строки
    function Eof(var F): Boolean; ввод-вывод System Проверяет, достигнут ли конец файла
    procedure Halt [ ( Exitcode: Integer) ]; управления System Инициирует досрочное прекращение программы
    function High(X); диапазона System Возвращает максимальное значение из диапазона
    procedure Insert(Source: string; var S: string; Index: Integer); строковые System Вставляет одну строку в другую
    function Length(S): Integer; строковые System Возвращает длину строки или количество элементов массива
    function Ln(X: Real): Real; арифметические System Возвращает натуральный логарифм числа (Ln(e) = 1)
    function Low(X); диапазона System Возвращает минимальное значение из диапазона
    procedure New(var P: Pointer); размещения памяти System Создает новую динамическую переменную и назначает указатель для нее
    function ParamCount: Integer; командной строки System Возвращает количество параметров командной строки
    function ParamStr(Index: Integer): string; командной строки System Возвращает указанный параметр из командной строки
    function Pos(Substr: string; S: string): Integer; строковые System Ищет вхождение указанной подстроки в строку и возвращает порядковый номер первого совпавшего символа
    procedure RmDir(const S: string); ввод-вывод System Удаляет указанный подкаталог (должен быть пустым)
    function Slice(var A: array; Count: Integer): array; разные System Возвращает часть массива
    function UpCase(Ch: Char): Char; символьные System Преобразует символ в верхний регистр
    function LowerCase(const S: string): string; строковые SysUtils Преобразует ASCII-строку в нижний регистр
    procedure Beep; разные SysUtils Инициирует системный сигнал
    function CreateDir(const Dir: string): Boolean; управления файлами SysUtils Создает новый подкаталог
    function CurrentYear: Word; даты и времени SysUtils Возвращает текущий год
    function DeleteFile(const FileName: string): Boolean; управления файлами SysUtils Удаляет файл с диска
    function ExtractFileExt(const FileName: string): string; имен файлов SysUtils Возвращает расширение файла
    function FileExists(const FileName: string): Boolean; управления файлами SysUtils Проверяет файл на наличие
    function IntToHex(Value: Integer; Digits: Integer): string; форматирования чисел SysUtils Возвращает целое в шестнадцатеричном представлении
    function StrPCopy(Dest: PChar; const Source: string): PChar; строковые SysUtils Копирует Pascal-строку в C-строку (PChar)
    function Trim(const S: string): string; строковые SysUtils Удаляет начальные и конечные пробелы в строке
    function TryStrToInt(const S: string; out Value: Integer): Boolean; преобразования типов SysUtils Преобразует строку в целое
    function ArcCos(const X: Extended): Extended; тригонометрические Math Вычисляет арккосинус угла
    function Log2(const X: Extended): Extended; арифметические Math Возвращает логарифм по основанию 2
    function Max(A,B: Integer): Integer; арифметические Math Возвращает большее из 2 чисел
    function Min(A,B: Integer): Integer; арифметические Math Возвращает меньшее из 2 чисел

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

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

    Функции в действии

    В целом мы уже ознакомились с несколькими десятками предопределенных процедур и функций, а так же умеем создавать собственные. Пора применить полученные знания на практике, для чего вновь вернемся к программе, рассмотренной в главе, посвященной операторам — игре «Угадай-ка». В ней, по сути, был реализован только один из рассмотренных в самом начале книги алгоритмов — угадывания числа. Что касается алгоритма управления, то на тот момент мы оставили его без внимания.

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

    1. Реализовать-таки возможность повторного прохождения игры без перезапуска программы;
    2. Добавить немного «геймплея». Иначе говоря, введем уровни сложности и подсчет очков. Новые уровни можно реализовать как повторное прохождение игры с увеличением сложности (скажем, за счет расширения диапазона загадываемых значений);
    3. В продолжение п. 2 добавить еще и таблицу рекордов, которая будет сохраняться на диске.

    Поскольку часть работы уже выполнена, то для того, чтобы приступить к разработке новой версии игры (назовем ее «Угадай-ка 2.0»), мы не будем как обычно создавать новый консольный проект в Delphi, а откроем уже существующий (Ugadaika) и сохраним его под новым именем, скажем, Ugadaika2, и в новом каталоге. Таким образом, мы уже имеем часть исходного кода, отвечающую за угадывание, в частности, цикл while (см. листинг 4.5). Этот фрагмент логичнее всего выделить в отдельную процедуру, вернее даже функцию, которая будет возвращать число попыток, сделанное пользователем. Для этого создадим функцию, которая будет принимать в качестве аргумента число, которое следует угадать, а возвращаемым значением будет целое, соответствующее числу попыток. Ее объявление будет таким:

    function GetAttempts(a: integer):integer;

    Данная функция так же должна иметь в своем распоряжении переменную, необходимую для ввода пользователем своего варианта ответа. Еще одна переменная нужна для подсчета результата, т.е. количества попыток. В качестве первой можно было бы использовать глобальную переменную (b), однако во избежание накладок, для локального использования в функции следует использовать локальную же переменную. Что касается переменной-счетчика, то для нее как нельзя лучше подходит автоматическая переменная result. Еще одним изменением будет использование цикла repeat вместо while. Это вызвано тем, что с одной стороны, тем, что хотя бы 1 раз пользователь должен ввести число, т.е. условие можно проверять в конце цикла, а с другой мы можем избавиться от присвоения лишнего действия, а именно — присвоения заведомо ложного значения переменной b. Ну и еще одно дополнение — это второе условие выхода, а именно — ограничение на число попыток, которое мы установим при помощи константы MAXATTEMPTS:

    const MAXATTEMPTS = 10;

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

    Листинг 6.6. Функция GetAttempts

    function GetAttempts(a: integer):integer; var b: integer; begin Result:=0; repeat inc(Result); // увеличиваем счетчик числа попыток write(#13+#10+’?:’); read(b); if (b>a) then begin write(‘Too much!’); continue; end; if (b

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

    var level, score, attempt: integer; f: TextFile; s: string;

    Теперь инициализируем счетчик псевдослучайных чисел (т.е. оставим randomize на месте) и инициализируем нулем значения счета и уровня:

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

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

    repeat writeln(‘Level ‘+IntToStr(level)+’:’); writeln(‘From 0 to ‘+IntToStr(level*100)); attempt:=GetAttempts(random(level*100+1)); score:=score+(MAXATTEMPTS-attempt)*level; writeln(#10+’You current score is: ‘+IntToStr(score)); inc(level); until attempt>MAXATTEMPTS;

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

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

    if not FileExists(‘record.txt’) then begin Rewrite(f); writeln(f,’0′); // первая строка содержит число-рекорд writeln(f,’None’); // а вторая — имя последнего победителя CloseFile(f); end;

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

    Reset(f); readln(f, attempt); readln(f,s); writeln(#10+’BEST SCORE: ‘+IntToStr(attempt)+’ by ‘+s); CloseFile(f);

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

    Вот, собственно, и все. Полный код получившейся программы можно увидеть на листинге 6.7, или же в файле проекта в каталоге Demo\Part1\Ugadaika2.

    Листинг 6.7. Программа угадай-ка, окончательный вариант

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

    Массивы Delphi XE7

    Автор: Alex. Опубликовано в Программирование 27 Январь 2015 . просмотров: 17870

    Ни для кого не секрет, что Delphi XE7 получил улучшения в языке Object Pascal для работы с массивами. В этой статье мы разберёмся, что же появилось нового и пробежимся по уже имеющимся возможностям по работе с массивами.

    Объявление и инициализация массива

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

    Как видно из кода, при объявлении многомерного массива при помощи конструкций «array of T», позже возникают проблемы с чтением массива в цикле «for in do». Приходится либо ходить по массиву с помощью цикла «for to do» (см. массив dynArray3) либо объявлять тип дочернего массива (см. массив dynArray2). Гораздо удобнее объявлять тип массива с помощью шаблона «TArray ». При объявлении многомерного массива таким способом при чтении можно использовать циклы «for in do» и «for to do».

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

    Конкатенация массивов, вставка и удаление элементов

    Теперь с массивами можно работать так же, как и со строками, при условии, что массивы динамические и одного типа. Доступны функции Concat, Insert и Delete, а также оператор +.

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

    Тоже самое можно записать с помощью оператора +:

    А вот примеры использования функций Insert и Delete:

    Копирование массивов, изменение размера и другие возможности

    Остальные замечательные функции для работы с массивами остались без изменений. Это Copy, Length, SetLength, Slice и функции для работы с многомерными массивами, такие как DynArrayBounds и DynArrayClear. Вот ещё несколько примеров по работе с массивами:

    Результат нововведений в Object Pascal

    О новых возможностях по работе с массивами в Delphi можно сказать следующее. Разработчики сделали отличное улучшение, работать с массивами теперь станет намного удобнее. Остаётся только пожелать, чтобы язык продолжил развиваться в лучшую сторону. Будем ждать очередных фишек.

    Использование процедур и функций в 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, сохранившийся от его предыдущих версий. При использовании в теле функции переменной с ее именем не забывайте, что существуют большие отличия в обработке этого имени — все зависит от того, где она расположена — в левой части оператора присвоения или же в любом другом месте текста функции. Если имя функции указано в левой части оператора присвоения, то предполагается, что назначается возвращаемое функцией значение. Во всех других случаях предполагается, что осуществляется рекурсивный вызов этой функции.

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

    Диагностические сообщения компилятора Delphi

    Типов сообщений компилятора — более двухсот. Рассмотрим перечень наиболее встречающихся сообщений класса Error


      0. expected but found. Обычно это сообщение возникает при синтаксической ошибке.Например,в случае небаланса скобок,компилятор сообщит: ‘)’ expected but ‘;’ found (вместо ожидавшейся скобки найдена запятая).

    Компилятор часто сообщает, что ‘end’ ожидается,например:x:= 5,7; здесь неуместен разделитель-запятая, а сообщается про end. (‘END’ expected but ‘,’ found)

  • 1. is not a type identifier. Данное не является именем типа.
  • 2. «;» not allowed before ‘Else’. Перед else нельзя ставить точку с запятой
  • 3. Abstract method must be virtual or dynamic. Абстрактный метод должен быть виртуальным или динамическим.
  • 4. Ambiguous overloaded call to . Компилятор не может однозначно выбрать перегружаемый блок. Измените параметр.
  • 5. Array type required. Ошибка возникает в случаях, когда в индексе элемента массива указано больше уровней, чем предусмотрено описанием, и если массив не описан. Например, после объявления двумерного массива х или простой переменной х ошибочно записывают элемент х[2,1,1] (в нем показано три измерения).
  • 6. Assignment to FOR-loop variable . Присваивание значения параметру FOR-цикла в теле цикла.

    Например, вследствие описки дважды используется имя i в кратном цикле:

  • 7. Break or Continue outside of loop. Break или Continue — не в цикле.
  • 8. Cannot initialize local variables. Локальные переменные запрещено инициализировать (задавать им значения при описании).
  • 9. Cannot assign to/read a read-only/write-only property. Присвоение значения свойству read/only и чтение свойства write/only запрещены.
  • 10. Constant expression expected. В этом месте должна стоять константа или константное выражение, например константа выбора в структуре Case.
  • 11. Constant expression violates subrange bounds. Выход значения константы из диапазона. Контроль не полон. Например, «сойдет с рук» присваивание x:=3000000000, где х имеет тип integer, но начение х будет искажено.
  • 12. Constant or type identifier expected. Требуется имя типа или тип-диапазон.
  • 13. Could not compile used unit . Компиляция присоединенного модуля невозможна.
  • 14. Data type too large. Тип определяет структуру размером более 2 Гбайт; это слишком много.
  • 15. Declaration expected but found. Пропущено описание или оператор.
  • 16. Declaration of differs from previous declarations. Данный заголовок блока не соответствует упреждающему объявлению блока.
  • 17. Default parameter must be by-value or constant. Необязательный параметр (со значением по умолчанию) не должен вызываться по ссылке.
  • 18. Expression expected. В этом месте программы должно стоять выражение.
  • 19. Expression too complicated. Выражение излишне сложно для компиляции.
  • 20. File type not allowed here. В этом месте или в этой роли файловую переменную нельзя использовать. Например, она не может быть формальным параметром-значением.
  • 21. For loop control variable must be simple local variable. Параметр цикла должен быть простой локальной (описанной в этом же блоке) переменной.
  • 22. For loop control variable must have ordinal type. Параметр цикла должен иметь порядковый тип.Вещественный тип запрещен.
  • 23. Function needs result type. В заголовке функции надо указывать тип ее результата.
  • 24. Identifier expected but found. В этом месте должно стоять имя. Например, пропущено имя функции после Function.
  • 25. Identifier redeclared . описано повторно, но в пределах блока имя можно описать лишь раз. Проверьте, не обозначена ли локальная переменная тем же именем, что и формальный параметр блока.
  • 26. Illegal character in input file . Запретный знак, например «русская» буква, либо вы оставили скобку >, убрав открывающую скобку <.
  • 27. Illegal type in Read/Readln (Write/Writeln) statement. Элемент запрещенного типа в списке ввода/вывода.
  • 28. Incompatible types . Несоответствие типов по присваиванию или типов операндов одной операции. Сообщение выдается и при неверном использовании структур. Например, z — запись, ошибочно записано присваивание z:= 0 (работать надо с полями записи).
  • 29. Invalid function result type. Недопустимый тип результата функции.
  • 30. Label already defined: . уже помечает другой оператор.
  • 31. Left side cannot be assigned to. He может быть такой левой части в присваивании. Примеры: попытка присвоить значение файловой переменной, присвоение значения формальному параметру-константе.
  • 32. Line too long. В строке программного текста больше 255 знаков.
  • 33. Low bound exceeds high bound. Нижняя граница превышает верхнюю.
  • 34. Missing operator or semicolon. Пропуск операции (например перед скобкой) или пропуск точки с запятой. При пропуске ‘;’ маркер ошибки стоит на очередном предложении (объявлении или операторе).
  • 35. Missing parameter type. He указан тип формального параметра-значения или параметра процедурного типа.
  • 36. Not enough actual parameters. He хватает фактических параметров.
  • 37. Need to specify at least one dimension . Нужно задавать в операторе SetLength хотя бы один размер динамического массива.
  • 38. Number of elements differs from declaration. Число элементов в структурной константе не соответствует ее описанию.
  • 39. Operator not applicable to this operand type. Операция не применима к операндам данного типа. Например: ‘А’ or ‘В’; ‘Text1’* ‘Text2’.
  • 40. Order of fields in record constant differs from declaration. Порядок полей в записи-константе не соответствует описанию записи.
  • 41. Ordinal type required. Требуется порядковый тип (например, в индексе).
  • 42. Out of memory. Компилятору не хватает памяти.
  • 43. Statement expected but found. В этом месте должен стоять оператор. Сообщение выдается во всех случаях, когда в тело блока или секцию инициализации ошибочно помещают описание ( ). Ошибочная форма обращения к процедуре Procedure или к функции Function также вызывает сообщение.
  • 44. Sets may have at most 256 elements. Множество (тип Set) не может содержать более 256 элементов.
  • 45. Slice standard function only allowed as open array argument. Функцию Slice можно использовать лишь как фактический параметр
  • 46. Statement not allowed in interface part. Предложения в секции интерфейса программного модуля недопустимы.
  • 47. Syntax error in real number. Синтаксическая ошибка в записи числа вещственного типа.
  • 48. There is no overload version of that can be called with these arguments. Не предусмотрен перегружаемый блок , который мог бы вызываться с таким аргументом. Пример: IntToStr(x), где х — выражение вещественного типа.
  • 49. Too many actual parameters. Фактических параметров больше, чем формальных.
  • 50. Type actual and formal var parameters must be identical. Тип фактического параметра должен быть идентичен типу формального параметра-переменной.
  • 51. Type of expression must be . Выражение должно быть указанного типа. Например,после While и Until должно стоять логическое выражение.
  • 52. Undeclared identifier: . Не описано . Проверьте есть ли описание в нужном месте,нет ли описок в имени. Если указано имя компонента формы, проверьте,поместили ли компонент на данную форму.
  • 53. Unexpected end of file in comment started on line . Неожиданный конец файла при незавершенном комментарии, начало комментария — в строке N.
  • 54. Unit name mismatch: . Имя модуля ошибочно.
  • 55. Unsatisfied forward or external declaration . Отсутствует описание блока, объявление которого было дано (заголовок в интерфейсе или в описании объектного типа, либо упреждающее описание).
  • 56. Unterminate string. He закрыта апострофом строка-константа типа string.
  • Рассмотрим также некоторые сообщения классов warning и hint.

    • Return value of function might be undefined. В теле функции нет присваивания ее результата.
    • Variable might not have been initialized. Указывает имя переменой, которой не задали значения.
    • For-Loop variable may be undefined after loop. Попытка использования значения параметра For-цикла после завершения этого цикла.
    • Text after final «END.’ ignored by compiler. Текст, идущий за конечной строкой модуля, игнорируется компилятором.
    • Variable is declared but never used in . Обращает внимание на переменную , описанную,но не нашедшую применения.
    • Value assigned to never used. Хотя бы одно значение переменной никак не использовано.

    Несколько рекомендаций

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

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

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

    Delphi 2006. Справочное пособие: Язык Delphi, классы, функции Win32 и .NET. — Архангельский А.Я.

    CompareValue, IsZero, SameValue

    Сравнивают два действительных значения Библиотеки VCL Win32, VCL .NET, NFCL Модуль в VCL Win32 Math Пространство имен в .NET Borland.Vcl.Math

    TValueRelationship = -1..1; const Com pa revalue, IsZerof SameVaIue

    LessThanValue = Low(TValueRelationship); EqualsValue = 0;

    GreaterThanValue = High(TValueRelationship); в Math и Borland.Vcl.Math:

    function CompareValue(const A, B: Double;

    Epsilon: Double = 0): TValueRelationship; function CompareValue(const A, B: Single;

    Epsilon: Single = 0): TValueRelationship; function CompareValue(const A, B: Integer): TValueRelationship; function CompareValue(const A, B: Int64): TValueRelationship;

    function IsZero(const A: Double; Epsilon: Double = 0): Boolean; function IsZero(const A: Single; Epsilon: Single = 0): Boolean;

    function SameValue(const A, B: Double;

    Epsilon: Double = 0): Boolean; function SameValue(const A, B: Single;

    Epsilon: Single = 0): Boolean;

    function CompareValue(const A, B: Extended;

    Epsilon: Extended = 0): TValueRelationship; function IsZero(const A: Extended;

    Epsilon: Extended = 0): Boolean; function SameValue(const A, B: Extended;

    Epsilon: Extended = 0): Boolean;

    Различные перегруженные формы функции CompareValue сравнивают значения двух своих числовых аргументов А и В различного типа. Функции возвращают:

    Значение Именованная константа Условие
    -1 LessThanValue А В

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

    Перегруженные формы функций IsZero осуществляют проверку, равен ли параметр А нулю с точностью до Epsilon. Функции возвращают true, если модуль А не превышает Epsilon. Надо отметить, что функция IsZero неявным образом используется во многих библиотечных функциях модуля Math и пространства имен Borland.Vcl.Math, в частности, при вычислении гиперболических и обратных тригонометрических функций.

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

    По умолчанию во всех функциях Epsilon = 0, так что осуществляется «почти» точное сравнение. Именно «почти», так как в реализации функций при 970

    Глава 12 ¦ Описания функций

    Epsilon = 0 все-таки задается отличное от нуля значение. Оно определяется в зависимости от типа аргументов одним из следующих выражений:

    Epsilon := Мах(Min(Abs(A), Abs(B)) * DoubleResolution, DoubleResolution);

    Epsilon Мах(Min(Abs(A), Abs(B)) * SingleResolution, SingleResolution);

    Приведенные выражения относятся к функциям CompareYalue и SameYalue. В функциях IsZero значения Epsilon просто равняются ExtendedResolution, DoubleResolution или SingleResolution. Во всех приведенных выражениях фигурируют константы, равные:

    ExtendedResolution = 1Е-16; DoubleResolution = 1Е-12; SingleResolution = 1Е-4;

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

    Пусть А и В — действительные числа, причем А = 10.05, а В = 10. Тогда выражение CompareValue(A, В) вернет +1, а выражение CompareValue(A, В, 0.01*Abs(B)) вернет 0, так как это выражение сравнивает число с точностью до 1%. Выражение SameValue(A, В) вернет false, а выражение SameValue(A, В, 0.01*Abs(B)) вернет true.

    Возвращает подстроку указанной строки

    Библиотеки VCL Win32, VCL ..NET, NFCL

    Модуль в VCL Win32 System

    Пространство имен в .NET Borland.Delphi.System

    function Copy(S; Index, Count: Integer): string;

    function Copy(S; Index, Count: Integer): array;

    Функция Copy возвращает подстроку строки S, начинающуюся с индекса Index и содержащую до Count символов. Строка S может бытьвыражением типа string или динамическим массивом. Если S — динамический массив, то функция Сору может использоваться в качестве параметра при вызове процедуры или функции, принимающей массив параметров. Т.е. в этом случае Сору действует как функция Slice, работающая с динамическим массивом.

    Если индекс Index превышает длину S, то функция возвращает пустую строку или массив. Если Index + Count превышает число элементов, то возвращается строка или массив, содержащие элементы, начиная с индекса Index и до конца S. CreateMessageDiatog

    Примеры применения функции Сору вы можете найти в разд. 5.1.2.1, 5.2.5.1.

    Создает диалоговое окно сообщения в виде объекта формы

    Функции delphi

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

    Начнем с общего определения:

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

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

    Давайте разберем как определить функцию.

    Итак, в начале идет ключевое слово function, затем имя функции. Далее в круглых скобках список параметров. Также необходимо указать тип возвращаемого результата. При необходимости можно определить локальные переменные. Между операторных скобок (begin..end;) необходимо записать требуемые инструкции.

    В каждой функции Delphi автоматически создает переменную с именем result, переменная имеет тот же тип, что и возвращаемое значение функции. С помощью этой переменной мы и будем возвращать значения. (Есть еще одна возможность вернуть значение, её я продемонстрирую на примере).

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

    Разберем применение функций Делфи на простом примере.

    Создайте новое приложение и на форме разместите три кнопки (Button).

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

    Сама же функция будет иметь следующий вид:

    Название – square, параметр всего один – x типа Double, результат тоже будет Double.

    Делфи позволяет возвращать значения через переменную, название которой совпадает с названием функции Delphi. В нашем случае это выглядит так: square:=x*x;(закомментированный код).

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

    • Для первой кнопки — ShowMessage(FloatToStr(square(1)));
    • Для второй — ShowMessage(FloatToStr(square(2)));
    • Для третей — ShowMessage(FloatToStr(square(3)));

    У меня получился следующий Unit

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

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

    Массив как результат функции

    07.06.2011, 09:37

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

    Как получить результат из функции
    разъясните пожалуйста по функции. задача: нужно передать в функцию строку а получить указатель.

    Как узнать результат функции приложения A из приложения В
    Приложение А работает и вернула значение функции True или False. Как узнать об этом из приложения.

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

    Вывести результат функции в массив
    Вычислить функцию у=х*х, результаты вывести в массив 2х10; х є В VBA, надо в C#: Sub m_1() .

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