[ Миронченко ] Императивное и объектно-ориентированное програмирование на Turbo Pascal и Delphi

161

24:

25: implementation 26:

27:function Grosser(const Rat1,Rat2:Bruch):boolean;

28:begin {(a/b) > (c/d) <=> a*d>b*c }

29:Grosser:=Rat1.Zahler*Rat2.Nenner>Rat2.Zahler*Rat1.Nenner;

30:end;

31:

32:procedure Kurzung(var Rat:Bruch);{сокращение дроби}

33:var

34:c:longint;

35:begin

36:c:=GGT(Rat.Zahler,Rat.Nenner);

37:Rat.Zahler:=Rat.Zahler div c;

38:Rat.Nenner:=Rat.Nenner div c;

39:end;

40:

41:procedure PrufRat(var Rat:Bruch);

42:{проверяет введенное число на правильность:

43:если Nenner=0, то присваивает дроби значение 1,

44:и печатает об этом пользователю}

45:

46:begin

47:if Rat.Nenner = 0 then

48:begin

49:writeln('Знаменатель дроби = 0');

50:Rat.Nenner:=1;

51:Rat.Zahler:=1;

52:writeln('Значение дроби будет установлено равным 1');

53:end;

54:end;

55:

56:procedure LeseBruch(var Rat:Bruch);

57:begin

58:readln(Rat.Zahler); {вводим числитель дроби Rat}

59:readln(Rat.Nenner);{вводим знаменатель дроби Rat}

60:PrufRat(Rat);{проверяем, не равен ли знаменатель 0}

61:Kurzung(Rat);{сокращение дроби}

62:end;

63:

64:procedure SchrBruch(var Rat:Bruch);

65:begin

66:if Rat.Nenner=1 then {a/1 = a => write(a)}

67:begin

68:writeln(Rat.Zahler);

69:exit;

70:end;

71:if Rat.Zahler=0 then {0/d = 0 => write(0)}

72:begin

73:writeln(0);

74:exit;

75:end;

163

2 : Student=record

3 : {фиксированная часть}

4 : name:string;

5 : {вариантная часть}

6 : case n:byte of

7 : 1:(Analysis1,Algebra,Diskrmath:byte);

8 : 2:(Progr,Analysis2,Geom,Geschichte:shortint);

9 : end;

10:var

11:s:student;

12:begin

13:s.Analysis1:=5;

14:s.Algebra:=5;

15:s.Progr:=4; {Теперь и s.Analysis1=4}

16:writeln(s.Analysis1,' ',s.Progr,' ',s.Algebra);

17:readln;

18:end.

Описание типа запись в общем случае состоит из двух частей: фиксированной и вариантной. До этого мы имели дело лишь с фиксированной частью. Вариантная часть начинается конструкцией, внешне сходной на оператор выбора case, но это сходство лишь внешнее. Смысл вариантной части таков: одно и то же место в памяти ПК резервируется под 2 набора переменных. В примере длина максимального набора = 4 байта, минимального = 3 байта. Это означает, что под вариантную часть резервируется 4 байта (и еще 1 байт для селектора – переменной n). причем к первым 3-м байтам из 4- х можно обращаться под двумя именами (например, к первому байту – с помощью имени Analysis1 или имени Progr). Разумеется, т.к. оба набора хранятся в одной области памяти, то изменяя значения переменных в одном наборе вы автоматически измените и значения в другом наборе.

В данном примере на экран будет выведено: 4, 4, 5.

Задачи

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

2.Пополните модуль работы с рациональными числами следующими подпрограммами:

•Проверка правильности ввода дроби (не равен ли знаменатель нулю).

•Деление двух дробей

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

•Смена знака (при работе с дробями может случиться, что в знаменателе окажется отрицательное число, а у нас по определению в знаменателе должно стоять натуральное число).

•Сравнение дробей (<, =, <>).

164

3.(!) Напишите модуль, содержащий подпрограммы для работы с комплексными числами:

•Ввод, вывод, сравнение с нулем, вычисление модуля комплексного числа

•Перевод в тригонометрическую и показательную формы

•Сложение, вычитание, умножение, деление, возведение в степень.

•Решение квадратного уравнения с комплексными коэффициентами над множеством комплексных чисел.

4.Реализовать модуль для работы с многочленами на основе массивов

•Сложение

•Вычитание

•Умножение

•Деление

•Возведение в степень (оптимальный алгоритм – см. задачу 5 в главе «Рекурсия»)

165

Глава 10: Матрицы, множества и перечисления

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

10.1. Матрицы

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

• Матрица – двумерный массив.

Описывается прямоугольная целочисленная матрица размера n*m так:

type

Matrix=array [1..n,1..m] of integer;

Рис 10.1. Структура матрицы А типа Matrix

При этом в матрице будет n столбцов и m строк (см. рисунок). Матрицу можно описать иначе (как массив массивов):

type

Matrix2=array [1..n] of array[1..m] of integer;

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

Диапазоны изменения элементов могут быть другие. Например:

type

Mat=array[‘a’..’r’,-3..14] of real;

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

Матрицы одного типа можно присваивать друг другу.

Обратиться к элементу матрицы можно, указав оба его индекса:

А[3,4]:=6

166

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

Рис 10.2. Так хранится матрица в памяти

Пример 1: Процедуры для ввода, вывода и заполнения матриц числами в

определенном порядке.

1 : const

2 : n=3; {количество строк матрицы}

3 : m=2; {количество столбцов матрицы}

4 : type

5 : {Объявление вещественной матрицы размера n*m}

6 : Matrix=array[1..n,1..m] of real;

7 : var

8 : A:Matrix;

9 :

10:{Ввод прямоугольной вещественной матрицы}

11:procedure LeseMatr(var A:Matrix);

12:var

13:i,j:integer;

14:begin

15:for i:=1 to n do {проход по строчкам матрицы}

16:for j:=1 to m do {проход по столбцам матрицы}

17:read(A[i,j]);

18:end;

19:

20:{Вывод прямоугольной вещественной матрицы на экран}

21:procedure SchrMatr(const A:Matrix);

22:var

23:i,j:integer;

24:begin

25:for i:=1 to n do

26:begin

27:writeln;{Переход на новую строку}

28:for j:=1 to m do

29:write(A[i,j]:9:4);

30:end;

31:end;

32:

33:procedure EinfFulleMatr(var A:Matrix);

34:var

35:i,j:integer;

36:begin

167

37:for i:=1 to n do

38:for j:=1 to m do

39:A[i,j]:=i; {Заполняем всю i-ю строку числом i}

40:end;

41:

42:BEGIN

43:writeln('Введите матрицу A размера ',n,' на ',m);

44:LeseMatr(A);

45:writeln('Матрица имеет такой вид A');

46:SchrMatr(A);

47:writeln;

48:

49:writeln('Матрица, у которой элементы i-й строки =i');

50:EinfFulleMatr(A);

51:SchrMatr(A);

52:readln;

53:end.

Вы видите, что принцип заполнения матриц прост: во внешнем цикле изменяется первый индекс (строчный), а во вложенный цикл пробегает по всей i-й строке от начала до конца. Выходит, что сначала заполняется вся первая строка (i=1), затем 2-я, и т.д.

10.2. Обобщение процедур работы с матрицами

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

А: array of array of integer

нельзя, т.к. array of integer – не тип данных.

Значит, надо использовать бестиповые ссылки.

Пример 2: Использование бестиповых ссылок.

1 : unit b2MatrU;

2 :

3 : interface

4 :

5 : type

6 : GrosseMatr=array[1..100,1..100] of integer;

7 :

8 : procedure LeseMatr(var A;n,m:integer);

9 : procedure SchrMatr(var A;n,m:integer); 10:

11: implementation 12:

13:procedure LeseMatr(var A;n,m:integer);

14:var

15:i,j:integer;

16:begin

17:for i:=1 to n do

168

18:for j:=1 to m do

19:read(GrosseMatr(A)[i][j]);

20:end;

21:

22:procedure SchrMatr(var A;n,m:integer);

23:var

24:i,j:integer;

25:begin

26:for i:=1 to n do

27:begin

28:for j:=1 to m do

29:write(GrosseMatr(A)[i][j],' ');

30:writeln;

31:end;

32:end;

33:

34: end.

А вот и файл, в котором этот модуль используется:

1 : uses b2MatrU;

2 : const

3 : n=3; {количество строк матрицы}

4 : m=2; {количество столбцов матрицы}

5 : type

6 : {Объявление вещественной матрицы размера n*m}

7 : Matrix=array[1..n,1..m] of real;

8 : var

9 : A:Matrix; 10:

11:begin

12:writeln('Введите матрицу A размера ',n,' на ',m);

13:LeseMatr(A,n,m);

14:writeln('Матрица имеет такой вид A');

15:SchrMatr(A,n,m);

16:writeln;

17:end.

Для тех, кто уже подзабыл принцип работы с бестиповыми ссылками, напомню, что после передачи бестиповой ссылки в качестве параметра, мы должны привести эту ссылку к какому-то типу. В данном случае – к типу GrosseMatr (строки 19, 29). Он объявлен как квадратная матрица, но ясно, что все процедуры модуля будут отлично работать для любой подматрицы для матрицы 100*100 элементов. Вам все понятно? – Тогда попытайтесь распечатать матрицу А обычным способом, т.е. вставьте в основную программу вместо SchrMat(A,n,m) небольшой фрагмент:

for i:=1 to n do begin

for j:=1 to m do write(A[i,j],' ');

writeln;

end;

169

Вы не поверите своим глазам: правильно заполненной оказалась лишь 1-я строка, хотя, казалось бы, мы все делали правильно. Все дело вот в чем: вспомните, как хранится матрица размера 3 2 в памяти:

А матрица размеров 100 100 хранится так:

В процедуре InputMatr мы заполняем элементы A[1,1], A[1,2], A[2,1], …, A[3,2],

интерпретируя матрицу А как матрицу типа MegaMatr. Но ведь на самом деле А – матрица размера 3 2 , поэтому для нее элемент, например, А[2,1] находится в памяти на совсем другом месте, чем элемент A[2,1], если матрица А – матрица размера

100 100 .

Если вы напишете в основном блоке writeln(A[51,1]), то тогда вы увидите тот элемент, который вы ввели как элемент А[2,1] внутри процедуры InputMatr.

Уфф, какой я обманщик!!!

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

Пример 3: Настоящее обобщение.

1 : unit MatrArrU;

2 :

3 : interface

4 :

5 : type

6 : GrosseMass=array[1..MaxInt] of integer;

7 :

8 : procedure LeseMass(var A;n,m:integer);

9 : procedure SchrMass(var A;n,m:integer);

10: procedure RandFulle(var A;n,m,numb:integer); 11:

12: implementation 13:

14:procedure LeseMass(var A;n,m:integer);

15:var

16:i,j:integer;

17:begin

18:for i:=1 to n do

19:for j:=1 to m do

20:read(GrosseMass(A)[m*(i-1)+j]);

21:end;

22:

23:procedure SchrMass(var A;n,m:integer);

24:var

25:i,j:integer;

26:begin

170

27:for i:=1 to n do

28:begin

29:for j:=1 to m do

30:write(GrosseMass(A)[m*(i-1)+j],' ');

31:writeln;

32:end;

33:end;

34:

35:procedure RandFulle(var A;n,m,numb:integer);

36:var

37:i,j:integer;

38:begin

39:for i:=1 to n do

40:begin

41:for j:=1 to m do

42:GrosseMass(A)[m*(i-1)+j]:=random(numb);

43:writeln;

44:end;

45:end;

46:

47: end.

Мы представили основной тип не как матрицу, а как массив, - т.е. естественный (для ПК!) способ хранения матрицы в памяти. Элемент A[i,j] матрицы размера n m хранится в (m*(i-1)+j)-м байте от начала массива (это следует из способа хранения матрицы). Таким образом мы заполняем именно те байты, в которых хранится матрица А, которую мы передали в процедуру InputMass.

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

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

10.3.Матрицы в математике

•Матрицей размера n m называется прямоугольная таблица чисел из n строк и m столбцов. При этом элементами матрицы могут быть числа любого множества.

У элементов aij : i - номер строки, а j – номер столбца, в котором находится элемент.

•Порядком квадратной матрицы называется количество ее столбцов (строк).

•Главной диагональю квадратной матрицы называется диагональ, идущая из левого верхнего в правый нижний угол.