355 500 произведений, 25 200 авторов.

Электронная библиотека книг » Олег Деревенец » Песни о Паскале (СИ) » Текст книги (страница 7)
Песни о Паскале (СИ)
  • Текст добавлен: 6 ноября 2017, 03:30

Текст книги "Песни о Паскале (СИ)"


Автор книги: Олег Деревенец


Жанр:

   

Драматургия


сообщить о нарушении

Текущая страница: 7 (всего у книги 29 страниц)

2 – послушный, но беспечный – смотрит только на светофор;

3 – хитрый вольнодумец – идет только на красный, если это ничем не грозит;

4 – непримиримый вольнодумец – идет только на красный;

5 – экстремал – идет только на красный, и так, чтобы грозила опасность;

6 – «безбашенный» – идет, несмотря ни на что;

7 – запуганный – никогда не идет через дорогу, а ищет подземный переход.

Глава 21

Отладка

Предыдущую главу мы покинули, понурив голову, так и не совладав с программой P_20_1. Почему не заменяются символы в строке? – этот вопрос остался без ответа. Эх, знать бы, что творится внутри программы! Сейчас она для нас – загадочный «черный ящик», и мы видим лишь то, что входит и выходит из него. К счастью, в IDE есть средство для доступа внутрь этого «ящика», и мы воспользуемся им. Это средство называется отладчиком. Так же, как редактор текста и компилятор, отладчик встроен в интегрированную среду разработки.

Отладчик

Отладчик – это набор инструментов для исследования «потрохов» программы. Посредством отладчика можно следить за выполнением отдельных операторов, делая остановки в нужных местах или на каждой строке программы. Застопорив программу, вы сможете выяснить значения тех или иных переменных и даже изменить их. Одним словом, отладчик – это чудо-оружие!

Инструменты отладчика доступны через два пункта меню: Run – запуск и Debug – удаление багов (жучков). Программные ошибки прозвали багами – «жучками».

В пункте Run собраны команды для управления ходом выполнения программы (рис. 45).


Рис. 45 – Пункты меню RUN для доступа к отладчику

Примечание. В данной главе показаны окна отладчика для Borland Pascal, в IDE Free Pascal они выглядят чуть иначе.

В табл. 1 даны пояснения к пунктам этого меню.

Табл. 1 – Описание пунктов меню Run

Команда

Горячая клавиша

Пояснение

Run

Ctrl+F9

Запускает программу в непрерывном режиме.

Trace into

F7

Выполняет одну строку программы (шаг). Если в строке есть вызов процедуры, то останов происходит на входе в нее, – так можно «войти» внутрь процедуры и следить за ходом её выполнения.

Step over

F8

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

Go to cursor

F4

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

Program Reset

Ctrl+F2

Сброс программы. Если программа остановлена в пошаговом режиме, она перейдет в исходное состояние.

Parameters…

нет

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

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

Теперь обратимся к пункту меню Debug (рис. 46), где собраны команды для просмотра переменных, их редактирования, а также для просмотра выводимых программой результатов. Эти результаты можно увидеть либо на экране (User screen) либо в специальном окне (Output). Рядом с командами показаны соответствующие им горячие комбинации клавиш.


Рис. 46 – Пункт меню Debug для просмотра результатов работы программы

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

Жучки, вылезайте!

Итак, приступим к поиску жучков, притаившихся в программе «P_20_1». Хорошо бы проследить за изменением переменных в ходе выполнения программы. Для этого вставим переменные в окно обзора «Watches». Откомпилировав программу, поместите курсор под переменной k и нажмите Ctrl+F7. Появится диалоговое окно для добавления переменной в окно обзора (рис. 47).


Рис. 47 – Добавление переменной в окно обзора

Поскольку переменная k была взята на мушку заранее, поле уже содержит её имя. Теперь щелчок по кнопке OK отправит переменную в окно обзора (рис. 48). Если же поле «Watch expression» пусто, или содержит нечто другое, значит, вы промахнулись, не попали курсором. Тогда впечатайте имя нужной переменной и щелкните OK. Действуя так, добавьте в окно обзора все интересующие вас переменные (рис. 48).


Рис. 48 – Окно обзора переменных Watches

Пока программа не запущена, напротив имен переменных выводится сообщение о невозможности доступа к ним, – пусть вас это не смущает. Лучше взгляните на то, как расположено окно «Watches». Сейчас оно занимает нижнюю часть экрана и закрывает собой часть окна с программой. Это неудобно, а посему обратитесь к пункту меню Window –> Tile (Окна –> Рядом) как показано на рис. 49.


Рис. 49 – Пункт меню Window –> Tile

В результате окна с текстом программы и списком переменных поместятся, не перекрывая друг друга (рис. 50). То же самое можно сделать и мышкой, перетаскивая и меняя размеры окон.

Теперь станем выполнять программу по шагам, следя за изменением переменных. Вместо привычной комбинации Ctrl+F9, для пуска программы в пошаговом режиме нажимают клавишу F7 (команда Run –> Trace). Тогда отладчик остановит программу перед первым оператором, подсветив его особым образом. Последующие нажатия клавиши F7 заставят выполняться следующие строки программы, и очередная строка будет выделяться цветной полоской.

Нажав клавишу F7 четыре раза, мы достигнем оператора Readln, – здесь программа остановится в ожидании ввода строки. Введите как обычно строку из латинских букв «QAAAW» и нажмите Enter, – и тогда программа остановится перед входом в процедуру Scan, как показано на рис. 50.

Примечание. В отладчике IDE Free Pascal при вводе строки необходимо нажать клавишу Enter дважды.


Рис.50 – Состояние программы перед входом в процедуру Scan

В этом месте рассмотрим переменные в окне «Watches». Счетчик циклов k равен единице, – это глобальная переменная k, поскольку локальной переменной с этим же именем пока не существует. Переменная S содержит то, что мы ввели с клавиатуры. Параметр arg тоже пока не виден отладчику, о чём говорит сообщение «Unknown identifier».

Нажмите клавишу F7 ещё пару раз, пока цветная полоска не перескочит внутрь процедуры Scan. Здесь параметр arg примет то же значение, что и глобальная переменная S, – это прекрасно видно в отладчике. Продолжайте нажимать клавишу F7, пока цветная полоска не дойдет до слова END в конце процедуры. Вы увидите, как параметр arg постепенно принимает значение «QBBBW», – это то, что нам нужно. Состояние программы в этот момент показано на рис. 51.


Рис. 51 – Состояние программы перед выходом из процедуры Scan

Теперь переменная k равна пяти, – это длина введенной строки. Но это уже другая, локальная переменная k, поскольку её глобальная тёзка внутри процедуры не видна. Но переменная S (тоже глобальная) по-прежнему видна внутри процедуры, ведь её имя не перекрывается локальной переменной.

Нажмите клавишу F7 ещё раз, – программа выйдет из процедуры и цветная полоска перепрыгнет на строку, следующую за вызовом процедуры Scan (рис. 52).


Рис. 52 – Состояние программы после выхода из процедуры Scan

Итак, к чему мы пришли? Сравнив это состояние с тем, что было до входа в процедуру (рис. 50), находим, что значения переменных не изменились. Переменная k снова стала равна единице, и это понятно – ведь теперь это глобальная переменная. Беда в том, что не изменилась и переменная S, а ведь именно этого мы добивались. В чем же дело?

Причина кроется в способе передачи параметра. При вызове процедуры Scan фактический параметр S копируется в формальный параметр arg, и далее внутри процедуры работа введется с этой копией. Иначе говоря, данные передаются только внутрь процедуры, но не обратно. Этот способ передачи параметров называют передачей по значению. Стало быть, глобальная переменная S не должна была измениться! Здесь надо что-то исправлять!

Ссылка на переменную

Рассмотрим ещё раз объявление параметра в процедуре Scan.

procedure Scan(arg : string);

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

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

procedure Scan(var arg : string);

Это мелкое изменение влечет важное следствие: теперь arg – не локальная переменная, а ссылка на другую переменную. Это значит, что в момент вызова процедуры данные не будут копироваться, но параметр arg на время исполнения процедуры станет дублером фактического параметра S. Теперь, изменяя параметр arg, мы тем самым будем изменять и переменную S – наш фактический параметр.

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

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

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

Вернемся к программе. Если она остановилась в пошаговом режиме, прервите её комбинацией Ctrl+F2. Затем исправьте заголовок процедуры указанным выше манером, откомпилируйте программу и вновь пройдите по шагам. Находясь внутри процедуры Scan, вы заметите, что переменные arg и S теперь изменяются синхронно (рис. 53). Это то, что нам нужно, стало быть, проблема решена!


Рис. 53 – Синхронное изменение формального и фактического параметров

Далее можете «толкнуть» программу в непрерывном режиме, нажав комбинацию Ctrl+F9.

Итоги

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

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

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

А слабо?

А) Комбинация клавиш Ctrl+F8 устанавливает так называемые точки останова на исполняемых операторах. Эта же комбинацией отменяет их. Точка останова – это строка, на которой отладчик задерживает выполнение программы и ждет команды на её продолжение в непрерывном или пошаговом режиме..

Установите точку останова на выходе из процедуры Scan (на строке END) и запустите программу в непрерывном режиме (Ctrl+F9). Что произойдет? Чем, по-вашему, удобны точки останова?

Б) Перед запуском программы установите курсор внутри процедуры Scan и испытайте действие команды Run –> Go to cursor (клавиша F4).

Глава 22

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

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

Процедура обмена

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

      T:= A;       { временно запомнить A }

      A:= B;

      B:= T;       { поместить в B то, что раньше было в A }

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

procedure Swap (x: integer; y: integer);

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

procedure Swap (var x: integer; var y: integer);

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

procedure Swap (var x, y: integer);

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

Теперь напишем процедуру Swap и программу «P_22_1» для её проверки.

{ P_22_1 – процедура обмена и программа её проверки }

{ процедура обмена }

procedure SWAP(var x,y : integer);

var t: integer;

begin

      t:= x;       x:= y;       y:= t;

end;

var A, B : integer;

begin       {– главная программа –}

      A:= 10; B:= 20;

      Writeln(’A= ’, A, ’ B= ’, B);

      SWAP(A, B);

      Writeln(’A= ’, A, ’ B= ’, B);

      Readln;

end.

Работает ли эта программа? Обязательно проверьте!

Замена символов в строке

Вернемся к программе P_20_1, где возможности процедуры Scan небогаты: допускается менять только символы «A» на символы «B». А если надо менять символы по своему усмотрению? Пожалуйста! Добавим в заголовок процедуры пару формальных параметров, например, так:

procedure Scan(var arg: string; Ch1, Ch2: char);

var k: integer;

begin

      for k:=1 to Length(arg) do

      if arg[k]= Ch1 then arg[k]:= Ch2;

end;

Здесь параметры Ch1 и Ch2 указывают, что и на что надо поменять. Поскольку параметры однотипны, они разделяются запятой. Порядок объявления формальных параметров в заголовке не важен. Но важно, чтобы при вызове процедуры порядок фактических параметров был таким же. Вот пример правильного вызова (символ «1» меняется на символ «2»).

Scan(S, ’1’, ’2’);

А вот ошибочные:

Scan(S, ’1’);       { указаны не все параметры }

Scan(’1’, S, ’2’);       { нарушен порядок следования параметров }

Scan(S, ’1’, ’2’, ’3’);       { указан лишний параметр }

Scan(S, 1, 2);       { неверный тип параметров }

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

Переработайте программу «P_20_1» с тем, чтобы испытать новую версию процедуры замены символов, а затем исследуйте её в пошаговом режиме.

О передаче строк

Передача строковых данных таит свои тонкости. Рассмотрим процедуру Calc для подсчета заданного символа в некоторой строке.

procedure Calc(arg: string; Ch: char; var Res: integer);

var k: integer;

begin

      Res:=0;

      for k:=1 to Length(arg) do

      if arg[k]= Ch then Res:= Res+1;

end;

Процедура принимает три разнотипных параметра: строку arg, символ Ch и ссылку на переменную Res – в ней возвращается результат. Здесь все правильно. Но недаром говорят: «меньше знаешь, – крепче спишь», – мой сон тревожит параметр arg строкового типа.

Поскольку строка может содержать до 255 символов, параметру arg отводится немалая память – 256 байтов! При передаче по значению все эти байты копируются в параметр arg, и на это тратится время. Если же параметр arg будет ссылкой на строку, то копирования не потребуется, и программа заработает быстрее. Вдобавок мы и память сэкономим, ведь ссылка на строку занимает в памяти всего 4 байта! Раз так, объявим процедуру иначе.

procedure Calc(var arg: string; Ch: char; var Res: integer);

Этот вариант лучше, но не сработает, если в вызове процедуры указать строковую константу, например:

      Calc(’PASCAL’, ’L’, Result);

Здесь компилятор воспротивится не на шутку, требуя в первом параметре переменную. И будет прав, поскольку ключевое слово VAR в заголовке процедуры объявляет ссылку на переменную, а не на константу. Что делать? Вернуться к первому способу? Нет, есть лучшее средство: вместо ключевого слова VAR укажите в заголовке слово CONST, вот так:

procedure Calc(const arg: string; Ch: char; var Res: integer);

Такая ссылка будет годна как для переменной, так и для константы.

      Calc(’PASCAL’, ’L’, Result);       { вызов с константой }

      Calc(S, ’L’, Result);       { вызов с переменной }

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

Итоги

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

• Для экономии памяти и повышения быстродействия строковые данные (и другие сложные типы данных) передают по ссылке с применением ключевых слов CONST и VAR.

• Если строку передают по ссылке только внутрь процедуры, используют ключевое слово CONST, а если обратно или в оба направления – слово VAR.

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

А слабо?

А) Введите в компьютер программу «P_22_1» и проверьте её работу.

Б) Измените программу «P_20_1» так, чтобы заменяемый и замещаемый символы передавались в процедуру Scan через параметры.

В) Напишите программу для проверки рассмотренной выше процедуры Calc, подсчитывающей символ в строке.

Глава 23

Функции

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

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

      x:= 1+ Random(10);       { арифметическое выражение }

      Writeln(Length(S)); { печатается длина строки S };

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

Объявление функции

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

function Имя_Функции : Тип;       { функция без параметров }

function Имя_Функции (Параметры) : Тип;       { функция с параметрами }

Отличий от процедуры всего два. Во-первых, вместо ключевого слова PROCEDURE указано слово FUNCTION. А во-вторых, завершает заголовок тип функции (тип возвращаемого ею результата), – его указывают после двоеточия.

Пример функции

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

function Max(arg1, arg2 : integer) : integer;

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

function Max(arg1, arg2 : integer) : integer;

begin

      if arg1 > arg2

      then Max:= arg1

      else Max:= arg2

end;

Но откуда взялась переменная Max, которой присваиваем значение? Ведь мы её не объявляли! А её и не надо объявлять, – это имя нашей функции, оно и принимает в себя результат. Мало того, если результату не присвоить значение, он останется неопределенным, и это будет ошибкой!

Созданная нами функция может вызываться так:

      A:= Max( 20, 10 );       { A = 20 }

      Writeln( Max( A, B ) );       { печатается большее из A и B }

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

      A:= Max ( Max( 20, 10 ), 40 );       { A = 40 }

      A:= Max ( Max( 20, 10 ), Max( 200, 100 ) ); { A = 200 }

В первом случае сначала вызывается функция Max(20,10), вставленная как первый фактический параметр, а затем Max(20,40), – то есть результат первого вызова подставляется параметром во второй. Похоже работает и другой пример, только функция вызывается трижды. Полезно понаблюдать за такими вызовами через отладчик. Напишите главную программу для исследования функции Max и прогоните её в отладчике.

Подсчет символов в строке

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

Начнем, разумеется, с заголовка функции, дадим ей имя Count (подсчет).

function Count(const Str : string; Ch : char): integer;

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

function Count(const str : string; ch: char): integer;

var N, i: integer;

begin

N:=0; { обнуляем счетчик }

for i:=1 to Length(str) do

      if str[i]=ch then N:= N+1;

Count:= N; { определяем результат функции }

end;

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

      if str[i]=ch then Count:= Count+1; { – это ошибка! }

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

И, наконец, напишем программу «P_22_1» для проверки функции Count. В главной программе функция вызывается сначала для переменной S, а затем для константы «BANAN». Причем во втором случае она вызывается дважды, а результат суммируется. Испытайте эту программу.

{ P_23_1 – подсчет заданных символов в строке }

function Count(const str : string; ch: char): integer;

var N, i: integer;

begin

N:=0; { обнуляем счетчик }

for i:=1 to Length(str) do

      if str[i]=ch then N:= N+1;

Count:= N; { передаем результат через имя функции }

end;

var S: string;

begin {– главная программа –}

S:='PASCAL';

Writeln( Count(S, 'A'));

Writeln( Count('BANAN', 'N') + Count('BANAN', 'B'));

Readln;

end.


Возврат строк

Вернемся к программе «P_20_1», заменяющей символы «A» на символы «B». Помните сколько крови она попортила прежде чем заработать? Заменив процедуру Scan на функцию с тем же именем, мы решим проблему возврата результата. Результат, разумеется, должен иметь строковый тип. Обратите внимание на то, что ключевые слова VAR или CONST в заголовке не указаны, а потому параметр arg можно употребить в теле функции в качестве локальной переменной.

{ P_23_2 – замена символов в строке с применением функции }

function Scan(arg : string): string;

var k: integer;

begin

      for k:=1 to Length(arg) do

      if arg[k]=’A’ then arg[k]:=’B’; { замена в параметре arg }

      Scan:= arg;

end;

var S: string; k: integer;

begin {– главная программа –}

      for k:=1 to 3 do begin

      Write(’Введите строку: ’); Readln(S);

      Writeln(Scan(S));

      end;

      Readln;

end.


Когда результат не важен

Хорошая функция возвращает правильный результат, а отличная делает ещё что-нибудь полезное. Программисты нередко поручают одной функции несколько дел, вот пример: напишем функцию Swap (обмен) булевого типа, принимающую ссылки на две переменные. Функция должна сравнить эти переменные и вернуть TRUE, если первая из них окажется больше второй. Мало того, в этом случае она должна обменять значения этих переменных (как в процедуре Swap, рассмотренной ранее). Короче, функция будет такой.

function Swap( var a1, a2 : integer) : Boolean;

var t: integer;

begin

      if a1 > a2

      then begin

      { обмен значений переменных }

      t:=a1; a1:=a2; a2:=t;

      Swap:= true

      end

      else Swap:= false

end;

Где применить такую функцию? Пусть переменные N1, N2, N3 содержат три разных числа. Переложим эти числа так, чтобы в N1 оказалось наименьшее, а в N3 – наибольшее число, то есть, чтобы соблюдалось условие: N1 < N2 < N3. Такая сортировка выполняется тремя вызовами функции Swap (в комментариях показаны результаты обмена).

      Swap(N1, N2);       { N1 < N2 }

      if Swap(N2, N3)       { N2 < N3 }

      then Swap(N1, N2);       { N1 < N2 < N3 }

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

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

Неявная переменная Result

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

function Count(const str : string; ch: char): integer;

var i: integer;

begin

Result:=0; { обнуляем счетчик }

for i:=1 to Length(str) do

      if str[i]=ch then Result:= Result + 1;

end;

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

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

Итоги

• Функции – это подпрограммы, возвращающие результат через свое имя. Тип возвращаемого результата указывают в заголовке функции.

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

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

• Когда результат функции не используется, её вызывают как процедуру. При этом через настройки компилятора должен быть позволен расширенный синтаксис – «Extended syntax».

А слабо?

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

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

В) Напишите функцию и программу для её проверки, принимающую число и возвращающую строку: слово «четное» или «нечетное» в зависимости от четности или нечетности параметра. Подсказка: для проверки четности числа N надо проверить остаток от его деления на два: if (N mod 2) = 0 then …

Глава 24

Криптография

Говорят, что хороший разведчик стоит целой дивизии. Ещё бы! Ведь лишенный секретов противник почти безоружен. Но вот умолкли пушки, а разведка не спит, – у мирного времени свои тайны: коммерческие и технические секреты. Впрочем, если секретов нет, их можно придумать, – почему бы нам не поиграть в шпионов? Приятно сознавать, что «отмыленное» приятелю письмо никто, кроме вас двоих, не прочтет, – надо лишь зашифровать его. Придумана уйма способов шифрования, есть даже наука об этом – криптография; сейчас и мы коснемся краешка этой премудрости.

Секреты Юлия Цезаря

Римскому полководцу Юлию Цезарю выпали лихие времена. Отправляя гонца с письмом в отдаленный уголок империи, Цезарь рисковал «подарить» свои тайны недругам, – ведь на дорогах было неспокойно. Это надоумило его шифровать свои письма. В чем заключался метод Цезаря?

Прием Юлия состоял в замене одних букв другими путем кругового сдвига алфавита на несколько позиций. На рис. 54 показано превращение букв при сдвиге алфавита на две позиции. Буква «А» становится буквой «В», буква «Б» – буквой «Г» и так далее. Двум последним уготовано превратиться соответственно в буквы «А» и «Б». Такое шифрование превращает письмо в дикую абракадабру!


Рис.54 – Принцип шифрования Юлия Цезаря

Как расшифровать её? Очень просто – сдвинуть буквы в обратную сторону. Но надо знать количество сдвигов – это число называют ключом шифра (в примере на рисунке ключ шифра равен двум). Разумеется, что ключ шифра и метод шифрования знали лишь двое: получатель письма и сам Юлий Цезарь.

Пойдем и мы вслед римскому полководцу, – создадим программу для шифрования текстового файла и его расшифровки. Скажу прямо: задача непростая, а потому решать её будем в два этапа. Вначале освоим шифрование отдельной строки, а уж потом «замахнемся» на файл. Но начнем с шифрования отдельного символа.

Суть проблемы

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

function Encrypt (X: char): char;

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

if X=’А’

      then Crypt:=’В’

else if X=’Б’

      then Crypt:=’Г’

else...

Насколько удачно это решение? Прикинем количество вложенных операторов в этой лесенке. В русском алфавите 33 буквы, если взять заглавные и строчные, то получится 66. А если надумаем шифровать ещё и латинские буквы, и цифры и знаки препинания, то наберется около двух сотен символов. Такая лесенка условных операторов растянется на несколько этажей!

Не прибегнуть ли к оператору выбора CASE? Тогда тело функции будет намного проще:


    Ваша оценка произведения:

Популярные книги за неделю