1 2
1 3
2 1
2 2
2 3
2. var a, b:integer;
begin
for i:= 1 to 2 do
begin
for j:= 1 to 3 do writeln(i, ‘ ’, j); {выполнится 6 раз}
writeln(‘******’);
end;
end.
На экране увидим:
1 1
1 2
1 3
******
2 1
2 2
2 3
Правило выполнения:
на каждом шаге внешнего цикла полностью выполняются все шаги внутреннего цикла.
Пример 1: Программа вычисления и вывода на экран таблицы умножения (Пифагора).
var i, j: integer;
begin
for i:=1 to 9 do
begin
for j:=1 to 9 do
write(i*j:4);
writeln;
end;
end.
Пример 2: Программа вычисления значений функции f(x, y)=sin(x)*cos(y), где х=0..π с шагом π/5 и у=0..1 с шагом 0,1.
var x, y,f: real;
begin
x:=0;
repeat
y:=0;
while y<=1 do
begin
f:=sin(x)*cos(y);
write(f:6:3);
y:=y+0,1;
end;
x:=x+pi/5;
writeln;
until x>pi;
end.
3.9 Оператор перехода GOTO
Оператор перехода позволяет изменить обычный последовательный порядок выполнения операторов в программе. Он вызывает переход к выполнению оператора, которому предшествует метка.
Структура оператора:
GOTO <метка>;
…
…
< метка >: <оператор>;
Метка – это число от 0 до 9999, или идентификатор. Метки, используемые в программе, должны быть описаны:
LABEL 1, 2, Met;
Нельзя использовать оператор GOTO для перехода в подпрограммы, а также внутрь операторов цикла, условного и составного операторов.
Использование оператора перехода в Паскаль считается избыточным, поэтому следует избегать его использования в программах. В крайнем случае можно применять GOTO для перехода вниз по тексту программы (вперед) .
Пример: Частное от деления целых чисел.
Label M1;
var x, y,res: integer;
begin
write(‘Введите x, y’);
readln(x, y);
if y=0 then
begin
writeln(‘Деление на ноль!’);
goto M1;
end;
res:=x div y;
writeln(‘Частное = ’, res);
M1: writeln(‘Конец программы’);
end.
Задачи для самоконтроля
3.1 Определить, какие значения x, y, z будут напечатаны после выполнения программы.
var x, y,z: real;
begin
x:=-2; y:=3; z:=3.5;
z:=x-2.5;
y:=x-y+2*z;
x:=x+y-2*z;
x:=y-2*x;
y:=x+2*y+z;
z:=(x+y)*2;
writeln(‘x=’,x,’ y=’,y,’ z=’,z);
end.
3.2
а) Определить значение переменной x после работы следующего фрагмента программы:
a = 8; b = 3 * a – 4; x = 0; y = 2 * b;
if ( 2 * a > b ) or (4 * a < y ) then begin x = 7; y = –15 end;
if ( x > 0 ) and ( 2 * a + b < y ) then begin x = 5; y = –7 end;
б) Определить значение переменной x после работы следующего фрагмента программы:
a = –3; b = –4 * a –2; x = 1; y = b/2 – 1;
if ( 5 * a > b ) or ( y > a ) then begin x = x + 2; y = x – 3 end;
if ( 2 * a + 8 > y ) and ( y < x ) then begin x = y + 5; y = 6 end;
3.3 Определить значение переменной x после работы следующих фрагментов программы:
а) x:=5;
for i:=2 to 4 do x:= x – 2;
б) x:=4; y:=2;
While y<= 4 do begin
x:=x - 2;
y:=y+1;
end;
в) x:=4; y:=2;
Repeat
x:=x - 2;
y:=y+1;
until y>=4 ;
4. Массивы
Массивы относятся к структурированным типам данных. В отличие от простых, структурированные типы определяют наборы однотипных или разнотипных компонент.
В Паскале существуют следующие структурированные типы:
1) Массивы
2) Записи
3) Множества
4) файлы
4.1 Одномерные массивы
Массив представляет собой фиксированное количество элементов одного и того же типа. Такой способ организации позволяет обозначать все значения этого типа одним именем, а для доступа к отдельным элементам массива использовать это имя и индекс (порядковый номер) необходимого элемента.
Например, пусть для решения какой-либо задачи требуется в программе выделить 7 ячеек памяти и занести в них начальные значения, равные нулю.
Как бы вы это сделали,
используя простые переменные: | используя массив: |
Var a, b, c, d, e, g, h: integer; Begin a:=0; b:=0; c:=0 d:=0; e:=0; g:=0; h:=0; … | Var a: array [1..7] of integer; p:integer; Begin for p:=1 to 7 do a[p]:=0; … |
В памяти наш массив можно представить следующим образом:
a1, a2, a3, a4, a5, a6, a7
Описание массива
var <имя>: array [n1..n2] of <тип элементов>;
- одномерный массив, имеет один размер – количество элементов:
n1 – начальный индекс массива (порядковый номер 1-го элемента),
n2 – конечный индекс массива (порядковый номер последнего элемента),
<тип> - тип элементов массива.
Индексы задаются константами, обычно целого или символьного типа. Тип элементов массива может быть любой.
Пример 1:
var a: array [-2..5] of integer; {8 элементов целого типа}
var b: array [0..3] of integer; {4 элемента целого типа }
Доступ к элементам массива осуществляется указанием имени массива, за которым в квадратных скобках указывается значение индекса элемента: имя[индекс]
В качестве индекса можно использовать:
- константы: а[5], b[38]
- переменные: a[i], b[k]
- выражения: a[i+1], b[2*i]
Элементы массива можно использовать везде, где допустимо использование простых переменных. Обычно при работе с массивами используют операторы цикла.
Необходимо следить за тем, чтобы индекс массива не выходил за диапазон, указанный при описании (типичная ошибка).
Пример 1.
var mas: array [1..10] of real;
i: integer;
begin
mas[11]:=0; {ошибка трансляции}
mas[1]:=1;
for i:=1 to 10 do при i=1 mas[2]: = mas[1]*2
mas [i+1]:=mas[i]*2; при i=2 mas[3] := mas[2]*2
………………………
{ошибка выполнения} при i=10 mas[11] := mas[10]*2
end.
Пример 2. Ввести с клавиатуры массив из 10 элементов и вычислить сумму элементов.
var a: array [0..9] of real;
s:real;
i:integer;
begin
writeln (‘Введите 10 элементов массива’);
for i:=0 to 9 do readln (a[i]);
s:=0;
for i:=0 to 9 do s:=s+a[i];
writeln (‘сумма=’, s);
end.
Пример 3: Ввести с клавиатуры массив положительных чисел (ввод закончить отрицательным числом). Определить максимальный элемент массива.
var m: array [1..1000] of real;
p, max: real;
i, n: integer;
begin
i:=1;
repeat
write(‘Введите ’,i,’ элемент’);
readln(p);
if p>0 then m[i]:=p;
i:=i+1;
until p<0;
n:=i-1;
max:=m[1];
for i:=1 to n do
if m[i]>max then max:=m[i];
writeln(‘max = ’, max);
end.
Пример 4: Сформировать массив из 50 случайных целых чисел, распечатать его и определить номер элемента, ближайшего к среднему арифметическому.
var b: array [1..50] of integer;
ras, s: real;
num, i: integer;
begin
randomize;
for i:= 1 to 50 do b[i]:=random(100);
for i:= 1 to 50 do write(b[i], ‘ ’);
s:=0;
for i:= 1 to 50 do s:=s+b[i];
s:=s/50;
num:=1;
ras:=abs(s-b[1]);
for i:=2 to 50 do
if abs(s-b[i])<ras then
begin
ras:=abs(s-b[i]);
num:=i;
end;
writeln(‘Среднее = ’,s,’ ближайший элемент b[’,num,’]=’,b[num]);
end.
Пример 5: Использование стандартных процедур BREAK и CONTINUE в операторах циклов. В массиве целых чисел найти первое отрицательное число и вывести его на экран.
const n=10;
var a: array [1..n] of integer;
i: integer;
yes: boolean;
begin
writeln(‘Введите элементы массива’);
for i:=1 to n do
begin
write(‘a[’,i,’]=’);
readln(a[i]);
end;
yes:=false;
for i:=1 to n do
begin
if a[i]>=0 then continue; { continue – возврат на заголовок цикла}
writeln(‘первое отрицательно число = ’, a[i]);
yes:=true;
break; { break – окончание выполнения цикла и переход к следующему оператору
программы, в данном примере – к условному оператору if }
end;
if not yes then writeln(‘Отрицательных чисел нет’);
end.
4.2 Сортировка элементов массива
Сортировкой массива называется расстановка элементов массива в возрастающем или убывающем порядке.
Существует множество методов сортировки, рассмотрим два наиболее простых и распространенных метода: метод прямого выбора и метод «пузырька».
Метод прямого выбора (через поиск максимального и минимального элемента).
Алгоритм сортировки по возрастанию (через поиск минимального элемента):
Определяется минимальный элемент массива и помещается на 1-е место Среди оставшихся элементов (начиная со 2-го) определяется минимальный элемент и помещается на 2-е место. Среди оставшихся элементов (начиная со 3-го) определяется минимальный элемент и помещается на 3-е место. И т. д. до конца массива.Пример:
1|
 |
1 3|8 7 5
 |
Программа:
var a: array [1..10] of real;
i, j: integer;
t: real;
begin
randomize;
for i:= 1 to 10 do
begin
a[i]:=random;
write(a[i]:6:3);
end;
writeln;
for i:= 1 to 9 do
for j:=i+1 to 10 do
if a[i]>a[j] then
begin
t:=a[i];
a[i]:=a[j];
a[j]:=t;
end;
for i:= 1 to 10 do write (a[i]:6:3);
end.
Для обмена значениями двух переменных обычно используют дополнительную переменную (дополнительную ячейку памяти), в приведенной выше программе – это переменная t.
Метод «пузырька» (перестановок).
Алгоритм сортировки по возрастанию:
Сравниваются попарно соседние элементы: 1-й со 2-м, 2-й с 3-м, 3-й с 4-м и т. д. до конца массива. Если соседние элементы расположены не по возрастанию, то они меняются местами. Таким образом, максимальный элемент массива «всплывает» на последнее место. Снова сравниваются попарно соседние элементы и меняются местами, если не по возрастанию. Всплывает элемент, меньший максимального, на предпоследнее место. И т. д. до тех пор, пока будут перестановки.Пример:
 |  |
8
3 5 1 7 8
3 1 5 7 8
Программа:
var a: array [1..10] of real;
i: integer;
t: real;
b: boolean;
begin
randomize;
for i:= 1 to 10 do
begin
a[i]:=random;
write(a[i]:6:3);
end;
writeln;
repeat
b:=false;
for i:= 1 to 9 do
if a[i]>a[i+1] then
begin
t:=a[i];
a[i]:=a[i+1];
a[i+1]:=t;
b:=true;
end;
until b=false; {Если b=false – это значит, что не было ни одной перестановки. Следовательно,
массив отсортирован, переходим к выводу отсортированного массива на экран: }
for i:= 1 to 10 do write(a[i]:6:3);
end.
4.3 Многомерные массивы
В качестве элементов массива могут быть значения любого типа, в том числе и массивы, например:
var a: array [N1..N2] of array [N3..N4] of real;
Обычно используют более короткую форму записи:
var a: array [N1..N2, N3..N4] of real; - двумерный массив (матрица), имеет два размера:
N1..N2 – диапазон изменения первого индекса (номер строки)
N3..N4 – диапазон изменения второго индекса (номер столбца)
Пример 1:
var a: array [1..3, 1..4] of integer;
a11 a12 a13 a14
a21 a22 a23 a24
a31 a32 a33 a34
Пример 2:
var b: array [1..5, 1..5, 1..5] of real; - трехмерный массив
Мы будем использовать только одномерные и двумерные массивы.
Обращение к элементам: a[1,3]:=0;
a[3,2]:=5;
В памяти:
1 | 2 | 3 | 4 | |
1 | 0 | |||
2 | ||||
3 | 5 |
Замечание: Размер любого массива не должен превышать 64 кбайта.
Как вычислить размер массива рассмотрим на примере 1. Массив a имеет размер 3x4, т. е. состоит из 12-ти элементов. Элементы массива a целого типа, т. е. каждый элемент занимает 2 байта памяти. Следовательно, весь массив занимает 24 байта памяти.
При обработке матрицы внешний цикл может быть по номеру строки, а внутренний цикл – по номеру столбца матрицы:
for str:= 1 to 3 do
for stb:= 1 to 4 do
write (a[i, j]);
либо наоборот: внешний цикл - по номеру столбца, а внутренний цикл – по номеру строки матрицы:
for stb:= 1 to 4 do
for str:= 1 to 3 do
write (a[i, j]);
В результате выполнения 1-го фрагмента программы увидим на экране содержимое элементов массива в следующем порядке: a11 a12 a13 a14 a21 a22 a23 a24 a31 a32 a33 a34
В результате выполнения 2-го фрагмента программы - в другом порядке:
a11 a21 a31 a12 a22 a32 a13 a23 a33 a14 a24 a34
Пример 3: Заполнить матрицу размерностью 5х10 целыми случайными числами в диапазоне от 0 до 99 и найти минимальный элемент матрицы и сумму элементов.
var m: array [1..5,1..10] of integer;
i, j,s, min: integer;
begin
randomize;
for i:=1 to 5 do
begin
for j:=1 to 10 do
begin
m[i, j]:=random(100);
write(m[i, j]:4);
end;
writeln;
end;
s:=0; min:=m[1,1];
for i:=1 to 5 do
for j:=1 to 10 do
begin
s:=s+m[i, j];
if m[i, j]<min then min:=m[i, j];
end;
writeln(‘S = ’,s,’ min = ’,min);
end.
Пример 4: Сформировать матрицу размерностью 5х5, где aij=i*j, и вывести ее на экран;
определить сумму элементов каждого столбца матрицы и вывести полученные значения на экран.
var a: array [1..5,1..3] of integer;
sum, i,j: integer;
begin
for i:=1 to 5 do
begin
for j:=1 to 3 do
begin
a[i, j]:=i*j;
write(a[i, j]:4);
end;
writeln;
end;
for j:=1 to 3 do
begin
sum:=0;
for i:=1 to 5 do
sum:=sum+ a[i, j];
writeln(‘сумма ’,,j,’-го столбца = ’,sum);
end;
end.
Задачи для самоконтроля
4.1 Какой оператор является ошибочным?
var a: array [0..5] of integer;
p: integer;
Begin
a[1]:=8;
p:=5;
a[p+1]:=7;
4.2 Определите значение sum после выполнения программы:
var a: array [1..2,1..3] of integer;
p, sum: integer;
Begin
a[1,1]:= 8; a[1,2]:= - 6; a[1,3]:= 2;
a[2,1]:= 4; a[2,2]:= 9; a[2,3]:= - 5;
for p:=1 to 2 do
sum:= sum + a[p, p];
end.
5. Подпрограммы (процедуры и функции)
Подпрограмма – относительно самостоятельная часть программы, имеющая свое имя и выполняющая определенные действия.
Подпрограммы повышают надежность и наглядность программ, т. к. позволяют разрабатывать и отлаживать каждый блок программы независимо (например, разными людьми).
Структура подпрограммы почти полностью повторяет структуру всей программы и состоит из следующих частей:
- заголовок подпрограммы
- раздел описаний
- тело подпрограммы
В Паскаль имеются два вида подпрограмм – процедуры и функции. Они отличаются назначеием и способом их использования. Процедуры служат для выполнения определенной последовательности действий, направленных на изменение программной обстановки (изменение значений переменных, ввод/вывод данных и т. п.). Функции для вычисления значения выражения.
5.1 Процедуры
procedure <имя> (список формальных параметров);
<раздел описаний>;
begin
<тело процедуры>;
end;
Пример 1: Процедура вычисления и вывода на экран куба числа.
procedure cub(x: real);
var y: real;
begin
y:=x*x*x;
writeln(y);
end;
Указание имени процедуры в программе приводит к активизации процедуры и называется ее вызовом. Сразу после активизации процедуры начинают выполняться входящие в нее операторы. После выполнения последнего оператора процедуры управление передается в основную программу и далее выполняются операторы, следующие за вызовом процедуры. Процедура может вызываться в основной программе неоднократно.
Например:
cub(5);
…
readln(z);
cub(z);
Для обмена информацией между основной программой и процедурой используются параметры, которые придают процедуре универсальность.
Пример 2: Программа, выводящая на экран следующее:
*
a=1 b=1
*
a=2 b=4
*
a=3 b=9
*
a=4 b=16
*
var a, b: integer;
procedure Stars; {без параметров}
var i: integer;
begin
for i:=1 to 9 do write(‘*’);
writeln;
end;
begin
Stars;
for a:=1 to 4 do
begin
b:=sqr(a);
writeln(‘a=’,a,’ b=’,b);
Stars; {вызов процедуры Stars }
end;
end.
Пример 3:
var a, b: integer;
procedure Stroka(ch: char, n: integer);
var i: integer;
begin
for i:=1 to n do write(ch);
writeln;
end;
begin
Stroka(‘+’,4);
for a:=1 to 3 do
begin
b:=sqr(a);
writeln(‘a=’,a,’ b=’,b);
Stroka(‘*’,8);
end;
end.
Разберем вызов процедуры Stroka(‘*’,8): ‘*’ и 8 – фактические параметры (т. е. те, которые указаны в скобках после имени процедуры при ее вызове), они присваиваются при вызове формальным параметрам ch и n (т. е. тем, которые указаны в скобках после имени процедуры при ее описании).
Замечание: количество, порядок и тип параметров при вызове процедуры должны совпадать с количеством, порядком и типом параметров, заданным при описании процедуры.
Результат на экране:
++++
a=1 b=1
a=2 b=4
a=3 b=9
5.2 Функции
Функция отличается от процедуры тем, что результат работы функции возвращается в виде значения через ее имя. Вызов процедуры – это отдельный оператор, а вызов функции может быть использован в выражениях вместе с другими операторами (в правой части оператора присваивания или в операторе write/writeln).
Пример:
стандартные процедуры: write, writeln, read, readln, delay, clrscr…
стандартные функции: sqr, sqrt, abs, odd, exp, ln, sin, cos…
Описание функции:
function <имя> (список формальных параметров): <тип>;
<раздел описаний>;
begin
<тело функции>;
end;
Пример 1: f(x, y)=
;
function f (x, y: integer): real;
begin
f:=sqrt(sqr(x)+sqr(y));
end;
begin
……
z:=f(2,3);
writeln(‘f=’, f(6,8));
end.
Пример 2: 
var s:real;
i, n: integer;
function fact(k: integer): longint;
var f: longint;
j: integer;
begin
f:=1;
for j:=1 to k do f:=f*j;
fact:=f;
end;
begin
write(‘Введите n’);
readln(n);
S:=0;
for i:=1 to n do s:=(s+1)/(fact(i)+fact(i+1)+fact(i+2));
writeln(‘S = ’,s:6:4);
end.
5.3 Области действия имен
1) Имена переменных, описанных в основной программе, называются глобальными и доступны в основной программе и во всех подпрограммах.
2) Имена переменных, описанных в подпрограмме, называются локальными и доступны в этой подпрограмме и во всех вложенных в нее подпрограммах (это же относится и к именам формальных параметров!)
3) 
Имена локальных переменных перекрывают имена глобальных, то есть если имена переменных в основной программе и подпрограмме совпадают, то в подпрограмме недоступна переменная, описанная в основной программе.
А – основная порграмма, все переменные доступны везде
B, E – подпрограммы, вложенные в А
C, D – подпрограммы, вложенные в В
5.4 Параметры процедур и функций
Формальные параметры – это параметры, используемые при описании процедур и функций
Фактические параметры – это параметры, используемые при вызове процедур и функций.
При вызове подпрограммы формальные параметры заменяются на соответствующие фактические параметры основной программы (!).
Пример:
var c: integer;
procedure p(b: integer);
begin
…
end;
b – формальный параметр
begin с – фактический параметр
p(c);
end.
По способу описания и передачи значения формальные параметры делятся на параметры-значения и параметры-переменные.
- Параметры-значения (имя: тип)
Изменение значения таких параметров в подпрограмме не приводит к изменениям соответствующих фактических параметров основной программы. В подпрограмму передается копия фактического параметра (его значение). Поэтому фактические параметры, соответствующие параметрам-значениям, могут быть константами, переменными или выражениями. Другими словами, параметр-значение считается обычной локальной переменной. При вызове подпрограммы начальное значение параметра автоматически устанавливается равным значению соответствующего фактического параметра, заданного при вызове. Внутри подпрограммы возможны любые действия с формальными параметрами, но эти изменения никак не отражаются на значениях переменных основной программы.
Пример1:
var a: integer;
procedure proc(x: integer);
begin
x:=x+2;
end;
begin
a:=10;
proc(a); writeln(a); 10
proc(a*a); writeln(a); 10
proc(25); writeln(a); 10
end.
- Параметры-переменные ( (var имя: тип); )
Изменение формальных параметров в подпрограмме приводит к аналогичному изменению фактических параметров, используемых при вызове подпрограммы. Эти параметры используются для возврата значений из процедур (в функциях обычно не используются, т. к. функция возвращает значение через свое имя).
В подпрограмму передается адрес фактического параметра, а не его копия. (Формальный параметр считается синонимом соответствующего фактического параметра). Поэтому фактический параметр, соответствующий параметру-переменной, должен быть переменной того же типа, что и формальный параметр (константы или выражения не допускаются).
Пример 1:
var a, b: integer;
procedure proc(x: integer; var y: integer);
begin
y:=x+y;
|
begin
a:=10; b:=10;
proc(a, b);
writeln(‘a = ’,a,’ b= ‘,b); a = 10 b = 20
end.
Пример2: Программа вычисления объема шара V=4/3πR3
С использованием функции: С использованием процедуры:
var r, v: real;
function vol (r:real): real;
begin
vol:=4/3*pi*r*r*r;
end;
begin
write(‘Введите радиус шара’);
readln(r);
v:=vol(r);
writeln(‘Объем шара = ’, v);
end.
var r, v: real;
procedure vol(r: real; var v:real);
begin
v:=4/3*pi*r*r*r;
end;
begin
write(‘Введите радиус шара’);
readln(r);
vol(r, v);
writeln(‘Объем шара = ’, v);
end.
|
|
5.5 Побочные эффекты при использовании подпрограмм
Побочные эффекты возникают, когда изменение переменных в подпрограмме приводит к их нежелательным изменениям в основной программе
Пример: программа с побочным эффектом
var s, p: integer; 
procedure Sum(n: integer, var f: integer);
var i: integer;
begin
|
for i:=1 to n do s:=s+i;
f:=s;
end;
begin
s:=2;
sum(3,p);
writeln(s, p); 6 6
end.
Процедура изменяет значение глобальной переменной S (!). Надо добавить в нее описание локальной S:
procedure Sum(n: integer, var f: integer);
var i: integer;
s: integer;
begin
…
5.6 Передача массивов в подпрограммы
Типом формального параметра подпрограммы может быть стандартный или заранее определенный тип, заданный в виде идентификатора (!). Поэтому описание процедуры следующего вида является недопустимым:
procedure S(a: array [1..10] of real);
В связи с этим, если в качестве параметра необходимо использовать массив, то делается предварительное описание типа массива:
type mas=array [1..10] of real;
…
procedure s(a: mas);
begin
…
end;
var b: mas;
c: array [1..10] of real;
begin
S(b);
S(c); - нельзя!
…
Массив может передаваться как параметр-значение, и как параметр-переменная. Если параметр массив описан со словом var, то изменение массива в подпрограмме приводит к изменению соответствующего массива в основной программе.
Пример:
type mas=array [1..10] of integer;
var c, d: mas;
i: integer;
procedure S(a: mas, var b: mas);
var i: integer;
begin
for i:=1 to 10 do
begin
a[i]:=a[i]*5;
b[i]:=b[i]*5;
end;
end;
begin
for i:=1 to 10 do
begin
c[i]:=1;
d[i]:=1;
end;
s(c, d);
for i:=1 to 10 do write (c[i]:3); …
writeln;
for i:=1 to 10 do write (d[i]:3); …
end.
Следующие три пункта 5.7, 5.8 и 5.9 являются необязательными для изучения, хотя рассмотренный в них материал достаточно широко используется в программировании.
5.7 Параметры-костанты
В Турбо-Паскаль 7.0 существует еще один вид параметров – параметры-константы.
(const имя: тип)
В этом случае в подпрограмму передается адрес фактического параметра, но он защищен от изменений.
Чаще всего используется для передачи в подпрограмму массивов, которые не должны изменяться. В этом случае нельзя использовать параметр-переменную, а использование параметра-значения не эффективно, т. к. на копию массива требуется много памяти и может быть переполнение стека.
type mas=array [1..10] of real;
var a: mas;
function Summa (const x:mas): integer;
var s, i: integer;
begin
s:=0;
for i:=1 to 10 do s:=s+x[i];
summa:=s;
end;
begin
randomize;
for i:=1 to 10 do a[i]:=random(20);
writeln(‘сумма элементов массива: ’,summa(a));
end.
5.8 Массивы открытого типа
В Турбо-Паскаль 7.0 в качестве параметров-переменных можно использовать массивы открытого типа, у которых не задаются размеры. В этом случае подпрограмма может обрабатывать массив любого размера. Фактический размер массива может быть определен с помощью функции High. При описании не указывается тип индекса массива. Индексация элементов открытого массива всегда от 0 до значения функции High ( 0..high(x) , где x – имя массива).
|
Из за большого объема этот материал размещен на нескольких страницах:
1 2 3 4 5 6 |
