Лекция 3
<Раздел объявления типов > :: =
type // Признак начала раздела объявления типов
<Имя Типа 1> = <Спецификация Типа 1> ;
<Имя Типа 2> = <Спецификация Типа 2> ;
. . .
Пример.
type
MyInt = integer;
MyDouble = double;
<Раздел объявления типизированных констант> :: =
const // Признак начала раздела объявления констант
<Имя константы 1> : <Тип 1> = < Константное выражение 1> ;
<Имя константы 2> : <Тип 2> = < Константное выражение 2> ;
. . .
Пример:
const
n: longint = 2000000000;
EulerGamma: double = 0.5772156649015329;
pi_half: double = pi / 2.0; pi_quarter: double = pi_half / 2.0;
Замечание. В Turbo Pascal 7.0 «типизированная константа» на деле константой не является: в тексте программы эту «константу» можно изменять. «Типизированная константа» – это, в действительности, инициализированная переменная.
Замечание. Типизированная константа не может участвовать в константном выражении.
Замечание. В Delphi типизированные константы, в отличие от констант без типа, могут принимать значения массивов, записей, процедур, указателей.
Если действует ключ компиляции {$J-} (явно или по умолчанию), значения, принятые типизированными константами при объявлении, не могут быть изменены. Напротив, ключ {$J+} дает типизированным константам возможность изменяться по ходу исполнения программы.
Замечание. В языке «C++» инициализированные переменные объявляются так:
<Тип 1>
<Имя 1> = <Константное выражение 1>,
<Имя 2> = <Константное выражение 2>,
. . .
<Имя N> = <Константное выражение N>;
<Тип 2>
<Имя N+1> = <Константное выражение N+1>,
. . .
Примеры.
int I = 2, J = –5, K = 888;
double x = 1.0, y = –2.2, z = 0.123;
char c = ‘Q’;
Цикл с постусловием
repeat <Операторы> until <Л.В.>
<Операторы> являются телом цикла.
Тело цикла выполняется по меньшей мере один раз, а затем, возможно, многократно, пока < Л.В.> есть ложь.
Если < Л.В.> есть истина при первой же оценке, то тело цикла выполняется один раз.
Если < Л.В.> есть ложь при каждой оценке, то тело цикла выполняется неограниченно много раз.
В случае, если тело цикла содержит несколько операторов, нет необходимости использовать операторные скобки. Слово repeat заменяет собой begin, тогда как слово until заменяет собой end.
Замечание. В языке «C++» родственная конструкция имеет вид:
do <Оператор> while (<Л.В.>)
«Полностью» аналогичная конструкция имеет вид:
do <Оператор> while (! <Л.В.>)
Знак логической инверсии «!» необходим, если истинность <Л.В.> должна приводить к прекращению цикла.
Замечание по теме «циклы»
Инструкция break применяется для досрочного прекращения цикла. Равноценна оператору “goto Metka1”, для которого “Metka1:” расположена сразу после оператора цикла.
Инструкция continue применяется для досрочного перехода на очередную проверку условия продолжения цикла.
Равноценна оператору “goto Metka2”, для которого “Metka2:” расположена сразу после последнего из операторов, составляющих тело цикла.
Инструкции break и continue в Паскале заимствованы из языка «C++».
Процедуры
<Объявление процедуры> :: =
procedure <Имя процедуры>[(<Список формальных параметров)];
<Разделы объявления локальных типов, констант, переменных>
<Разделы объявления локальных процедур и функций>
begin |
} Раздел исполнения (тело) процедуры |
<Операторы> |
|
end; |
<Список формальных параметров> :: =
<Элемент списка 1>; <Элемент списка 2>; . . .
<Элемент списка> :: =
<Список имён параметров-значений>: <Тип>
или
var <Список имён параметров-переменных>: <Тип>
или
const <Список имён параметров-констант>: <Тип>
<Обращение к процедуре> :: =
<Имя процедуры>[(<Список фактических параметров>)]
Замечание. Фактические параметры должны быть совместимы с формальными по типам.
Параметр-значение сам процедуре не передаётся. Передаётся лишь его «численная» (или иная, согласно типу параметра) копия, под которую выделяется дополнительное место в оперативной памяти. Это важно иметь в виду, особенно, если параметр занимает много места в памяти.
Переменная, реализующая параметр-значение, может быть, при необходимости, использована, как локальная переменная.
По окончании работы процедуры эта переменная становится недоступной. Новое значение, приданное ей в теле процедуры, недоступно в том месте, из которого процедура вызвана.
Параметр-переменная именно сам передаётся процедуре. Изменения, произошедшие с таким параметром, сохраняются и по окончании работы процедуры.
Параметр-константа также сам передаётся процедуре. Изменения такого параметра в теле процедуры запрещены.
Пример.
program Example2;
type
MyInt = integer ;
var
I : MyInt ;
J: integer ;
procedure P2(var M: integer);
begin
. . .
end;
begin
P2(J) ; // Нормально
P2(I) ; // Ошибка. Несоответствие типов
end.
Пример.
program Example3;
var
I, J, K : integer ;
procedure P3(L : integer ; var M : integer ; const N : integer);
begin
Inc(L) ; // Бесполезно
Inc(M) ; // Полезно
(* Inc(N) ; *) // Ошибка
end;
begin
I := 1; J := 1; K := 1;
P3(I, J, K) ;
wri teln(‘I=’, I) ; // I = 1, переменная не изменилась
wri teln(‘J=’, J) ; // J = 2, переменная изменилась
end.
Замечание. В языке «C++» процедур нет. Роль процедур исполняют функции, возвращающие значение void (пусто).
<Объявление функции void> :: =
void <Имя функции>([<Список формальных параметров>])
{ |
} Раздел исполнения (тело) функции |
<Операторы> |
|
} |
<Список формальных параметров> :: =
<Элемент списка 1>; <Элемент списка 2>; . . .
<Элемент списка> :: =
<Тип> <Имя параметра-значения>
или
const <Тип> <Имя параметра-значения>
Пример.
#include <vcl.h>
#include <stdio.h>
#include <conio.h>
#pragma hdrstop
int
I, J, K, Q;
void P3(int L; int *M; const int N; const int *P)
{
L++ ; // Бесполезно
*M++ ; // Полезно
// N++ ; // Ошибка
// *P++ ; // Ошибка
// P++ ; // Ошибка
}
int main(int argc, char* argv[])
{
I = 1; J = 1; K = 1; Q = 1;
P3(I, &J, K, &Q) ;
printf(“I=%d”, I) ; // I = 1, переменная не изменилась
printf (“J=%d”, J) ; // J = 2, переменная изменилась
{
Функции
<Объявление функции> :: =
function <Имя функции>(<Список формальных параметров>) :
<Тип возвращаемого значения>;
<Разделы объявления локальных типов, констант, переменных>
<Разделы объявления локальных процедур и функций>
begin |
} Раздел исполнения функции |
<Операторы> |
|
end; |
Среди <Операторов> должен быть хотя бы один «Оператор» вида
<Имя функции> := <Выражение> ;
или
result := <Выражение> ;
Пример.
program Example4;
var
x, y, Eps : Double ;
function BesselI0(x, Eps : Double) : Double ;
var
S, A, B, R: Double ;
begin
. . .
BesselI0 := S ;
end;
begin
writeln(‘x=? ’) ; readln(x);
writeln(‘Eps=? ’) ; readln(Eps);
y := BesselI0(x, Eps) ; writeln(‘y=’, y) ;
end.
,
Условия
прекращения цикла суммирования:
и
S0 = 0 |
A0 = 1 |
|
S1 = S0 + A1 |
A1 = A0*B1 |
B1 = (x/2)2/12 |
S2 = S1 + A2 |
A2 = A1*B2 |
B2 = (x/2)2/22 |
. . . |
. . . |
. . . |
Si = Si-1 + Ai |
Ai = Ai-1* Bi |
Bi = (x/2)2/i2 |
Текст программы на языке Free Pascal, TP7:
program BesselI0 ; // Необязательная строка
var
x,y: Double;
function BesselI0(x, Eps : Double): Double;
var
I, N: integer;
S, A, B, R, x2: Double;
begin
S := 0 ;
x2 := sqr(x/2) ;
A := x2 ;
N := 0 ;
B := x2 / (N + 2) / (N + 2) ;
repeat
inc(N);
A := A * B ;
B := x2 / (N + 2 ) / (N + 2) ;
R := A / (1 - B) ;
until ( B < 1) and ( R < Eps ) ;
S := 1;
A := 1;
S0 = 0 |
A0 = 1 |
|
S1 = S0 + A1 |
A1 = A0*B1 |
B1 = (x/2)2/12 |
S2 = S1 + A2 |
A2 = A1*B2 |
B2 = (x/2)2/22 |
. . . |
. . . |
. . . |
Si = Si-1 + Ai |
Ai = Ai-1* Bi |
Bi = (x/2)2/i2 |
for I := 1 to N do
begin
B := x2 / I / I;
A := A * B;
S := S + A;
end;
BesselI0 := S ;
end ;
begin
writeln(‘Введите x’) ; readln(x) ;
writeln(‘Введите Eps’) ; readln(Eps) ;
if (Eps <= 0) or (Eps >= 1) then exit ;
writeln(‘f=’, BesselI(x, Eps));
readln;
end.
Тип «Перечисляемый»
<Перечисляемый тип> : : =
(<Список имён значений>)
Первому из элементов <Списка имён значений> придаётся внутренний (недоступный пользователю) номер 0, второму – номер 1, и т.д.
Переменные типа «Перечисляемый»
Примеры
var
v1: (LeftDyrecton, RightDyrecton, BackDyrecton);
type
MyType2=(Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);
MyType4=(MyTrue, MyFalse);
var
MyVar2: MyType2;
MyVar3: boolean;
MyVar4: MyType4;
begin
for MyVar2 :=Monday to Friday do writeln(MyVar2); // Ошибка
for MyVar4 :=MyFalse to MyTrue do writeln(MyVar4); // Ошибка
for MyVar3 := False to True do writeln(MyVar3); // Выход: True False
end.
Замечание. boolean ≠ (False, True). Вообще говоря.
Замечание. Тип «Перечисляемый – порядковый тип.
Диапазон
<Диапазон> : : =
<Целое число 1> . . <Целое число 2>
Естественное требование:
<Целое число 1> не более, чем <Целое число 2>
Примеры.
1 . . 5
First . . Third
// Если выше по тексту было что-то наподобие:
// const First = 0; Third = 2;
Тип «Диапазон»
type <Имя типа> = <Диапазон> ;
Пример.
type MyType01 = –3 . . 72 ;
Переменные типа «Диапазон»
Примеры:
var
v1: 22 . . 44 ;
v2: MyType01 ;
const
v3: MyType01 = 6 ;
const
MyConst11 = 1; MyConst12 = 7;
type
MyType02 = MyConst11 .. MyConst12;
var
MyVar02: MyType02;
Замечание. Тип–Диапазон – порядковый тип.
Массивы
Все типы переменных, изученные до сих пор – скалярные (простые) типы.
Массив – вектор, матрица, ...
Массив – упорядоченная совокупность данных одного типа.
Массив – переменная с индексом (со списком индексов).
<Объявление одномерного массива> : : =
<Имя переменной> : array[<Диапазон>] of <Тип элемента> ;
<Объявление нескольких многомерных массивов> : : =
<Список имён > : array[<Список диапазонов>] of <Тип элемента> ;
или
<Список имён > : <Тип-массив> ;
<Тип-массив> : : =
array[<Список диапазонов>] of <Тип элемента > ;
<Обращение к элементу массива> : : =
<имя массива> [ <Список значений индексов> ]
Пример
const
MyConst21 = 1; MyConst22 = 8;
type
MyRange1 = 1 . . 7;
MyRange2 = MyConst21 . . MyConst22;
var
A: array[1 . . 4] of integer;
A1, A2, A3: array[1 . . 4, -1 . . 7] of double;
A4: array[MyRange1] of double;
A5: array[MyRange1, MyRange2] of double;
begin
A[3] := 99;
A1[2, 6] := 5.3;
A2[1][7] := 4.1e-10;
A3[5, 0] := 2;
end.
Пример. Заполнить матрицу числами, составляющими треугольник Паскаля.
,
.
,
.
const
n=16;
type
MyArrayType = array[0 . . n , 0 . . n] of integer;
. . .
procedure PT(var mG: MyArrayType);
// procedure PT(var mG: array[0 . . n , 0 . . n] of integer);
var
m, k: integer;
begin
for m := 0 to n do for k := 0 to n do mG[m, k] := 0;
mG[0, 0] := 1;
for m := 1 to n do
begin
mG[m, 0] := 1; mG[m, m] := 1;
for k := 1 to m-1 do mG[m, k] := mG[m-1, k] + mG[m-1, k-1];
end;
end;
. . .