FORпеременная:=начальное значение DOWNTOконечное значение DO

оператор/блок.

Здесь переменная - любая переменная порядкового типа, называемая в таком контексте переменной цикла, начальное значение и конечное значение - выражения того же типа. Цикл FORвыполняется следующим образом: переменной цикла присваивается начальное значение, после чего выполняется тело цикла (оператор или блок, стоящий после DO). Два этих действия вместе составляют один шаг цикла. Затем переменной цикла присваивается следующее (в цикле FOR ... TO) или предыдущее (в цикле FOR ... DOWNTO) значение и выполняется следующий шаг цикла. Так происходит до тех пор, пока значение переменной цикла не станет больше (FOR...TO) или меньше (FOR...DOWNTO) конечного значения. Цикл FORможет не выполниться ни разу, если начальное значение больше конечного в цикле FOR...TOили меньше конечного в цикле FOR ... DOWNTO. Запишем два примера использования цикла FOR: вычислим сумму квадратов натуральных чисел от 1 до N:

var i : word; s:single;

const n = 22;

begin

s:=0;

for i:=1 to n do

s:=s+sqr(i);

writeln('сумма=',s:8:2);

end.

Теперь выведем на экран символы с номерами от 32 до 255:

var c : char;

begin for c:=' ' to #255 do

write(c ,' ');

writeln;

end.

Второй тип цикла - цикл WHILE- записывается в виде:

WHILEлогическое выражение DOоператор/блок

Здесь логическое выражение - любое выражение типа Boolean. Цикл выполняется следующим образом: вычисляется логическое выражение и, если оно истинно, выполняется тело цикла, в противном случае цикл заканчивается. Очевидно, что цикл WHILEможет как не выполниться ни разу, так и выполняться бесконечное количество раз (в последнем случае говорят, что программа зациклилась). Запишем две предыдущие задачи, используя цикл WHILE:

const n = 22; var i : word ; s : single; begin i:=1; s:=0; while i<=n do begin s:=s+sqr(i); inc(i); end; writeln('сумма=',s:8:2); end.

var c : char; begin c:=pred(' '); while c<#255 do begin c:=succ(c); write(c ,' '); end; writeln; end.

В качестве упражнения, подумайте, почему программа

var c : char;

begin c:=' ';

while c<=#255 do

begin write(c);

c:=succ(c);

end;

writeln;

end.

оказывается зацикленной.

Третий тип цикла - REPEAT -записывается в виде:

REPEATоператоры UNTILлогическое выражение;

Если тело цикла REPEATсодержит больше одного оператора, нет необходимости использовать блок, поскольку сами ключевые слова REPEATи UNTILявляются в данном случае логическими скобками. Перед UNTILможно не ставить ";". Цикл REPEATвыполняется так: сначала выполняется тело цикла, затем вычисляется логическое выражение, и если оно истинно, цикл заканчивается. Таким образом, цикл REPEATвсегда выполняется хотя бы один раз. Обратите внимание на то, что тело цикла WHILE выполняется до тех пор, пока логическое выражение истинно, а тело цикла REPEAT - пока логическое выражение ложно. Запишем наши примеры, используя цикл REPEAT:

const n = 22; var i : word ; s : single; begin i:=1; s:=0; repeat s:=s+sqr(i); inc(i) until i>n; writeln('сумма=',s); end.

var c : char; begin c:=pred(' '); repeat c:=succ(c); write(c) until c=#255; writeln; end.

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

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

const parol='tdf25';

var i:integer;

s:string;

begin for i:= 1 to 3 do

begin

write('введите пароль'); readln(s);

if s = parol

then break

else if i <> 3 then continue;

writeln('доступ к программе запрещен');

writeln( 'нажмите enter');

readln;

halt

end;

writeln('пароль верен, доступ к программе разрешен'); readln;

end.

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

Пример нахождения суммы бесконечного ряда

var i : Integer;

eps, sum, znam, slag : Extended;

begin

writeln(Rus('Ведите необходимую точность вычислений'));

readln(eps);

Sum:=1; znam:=1; i:=1;

repeat

slag:=1/znam;

Sum:=Sum+slag;

inc(i);

znam:=znam*i;

until slag<eps;

writeln(Rus('Сумма ряда = '),Sum:15:12);

writeln(Rus('Точное значение = '),exp(1):15:12);

readln;

end.

Пример нахождения суммы бесконечного функционального ряда

, где .

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

var y, sum, x, eps, a, mnog : extended;

i, m_dop: Word;

begin

writeln(Rus('Введите значение аргумента '), 'x='); readln(x);

writeln(Rus('Введите значение погрешности '), 'eps='); readln(eps);

writeln(Rus('Введите максимально допустимое количество членов

ряда')); readln(m_dop);

y:= sin(x);

i:= 0; {количество членов ряда}

a:= x; { a - первый член ряда }

Sum:= a; { Sum - первая частичная сумма ряда }

while (abs(a) > eps) and (i<=m_dop) do

begin

i:= i+1;

mnog:= -x*x/(2*i*(2*i+1));

a:= a*mnog;

Sum:= Sum+a;

end;

if i<=m_dop

then

begin writeln(Rus('Контрольное значение функции'),' sin(x)= ', y:12:8);

writeln(Rus('Приближенное значение функции = '),Sum:12:8);

writeln(Rus('при количестве членов ряда='), i );

end

else

begin writeln(Rus('Количество членов ряда превосходит максимально

допустимое'));

writeln(Rus('Требуемая точность вычислений не достигнута'));

end;

readln;

end.

 

Дадим краткую сравнительную характеристику циклических операторов:

			Таблица 4
	WHILE	REPEAT…UNTIL	FOR
Определение параметров цикла	До начала цикла должны быть сделаны начальные установки переменных, управляющих условием цикла, для корректного входа в цикл	Начальная установка переменной счетчика циклов до заголовка не требуется
Параметры цикла	В теле цикла должны присутствовать операторы, изменяющие переменные условия так, чтобы цикл через некоторое число итераций завершился.	Изменение в теле цикла значений переменных, стоящих в заголовке цикла, не разрешается
Работа цикла	Цикл работает пока условие истинно (пока True)	Цикл работает пока условие ложно (пока False).	Количество итераций цикла неизменно и точно определяется значениями нижней и верхней границ и шага цикла
Условие завершения цикла	Цикл завершается, когда условие становится ложным (до False).	Цикл завершается, когда условие становится истинным (до True).	Нормальный ход работы цикла может быть нарушен оператором goto или процедурами BREAK и CONTINUE
Минимальное количество выполнения тела цикла	Цикл может не выполниться ни разу, если исходное значение условия при входе в цикл равно False.	Цикл обязательно выполняется как минимум один раз	Цикл может не выполниться ни разу, если шаг цикла будет изменять значение счетчика от нижней границы в направлении, противоположном верхней границе
Условие использования составного оператора тела цикла	Если в теле цикла требуется выполнить более одного оператора, то необходимо использовать составной оператор	Независимо от количества операторов в теле цикла использование составного оператора не требуется	Если в теле цикла требуется выполнить более одного оператора, то необходимо использовать составной оператор

 

12. Метки. Оператор GOTO. Процедура Halt

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

GOTOметка;

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

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

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

var x : single;

begin write('введите число '); read(x);

x:=sqrt(x); write(x:5:2);

end.

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

var x : single;

label finish;

begin write('введите число '); read(x);

if x<0 then goto finish;

x:=sqrt(x); write(x:5:2);

finish: end.

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

var x : single;

begin write('введите число '); read(x);

if x<0

then writeln('ошибка !')

else begin x:=sqrt(x); write(x:5:2); end;

end.

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

13. Интервальные типы данных. Оператор TYPE. Массивы

 

Интервальный тип - это некоторый подтип порядкового типа данных (вспомним, что порядковые типы - это ShortInt, Byte, Integer, Word, LongInt, Charи Boolean). Пусть, например, некоторая переменная в программе может принимать значения от -1 до 99. Мы могли бы описать ее как LongIntили Integer(хотя это излишне!), могли бы описать ее как ShortInt, что достаточно разумно. Но можно создать для нее и специальный тип данных, объединяющий только числа от -1 до 99:

var x : -1..99;

Вместо имени одного из стандартных типов мы использовали в описании переменной построенный нами собственный интервальный тип. Таким образом, описанная переменная x может принимать только значения -1, 0, 1, ..., 99 , в остальном она ничем не отличается от других целых переменных. Ее можно вводить, выводить, использовать в качестве переменной цикла, подставлять в выражения и т.п. Любой интервальный тип есть подтип некоторого стандартного базового типа, в нашем случае - типа ShortInt. Но если бы мы стали использовать интервальный тип -1..200, то он бы уже был подтипом типа Integer, а 0..200-подтипом типа Byte. Компилятор Паскаля самостоятельно анализирует интервальные типы и подбирает для них минимальный подходящий базовый тип. Это нужно знать, чтобы определять размер и способ кодировки ваших переменных. Вы можете выполнить оператор

write('переменная x:-1..99 занимает ',sizeof(x),' байт');

и убедиться, что ее размер действительно равен 1.

В качестве базового типа можно использовать не только арифметические типы, но и типы Charи Boolean(правда, в последнем случае это довольно бессмысленно). Опишем, например, переменную, значением которой могут быть только маленькие латинские буквы:

var letter : 'a'..'z';

В общем случае интервальный тип описывается как

константное выражение 1 ..константное выражение 2

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

TYPEимя типа=описание типа;

Операторы TYPEтак же, как и все другие операторы описания, записываются в разделе описаний. В программе может быть сколько угодно операторов TYPE, и их можно чередовать с другими операторами описания, но любые идентификаторы, использованные в описании типа, должны быть описаны раньше. После того, как некоторый тип получил имя, вы в дальнейшем можете пользоваться этим именем вместо полного описания типа: const tmin=-5;

tmax=15; type t_range_type=tmin..tmax;

var t:t_range_type;

type t_range_subtype=tmin+3..tmax-5;

var t1:t_range_subtype;

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

Теперь, зная об интервальных типах, мы можем говорить о массивах. Массив во всех языках программирования - это множество индексированных (пронумерованных) однотипных элементов. В Паскале описание одномерного массива имеет вид:

ARRAY[тип индекса] OFтип элемента

Здесь тип индекса - ShortInt, Byte, Char, Booleanили интервальный тип; тип элемента - любой тип, в том числе и массив. Вы заметили, что не все порядковые типы можно использовать как тип индекса, это не значит, что, например, тип Wordчем-то хуже типа Byte. Такое ограничение обусловлено тем, что в Паскале никакой объект не может иметь размер больше (64К - 2) байта, или 65534 байта. Это ограничение действует и для интервальных типов, так вы можете описать массив var a : array[1..65534] of byte; но не массив var a : array[1..65535] of byte; и не массив var a : array[1..33000] of word;

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

var a : array[char] of 1..5;

- массив из 256 элементов, каждый из которых есть целое число от 1 до 5, индексы элементов изменяются от #0 до #255;

const max = 99; min = 10;

type nums = min..max;

type arraytype = array[-10..0] of nums;

var a : arraytype;

- массив из 11 элементов с индексами от -10 до 0, каждый элемент - целое положительное число из двух цифр;

type indextype = 'a'..'z';

var a: array [indextype] of boolean;

- массив из 26 элементов с индексами от 'a' до 'z', каждый элемент - логическая переменная.

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

имя массива [индексное выражение]

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

var a : array[1..3] of single;

b,c,d : array[1..3] of single;

type massiv=array[1..3] of single;

var e,f : massiv;

g : massiv;

h,i : massiv;

то массивы b,c,d- однотипные и массивы e,f,g,h,iтоже однотипные, но массивы aи b(aи c,aи d) имеют разный тип; и массивы b(c,d,a) и e(f,g,h,i) тоже имеют разный тип! Компилятор считает, что две переменные имеют один и тот же тип, только если они описаны в одном операторе через запятую, либо имена их типов одинаковы! Запомните это очень важное правило.

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

const Nmax=100;

type IndexType = 1..Nmax;

Mas = array [IndexType] of integer;

var i,dim:1..100;

a,b,c:Mas;

N,j,k:Byte;

S,a_max:Integer;

begin

repeat

writeln('Введите размерность массива от 1 до ',Nmax);

readln(dim)

until (dim>=1) and (dim<=Nmax);

repeat

writeln('Заполнить массив вручную (1) или случайным образом (2)?);

readln(N)

until (N<>1) or (N<>2);

if N=1

then for i:= 1 to dim do

begin write(' Введите A[ ' , i , ' ] = ' );

readln(a[i])

end

else begin randomize;

for i:= 1 to dim do

a[i]:= - 30 + Random(71);

end;

writeln; writeln('Массив А');

for i:=1 to dim do

write(a[i]:3,' ');

writeln;

s:= 0;

for i:= 1 to dim do

s:= s + a[i];

writeln('Сумма элементов массива = ',S);

a_max:= a[1];

for i:= 1 to 100 do

if a[i] > a_max

then

begin a_max:= a[i];

j:= i

end;

writeln('Наибольший элемент массива a[',j,']= ',a_max);

j:= 0; k:= 0;

for i:=1 to dim do

if a[i] >= 0

then begin j:= j+1;

b[j]:= a[i]

end

else begin k:= k+1;

c[k]:= a[i]

end;

writeln('Cоздание новых массивов с элементами: b[j] >=0, c[k] <0');

writeln('Массив b:');

if j>0

then for i:=1 to j do write(b[i]:3,' ')

else

writeln('массив не содержит элементов');

writeln; writeln(('Массив c:');

if k>0

then for i:=1 to k do write(c[i]:3,' ')

else writeln(Rus('массив не содержит элементов'));

writeln; readln

end.

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

var a : array[1..10] of array[1..20] of single;

или так:

var a : array[1..10, 1..20] of single;

При обращении к ячейкам массиваможно использовать в программе запись вида a[i][j]илиa[i,j].

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

const Nmax=100;

type IndexType = 1..Nmax;

Mas = array [IndexType] of integer;

Mas_d = array [IndexType,IndexType] of integer;

var a,c : Mas_d;

ss,b : Mas;

N,m,a1,i,j,dim,l : Integer;

begin

repeat

writeln('Введите размерность массива от 1 до ',Nmax-1);

readln(dim)

until (dim>=1) and (dim<Nmax);

repeat

writeln('Заполнить массив вручную (1) или случ образом (2)?);

readln(N)

until (N<>1) or (N<>2);

if N=1

then for i:= 1 to dim do

for j:=1 to dim do

begin write(' Введите A[ ' , i , ',',j,' ] = ' );

readln(a[i,j])

end

else

begin randomize;

for i:= 1 to dim do

for j:=1 to dim do

a[i,j]:= - 30 + Random(71);

end;

writeln;

writeln('Массив А');

for i:=1 to dim do

begin for j:=1 to dim do

write(a[i,j]:3,' ');

writeln;

end;

for i:= 1 to dim do

begin SS[i]:= 0;

for j:= 1 to dim do

SS[i]:= SS[i] + A[i, j] ;

writeln('Сумма элементов ',i,' строки = ',SS[i]);

end;

readln;

writeln('Обмен местами первой и последней строки');

for j:= 1 to dim do

begin a1:=a[1,j];

a[1,j]:=a[dim,j];

a[dim,j]:=a1

end;

writeln('Измененный массив А');

for i:=1 to dim do

begin for j:=1 to dim do

write(a[i,j]:3,' ');

writeln;

end;

readln;

repeat writeln('Введите номер столбца (от 1 до ',dim,')');

readln(M)

until (m>=1) and (m<=dim);

writeln('Вставка данных из одномерного массива B в столбец с

номером ', M,' массива А'); writeln('Массив B');

for i:= 1 to dim do

begin b[i]:= - 30 + Random(71);

write(b[i]:3,' ');

end;

for i:= 1 to dim do

begin for j:=dim+1 downto M+1 do

A[i,j]:=A[i,j-1];

A[i,M]:=B[i]

end;

writeln('Массив А');

for i:=1 to dim do

begin for j:=1 to dim+1 do

write(a[i,j]:3,' ');

writeln;

end;

writeln('Создание массива C из четных столбцов массива A');

for j:= 1 to dim do

if (j Mod 2) = 0

then for i:= 1 to dim do

C[i,j Div 2]:= A[i,j];

writeln('Массив C'));

l:=dim div 2;

for i:=1 to dim do

begin for j:=1 to l do

write(c[i,j]:3,' ');

writeln;

end;

readln;

end.

Каким именно образом сгруппировать значения элементов, легко понять, вспомнив, что массив ARRAY[1..3,1..2] OF Singleесть на самом деле компактная запись описания ARRAY[1..3] OF ARRAY[1..2] OF Single.

 

14. Защита от ошибок и отладка программ. Стандартная техника отладки

 

В программах принято выделять три вида ошибок. Ошибки времени выполнения (Run­time errors), как следует из названия, происходят во время выполнения программы. Во время разработки программы могут возникать синтаксические ошибкии логические ошибки.Под синтаксисом подразумевается структура кода - написание имен и ключевых слов, правила грамматики, пунктуация и т.д. Приведенные ниже фрагменты кода содержат синтаксические ошибки. Сможете ли вы обнаружить их?

if x>y then m:=x; else m:=y;

var perem_x,perem_y,rez:integer; begin perem_x:=1; perm_y:=2; rez:= perem_x+ perem_y;

Обнаружение таких ошибок не всегда очевидно, особенно для начинающих программистов. В первом примере перед else стоит “;” и Delphi автоматически обнаружит ошибку. Появится сообщение: ';' not allowed before 'ELSE'. Во втором примере в операторе присваивания неправильно введено имя perm_y (вместо perem_y) и сообщение об ошибке будет следующим: Undeclared identifier: 'perm_y'.

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

var x:single;

begin

x:=10.0;

repeat

writeln(x);

x:=x-3.0/4.0;

until x=0.0;

Дело в том, что переменная х никогда не будет равна 0, и поэтому цикл будет бесконечным. Чтобы прекратить выполнение зациклившейся программы, выберите в главном меню Delphi команду Run Program Reset или воспользуйтесь комбинацией клавиш <Ctrl+F2> при активном окне выполнения программы. А для исправления ошибки нужно заменить предложение until следующим: until x <= 0;

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

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

Как же должен поступать программист, когда при выполнении его программы возникают ошибки? Прежде всего, нужно локализовать ошибку, то есть найти оператор, в котором она произошла. В этом вам может помочь среда Delphi, если в ней правильно установлены опции компилятора. Опции компилятора позволяют изменять режим компиляции (выберите в главном меню Delphi команду Project Options Compiler). Пока нас будут интересовать лишь следующие опции: Range checking, I/O checking, Overflow checking, Debug information. Если они включены, то настройка среды благоприятна для отладки вашей программы. Если они выключены, то их следует включить, а также можно вставить в любом месте исходного кода, где допустима вставка комментариев. Опции записываются в программе в виде: {$буква +/ - }.Каждой опции соответствует своя буква (это заглавные буквы в названии каждой опции), символ "+" означает включить, а символ "-" - выключить. В программе можно задать одну опцию, например, {$O+}или несколько опций -{$R+,I-}. Некоторые опции можно записывать только в самом начале кода программы, другие могут размещаться в любом ее месте.

Опция Range checking(R) отвечает за контроль ошибок Range check error (ошибка проверки диапазона). Они возникают, например, при попытке присвоить целочисленной переменной недопустимое значение, или при использовании недопустимого индексного выражения для элемента любого массива.

Опция Overflow checking(C) отвечает за контроль ошибок Ariphmetic overflow (целочисленное переполнение), возникающих при выполнении арифметической операции над целыми числами, когда результат операции выходит за границы соответствующего типа.

Опция I/O cheking(I) отвечает за контроль ошибок ввода-вывода.

Опция Debug information(D) включает в код программы отладочную информацию, что позволяет среде при аварийном завершении программы показать курсором оператор, в котором произошла ошибка.

Стандартными приемами отладки являются дамп данных (выгрузка, вывод дан­ных на экран), ручное выполнение кода и использование встроенного отладчика Delphi.

Наиболее простой прием отладки — дамп данных. Если программа не работает как ожидается, программист может добавить строки кода, выводящие промежуточные зна­чения выбранных переменных. Такой вывод значений пе­ременных называется дампом данных. Отслеживая изменение переменных, программист может обнаружить неполадку в исходном коде. Вспомним последний при­мер логической ошибки. Фрагмент кода этого примера фактически выполняет дамп данных: значения переменной х выводятся на экран на каждой итерации цикла repeat. Это позволяет сразу увидеть, что переменная х уменьшается бесконечно.

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

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

var x:single;

begin

x:=5;

repeat

x:=x-2;

writeln(x:5:2);

until x=0;

Номер итерации	х	Выводимое значение
		пусто
	-1	-1

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

Среда разработки Delphi содержит встроенный отладчик, значительно облегчающий программисту отслеживание кода и обнаружение ошибок. Чтобы отладчик Delphi можно было использовать, нужно убедиться, что режим интегрированной отладки включен. Для этого в главном меню выберите команду Tools Debugger Options (Инструменты Режимы от­ладчика) и на закладке General (Общие) убедитесь, что установлен флажок Integrating debugging (Интегрированная отладка) в левой нижней части диалогового окна.

Команды отладчика доступны из меню Run

Рис. 4

и на панели инструментов отладки Debug (рис. 5).

Рис. 5

Для активизации панели Debug щелкните правой кнопкой мыши на главном меню или на любой видимой панели инструментов (при этом всплывает контек­стное меню Toolbar) и выберите Debug. На рис. 4 показаны пиктограммы, которые на­ходятся на панели инструментов отладки по умолчанию. Кроме того, быстро получить доступ к командам отладчика можно из окна редактора кода. Щелкните правой кнопкой мыши в любом месте окна редактора кода, при этом всплывет контекстное меню, в пунк­те Debug которого перечислены все доступные команды отладчика.

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

Приведем короткое описание точек прерывания (breakpoint), пошагового выполнения (step) и окон наблюдения (watch). Точки прерывания выполнения исходного кода устанавливаются программистом слева от строки кода, перед которой нужно остановить выполнение. Их можно устанавливать только на выполнимых строках кода (нельзя на пустых строках, операторах объявления и комментариях). Когда при выполнении исходного кода встречается точка прерывания, программа временно останавливается, пока программист не выберет команду Run меню Run или не щелкнет на кнопке Run панели отладки.

Когда программа остановлена, программист может просмотреть и/или изменить значения выражений в окне Evaluate/Modify (Оценить/ Изменить).

В процессе интерактивной отладки значения переменных и выражений можно просматривать также с помощью всплывающего окна указателя (tooltip). Для этого нужно всего лишь поместить указатель мыши на переменную или выражение в ре­дакторе кода и через одну секунду (по умолчанию) Delphi выведет во всплывшем окне значение этой переменной или выражения.

Для включения режима вывода всплывающего окна указателя выберите в главном меню команду Tools Editor Options... (Инструменты Параметры редактора...), от­кроется окно Editor Options. Затем во вкладке Code Insight (Подсказка кода) устано­вите флажок Tooltip expression evaluation (Оценивание и вывод выражений во всплы­вающее окно). Обратите внимание: при этом должен быть установлен режим Inte­grated Debugging (Интегрированная отладка).

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

Наблюдаемое выражение (watch expression)— это определенное программистом выра­жение (оно может не входить в исходный код), значение которого программист может наблюдать во время выполнения программы. Значения наблюдаемых выражений видны в окне наблюдения (Watch window),в режиме прерываний они автоматически обновляют­ся. Кроме того, в окне локальных переменных (Local variable window)автоматически выво­дятся значения всех объявленных локальных переменных текущей подпрограммы.

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

1. Числа Фибоначчи определяются как последовательность значений , где , . Приведенная ниже подпрограмма выводит числа Фибонач­чи, значение которых меньше или равно 30 000, и квадраты каждого из этих чисел:

{Это функция, вычисляющая квадрат целого числа}

function Square(value: Integer): Integer;

begin

Square := value * value;

end;{ Square }

{Вывод чисел Фибоначчи, значения которых меньше, или равны 30000}

var num1,num2,sum: Integer;

begin

num1 := 1;

num2 := 1;

writeln(Rus('Число Фибоначчи Квадрат числа'));

writeln(num1 :10, Square(num1) :15);

repeat

writeln(num2 :10, Square(num2) :15);

sum := num1 + num2;

num1 := num2;

num2 := sum;

until (num2 > 30000);

readln

end.

2. Поставьте точку прерывания на первую строку тела цикла repeat. Для этого по­местите на этой строке курсор мыши, щелкните правой кнопкой и во всплывшем меню выберите команду Debug Toggle Breakpoint (Отладка Переключение точки прерывания). Другой способ сделать это — установить на строку указатель мыши и нажать клавишу <F5>, которая переключает точку прерывания (чтобы увидеть, как она переключается, нажмите <F5> несколько раз). Обратите внимание: редак­тор кода выделяет строку и располагает слева от нее красный кружочек, как пока­зано на рис. 6. Еще один способ установки точки прерывания — щелкнуть левой кнопкой мыши на серой полосе слева от строк кода (там, где устанавливается красный кружочек).

Рис.6

3. Выполните программу. Как видите, отладчик Delphi остановил выполнение программы в точке прерывания и вывел окно редак­тора кода (рис. 7). В окне редактора отмечена следующая строка, которая пока не выполнена, при этом на левой серой полосе появилась зеленая стрелка - указатель инструкций (instruction pointer).

Рис.7

4. Выполняйте строки кода путем последовательных щелчков на кнопке Trace Into (Отследить в) или нажатий клавиши <F7>. Обратите внимание: указатель инст­рукции попадает внутрь подпрограммы Square (). Сделав еще два щелчка, верни­тесь в основную программу.

5. Установите наблюдение за переменными numl и value. Для этого выберите ко­манду Run Add Watch... (Выполнить Добавить наблюдение) или нажмите клави­ши <Ctrl+F5>. Появится окно Watch Properties (Свойства наблюдения), показан­ное на рис. 8.

Рис.8

В области Expression (Выражение) введите num2 и нажмите клави­шу <Enter>. Сделайте то же самое для переменной value. Еще один способ быст­рой установки наблюдения за выражением - щелкнуть в редакторе кода правой кнопкой мыши на нужном выражении и во всплывшем меню выбрать команду Debug Add Watch at Cursor (Отладка Установка наблюдения в точке указателя мыши).

6. Чтобы отследить работу программы, несколько раз нажмите клавишу <F7>. Обратите внимание: в процессе пошагового выполнения значения в окне наблюдений изме­няются. Продолжая нажимать клавишу <F7>, дождитесь момента, когда указатель инструкций по­падет в точку прерывания.

7. Чтобы перешагнуть через вызов функции Square (), нажмите клавишу <F8>. Об­ратите внимание: указатель инструкций не вошел в функцию Square (), а пере­местился в следующую строку кода текущей подпрограммы.

8. Удалите все наблюдения за значениями переменных. Для этого щелкните правой кнопкой мыши на окне на­блюдений и во всплывшем меню выберите команду Delete All Watches (Удалить все наблюдения). Закройте окно наблюдений Watch List.

9. В редакторе коде щелкните на строке с точкой прерывания. Нажав клавишу <F5>, отключите точку прерывания.

10. Нажав клавишу <F9>, возобновите выполнение программы. Затем закройте окно с результатами выполнения программы.

 

15. Процедуры и функции. Сфера действия описаний

 

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

Процедуры и функции, определяемые программистом, приводятся в разделе описания основной программы. Процедуры и функции имеют заголовок, раздел описания и раздел операторов. Раздел операторов начинается с BEGINи заканчивается END;(но не END.). Единственным новым оператором для нас будет оператор заголовка, с которого начинается всякая процедура и функция. Заголовок процедуры состоит из служебного слова Procedure, имени процедуры и списка параметров

PROCEDUREимя (список параметров ) ;

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

[VAR] имя ,... имя :тип ;........................... ; [VAR] имя ,... имя :тип

Здесь имя - имена параметров, каждый параметр может использоваться внутри процедуры как обычная переменная соответствующего типа. Тип - имя типа, но не описание пользовательского типа; скажем, описание параметра в виде x:1..5неверно, но, если выше описан соответствующий тип: TYPE MyType=1..5, то параметр можно описать в виде x:MyType. Ключевое слово VARперед описанием параметров означает в данном случае, что все параметры до ";" или до ")" - параметры-переменные; если же VARотсутствует, то параметры являются параметрами-значениями. Смысл этих понятий мы рассмотрим чуть позже.

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

имя (список аргументов );

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

procedure outvar(x:single; name:char);

begin

writeln(Rus('переменная '),name,Rus(' равна '),x:10:4);

end; {outvar}

var a,b,c,d : single;

begin

writeln(Rus('Введите переменные a,b,c,d '));

readln(a,b,c,d);

outvar(a,'a'); outvar(b,'b');

outvar(c,'c'); outvar(d,'d');

readln

end.

Наша процедура OutVar получает из главной процедуры вещественное число хи символ Name, но ничего не передает обратно. Теперь попробуем написать процедуру, которая по заданным значениям x и y вычисляет cos(x)+cos(y) и cos(x)-cos(y) :

procedure t(x,y:single; cplus,cminus:single);

begin cplus:=cos(x)+cos(y);

cminus:=cos(x)-cos(y);

end; {t}

var p,m:single;

begin

t(1.235,0.645,p,m);

writeln(p:7:3,m:7:3);

readln

end.

Запустим эту программу и - вместо правильного результата 1.129,-0.470 -получим в лучшем случае нули. Дело в том, что через параметры-значения (а Cplusи Cminusописаны в нашей процедуре как параметры-значения!) невозможно передать информацию из процедуры, но лишь в процедуру. Чтобы правильно решить нашу задачу, следует Cplusи Cminusописать в заголовке как параметры-переменные:

procedure t(x,y:single;var cplus,cminus:single);

begin cplus:=cos(x)+cos(y);

cminus:=cos(x)-cos(y);

end; {t}

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

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

FUNCTIONимя (список параметров ) :тип ;

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

function Na3(x:LongInt):Boolean;

begin

Na3:=x MOD 3=0;

end; {Na3}

var L:LongInt;

begin write(Rus('Введите целое число '));

read(L);

write(Rus('Число '),L);

if not Na3(L)

then write(Rus(' не'));

writeln(Rus(' делится на 3 !'));

readln; readln;

end.

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

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

function factorial(n:byte):single;

begin if n<=1 then factorial:=1

else factorial:=n*factorial(n-1);

end;

Теперь запишем этот алгоритм по-другому:

function factorial(n:byte):single;

var i:byte; f:single;

begin f:=1; for i:=2 to n do f:=f*i; factorial:=f;

end;

Но обратите внимание: в этих примерах предполагается, что число, для которого будет найдено значение факториала, не превосходит 255, а результат не будет превышать 3.4Е+38. Если мы попытаемся найти значение факториала для 34, то после выполнения соответствующей программы получим 2.952328Е+0038. Но вот попытка поиска значения факториала для 35 не завершится успехом. А если определить тип результата функции factorial как integer, то значения аргумента, для которых можно получить значение функции, соответствующее действительности, еще меньше. Подумайте, в чем здесь ошибка и как ее можно исправить.

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

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

	Таблица 5
Место объявления идентификатора	Область видимости
Объявление в подпрограмме	От точки объявления до конца текущей подпрограммы, включая все внутренние подпрограммы
Объявление в программе	От точки объявления до конца текущей программы, включая все внутренние подпрограммы

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

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

var counter: Integer;

 

procedure DisplayCounter;

begin

writeln (counter);

end; {DisplayCounter}

 

procedure SetTo1;

var

counter: Integer;

begin

counter := 1;

write (Rus('В процедуре'), ' counter=');

DisplayCounter;

end; {SetTo1}

 

begin

counter := 0; SetTo1;

ReadLn;

end.

Как вы думаете, что пользователь увидит в результате работы этой программы? Сообщение будет следующим: “В процедуре counter=0”. Попробуем разобраться, почему это так. Сначала переменная counter получает значение 0. Затем происходит обращение к процедуре SetTo1, в которой объявлена локальная переменная с таким же именем counter, область ее видимости – до конца процедуры SetTo1. В процедуре локальная переменная counter получает значение 1. Выполняется вывод сообщения и далее происходит обращение к процедуре DisplayCounter, которая выведет значение глобальной переменной counter, т.е. 0, так как процедура DisplayCounter является независимой по отношению к процедуре SetTo1.

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

Для чего нужны процедуры и функции, когда и как их следует применять? Многие начинающие программисты избегают процедур и функций, утверждая, что "без них проще". На самом деле обойтись без функций и процедур легко только в самых тривиальных программах. Сколько-нибудь сложная программа, записанная "одним куском", требует при отладке от программиста огромных усилий, которые зачастую все равно пропадают даром. Обязательно используйте в своих программах процедуры и функции! Хорошая программа должна содержать главным образом обращения к процедурам и функциям. Конечно, не существует никаких жестких правил, определяющих, когда использовать функции, а когда нет, но авторы могут предложить несколько нестрогих, но полезных рецептов:

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

- не смешивайте в одной процедуре (функции) ввод-вывод данных и вычислительные алгоритмы;

- называйте свои процедуры (функции) мнемоническими именами;

- если алгоритм, который вы решили выделить в процедуру (функцию), все еще слишком сложен, оформите фрагмент этого алгоритма в другой процедуре (функции);

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

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

 

16. Множества

 

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

SET OFтип ,

где тип - базовый для этого множества тип, т.е. тип элементов множества. Базовый тип должен быть порядковым типом мощностью не более 256 (т.е. допускающий не более 256 различных значений), причем порядковые номера (вспомним функцию ORD) наименьшего и наибольшего значений должны лежать на отрезке [0,255]. Таким образом, базовым типом для множества могут быть: типы Char, Boolean, Byteи все производные от Byteинтервальные типы. Размер объекта типа “множество” можно определить по формуле: размер = (мощность-1) DIV8 + 1, т.е. множества - довольно компактные объекты, самое большое множество имеет размер 32 байта. Неименованные константы типа множество записываются в виде:

[подмножество,подмножество,... ],

где подмножество - это либо отдельное значение, либо диапазон. Диапазон записывается как начальное значение ..конечное значение. Любое из значений может быть как константой, так и выражением соответствующего типа. Запишем, например, константу-множество, содержащую числа 0, 1, 2, 3, 4, 8, 12, 13, 14, 15, 16, 22:

[0,1,2,3,4,6,12,13,14,15,16,22]

или

[0..4,6,12..16,22]

или

[0..2,3..4,6..6,12,13..16,22]

или

[22,13..15,1..6,0,12,16]

Все эти константы полностью эквивалентны, порядок записи элементов совершенно произволен. Допускаются пустые множества, они записываются так: [ ]. Опишем несколько переменных и типизированных констант: type myset = set of 0..111;

var a : set of char;b : myset;

const c : myset = [];

d : set of char = ['a'..'z']; e : set of boolean = [false];

К множествам применимы следующие операции:

- множеству можно присвоить множество того же типа;

- операция объединение +

- операция дополнение -

- операция пересечение *

- операция эквивалентность =

- операция не эквивалентность <>

- операция включение <=и >=

Последние три операции дают значения логического типа - TRUEили FALSE. Пусть множество A=[1..20], B=[2..9,15..20], C=[3..22], тогда A+B=[1..20], A+C=[1..22], A-C=[1,2], C-A=[21,22], A*B=[1..20], A*C= [3..20], B*C=[3..9,15..20], A=B=FALSE, A<>C=FALSE, B<=A=TRUE, A>=C=FALSE.

Существует еще одна операция, связанная с множествами, - операция IN, она применяется к скалярной величине и множеству:

выражение INмножество

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

Для множеств определены две стандартные процедуры:

Include( множество , выражение );

Exclude( множество , выражение );

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

Теперь, когда мы знаем все возможности множеств, запишем программу, находящую все простые числа на отрезке [1,255]. Используем алгоритм под названием "решето Эратосфена": выпишем подряд все целые числа от 2 до 255 . Первое простое число 2; подчеркнем его, а все числа, кратные 2, зачеркнем. Следующее из оставшихся незачеркнутых чисел 3.. Подчеркнем его как простое, а все большие числа, кратные 3, зачеркнем. Первое число из оставшихся теперь 5, так как 4 уже зачеркнуто. Подчеркнем его как простое, а все большие числа, кратные 5, зачеркнем и т.д.:

type NumSet = set of 1..255;

var

N : NumSet;

MaxDim,d,k: longint;

begin

MaxDim:=255;