Основы программирования в паскале

      С другой стороны, описание всех формальных параметров как параметров-переменных нежелательно по двум причинам.

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

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

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

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

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

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

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

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

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

      8.3. ПАРАМЕТРЫ-МАССИВЫ  И ПАРАМЕТРЫ-СТРОКИ

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

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

      Поэтому нельзя, например, объявить следующую процедуру:

Procedure S (a: array [1..10] of Real);

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

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

      Например:

      аtype = array [1..10] of Real;

      Procedure S (a: atype);

      …….

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

      type

      intype = String [15];

      outype = String [30];

Function St (s : intype) : outype;

……..

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

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

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

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

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

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

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

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

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

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

      Если  соответствующий параметр объявлен параметром-значением, эта опция игнорируется и длина не контролируется.

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

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

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

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

      Procedure MyProc(OpenArray: array of Integer); 

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

      {Иллюстрация  использования открытых  массивов:

      программа выводит на экран  содержимое двух одномерных массивов разной длины с помощью одной процедуры Array Print}

Procedure ArrayPrint(aArray: array of Integer);

      var

      k: Integer;

  begin

      for k := 0 to High(aArray) do Write(aArray[k]:8) ;

      WriteLn

  end; 
 

  (Эти недостатки  практически полностью устранены  в языке Object Pascal, используемом в визуальной среде программирования Delphi.)

      const

      A: array [-1..2] of Integer = (0,1,2,3);

      В: array [5..7] of Integer = (4,5,6);

      begin

      ArrayPrint(A) ;

      ArrayPrint(B)

      end. 

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

      Однако  размерность открытых массивов (количество индексов) всегда равна 1 - за этим следит компилятор.

      Если  бы, например, мы добавили в программу  двумерный массив С 

      var

      С: array [1..3,1..5] of Integer; 

      то  обращение 

      ArrayPrint(С)

       

  вызвало бы сообщение об ошибке 

      Error26: Type mismatch.

      (Ошибка 26: Несоответствие типов.) 

      8.4. ПРОЦЕДУРНЫЕ ТИПЫ. ПАРАМЕТРЫ-ФУНКЦИИ  И ПАРАМЕТРЫ-ПРОЦЕДУРЫ

      Процедурные типы - это нововведение фирмы Borland (в стандартном Паскале таких типов нет).

      Основное  назначение этих типов - дать программисту гибкие средства передачи функций и процедур в качестве фактических параметров обращения к другим процедурам и функциям.

      Для объявления процедурного типа используется заголовок процедуры (функции), в котором опускается ее имя, например: 

      type

      Proc1 = Procedure (a, b, c: Real; var d: Real) ;

      Proc2 = Procedure (var a, b);

      РгосЗ = Procedure;

      Func1 = Function: String;

      Func2 = Function (var s: String): Real; 
 

      Как видно из приведенных примеров, существует два процедурных типа: тип-процедура и тип-функция.

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

      sinl(x) = (sin(x) +1) * ехр(-х)  

      и 

      cosl (х) = (cos(x) +1) * ехр(-х). 

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

      Пример 8.3.

      Uses CRT;

      type

      Func = Function (x: Real): Real;

      {------------------------}

      Procedure PrintFunc(XPos: Byte; F:Func);

      {Осуществляет  печать функции  F (XPos - горизонтальная

      позиция начала вывода)}

      const

      np = 20; {Количество вычислений функций}

      var

      x:real;

      I:integer;

             

      begin {PrintFunc}         

        for i : = 1 to np do

      begin

      x := i * (2 * pi / np) ;

      GotoXY (XPos, WhereY);

      WriteLn (x:5:3, F(x):18:5)

      End

      end; {PrintFunc}

      {------------------}

      Function Sinl(x: Real): Real; far;

      Begin

      sinl := (sin(x) + 1) * exp(-x)

      end;

      {---------------------} 
 

      Function Cosl(x: Real): Real; far;

      begin

      cosl := (cos(x) + 1) * exp(-x)

      end;

      {----------------------}

      begin {основная программа)

      CIrScr;                     {Очищаем экран}

      PrintFunc (1, sin1);

      GotoXY (1,1);               {Переводим курсор

      в левый верхний  угол}

      PrintFunc (40, cos1)