Типы данных, определяемые программистом

Двумерные массивы

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

const n = 4; m = 3;
type mas  = array [1 .. n] of integer;    
     mas2 = array [1 .. m] of mas;

Более компактно это можно записать так:

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

Здесь описан тип массива, состоящего из ). Обе размерности массива должны быть константами или константными выражениями. Имя типа указывается при описании переменных, например:

var a, b : mas2;

В памяти двумерный массив располагается по строкам.

a11  a12  a13  a14  a21  a22   a23  a24  a31  a32  a33  a34
|  – 1–я строка –   |   – 2–я строка –    |   – 3–я строка –   |

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

(рис 3.1) Матрица из m строк и n столбцов

К элементу двумерного массива обращаются, указывая номер строки и номер столбца, на пересечении которых он расположен, например:

a[1, 4] b[i, j] b[j, i]

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

const a : mas2 = ( ( 2, 3, 1, 0),
                   ( 1, 9, 1, 3),
                   ( 3, 5, 7, 0)  );

С массивами в целом определена только одна операция — присваивание массивов одного типа (например, b := a ) . Все остальные действия выполняются с отдельными элементами. Например, чтобы ввести с клавиатуры двумерный массив, необходимо организовать вложенные циклы:

for i := 1 to m do
    for j := 1 to n do read(a[i, j]);

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

Пример. Программа, которая для целочисленной матрицы 3x4 определяет среднее арифметическое ее элементов и количество положительных элементов в каждой строке.

program sred_n;
const m = 3; n = 4;
var a : array [1 .. m, 1 .. n] of integer;
    i, j, n_pos_el : integer;
    sred : real;
begin
    for i := 1 to m do
    for j := 1 to n do read(a[i, j]);
    sred := 0;
    for i := 1 to m do begin
        n_pos_el := 0;
        for j := 1 to n do begin
            sred := sred + a[i, j];
            if a[i, j] > 0 then inc(n_pos_el);
        end;
        writeln('В ', i, '–й строке ', n_pos_el, ' положительных элементов');
    end;
    sred := sred / m / n;
    writeln('Среднее арифметическое: ', sred:6:2);
end.

Строки

Строки используются для хранения последовательностей символов. В Паскале существует три типа строк:

Строка типа string может содержать до 255 символов. Под каждый символ отводится по одному байту, в котором хранится код символа. Еще один байт отводится под фактическую длину строки. Таким образом, в памяти под одну переменную типа string всегда отводится 256 байт.

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

type str4 = string [4]; { переменная такого типа занимает в памяти 5 байтов }

Примеры описания строк:

const n = 15;
var s : string;         { строка стандартого типа }
    s1 : str4;          { строка типа str4, описанного выше }
    s2 : string [n];    { описание типа задано при описании переменной }

Инициализация строк, как и переменных других типов, выполняется в разделе описания констант.

const s3 : string [15] = 'shooshpanchik';

Внутреннее представление строки .

(рис 3.2) Внутреннее представление строки s3

Операции

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

s2 := 'shooshpanchik'; 
s1 := s2;                  { в s1 будут помещены символы "shoo" }

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

s1 := 'ком';
s2 := s1 + 'пот';                        { результат — "компот" }

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

'abc' > 'ab' 'abc' = 'abc' 'abc' < 'abc '

Имя строки может использоваться в процедурах ввода-вывода:

readln (s1, s2); write (s1);

При вводе в строку считывается из входного потока количество символов, равное длине строки или меньшее, если символ перевода строки (который вводится нажатием клавиши Enter ) встретится раньше. При выводе под строку отводится количество позиций, равное ее фактической длине.

К отдельному символу строки можно обращаться как к элементу массива символов, например s1[4] . Символ строки совместим с типом char, их можно использовать в выражениях одновременно, например:

s1[4] := 'x'; writeln (s2[3] + s2[5] + 'r');

Процедуры и функции для работы со строками

При работе со строками, как правило, возникает необходимость выполнять их копирование, вставку, удаление или поиск. Для эффективной реализации этих действий в Паскале предусмотрены стандартные процедуры и функции. Они кратко описаны ниже.

Функция Concat (s1, s2, ..., sn) возвращает строку, являющуюся слиянием строк s1, s2, ..., sn.

Функция Copy (s, start, len) возвращает подстроку длиной len, начинающуюся с позиции start строки s.

Процедура Delete (s, start, len) удаляет из строки s, начиная с позиции start, подстроку длиной len.

Процедура Insert (subs, s, start) вставляет в строку s подстроку subs, начиная с позиции start.

Функция Length (s) возвращает фактическую длину строки s, результат имеет тип byte.

Функция Pos (subs, s) ищет вхождение подстроки subs в строку s и возвращает номер первого символа subs в s или нуль, если subs не содержится в s.

Процедура Str (x, s) преобразует числовое значение x в строку s, при этом для x может быть задан формат, как в процедурах вывода write и writeln.

Процедура Val (s, x, errcode) преобразует строку s в значение числовой переменной x, при этом строка s должна содержать символьное представление числа. В случае успешного преобразования переменная errcode равна нулю. Если же обнаружена ошибка, то errcode будет содержать номер позиции первого ошибочного символа, а значение x не определено.

program censor;
var s, str : string[10];
    f      : text;
    i, dl  : integer;
begin
    assign(f, 'primer.txt'); reset(f);
    writeln('Какую последовательность заменять?'); readln(s);
    dl := length(s);
    while not Eof(f) do begin
        readln(f, str);
        i := 1;
        while i <> 0 do begin
            i := Pos(s, str);
            if i <> 0 then begin
                Delete(str, i, dl); Insert('...', str, i);
            end;
        end;
        writeln(str);
    end;
    close(f)
end.

Записи

В программах часто возникает необходимость логического объединения разнородных данных (например, база данных предприятия содержит для каждого сотрудника его фамилию, дату рождения, должность, оклад и т. д.). Для этого предназначен тип 'запись'. Он вводится с помощью ключевого слова record. Элементы записи называются полями.

type имя_типа = record
    описание 1-го поля записи;
    описание 2-го поля записи;
    ...
    описание n-го поля записи;
end;

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

type goods = record
    name   : string[20];
    price  : real;
    number : integer;
end;

Переменные типа 'запись' описываются обычным образом. Можно задавать описание типа при описании переменной, создавать массивы из записей, записи из массивов, и т. д.

var g1, g2  : goods;
    stock   : array [1 .. 100] of goods;
    student : record
        name  : string [30];
        group : byte;
        marks : array [1 .. 4] of byte;
    end;

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

g1 := g2; g2 := stock[3];

Все остальные действия выполняются с отдельными полями записи. Есть два способа доступа к полю записи: либо с помощью конструкции имя_записи.имя_поля, либо с использованием оператора присоединения with, например:

g1.price := 200;
with g1 do begin
    price := 200; number := 10
end;

program store;
const Max_n = 100;
type str20 = string [20];
     goods = record
        name   : str20;
        price  : real;
        number : integer;
     end;
var stock     : array[1 .. Max_n] of goods;
    i, j, len : integer;
    name      : str20;
    found     : boolean;
    f         : text;
begin
    assign(f, 'stock.txt'); reset(f); 
    i := 1;
    while not Eof(f) do begin
        with stock[i] do readln(f, name, price, number); 
        inc(i); 
        if i > Max_n then begin                                    { 1 }
            writeln('Переполнение массива'); exit end;
    end;
    while true do begin                                            { 2 }
        writeln('Введите наименование'); Readln(name);
        len := length(name);
        if len = 0 then break;                                     { 3 }
        for j := len + 1 to 20 do name := name + ' ';              { 4 }
        found := false;
        for j := 1 to i – 1 do begin                               { 5 }
            if name <> stock[j].name then continue; 
            with stock[j] do    writeln (name:22, price:7:2, number:5); 
            found := true;
            break;
        end;
        if not found then writeln ('Товар не найден');             { 6 }
    end;
end.

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

const g : goods = (name : 'boots'; price : 200; number : 10);

Множества

Множественный тип данных в языке Паскаль соответствует математическому представлению о множествах: это ограниченная совокупность различных элементов. Множество создается на основе элементов базового типа — это может быть перечисляемый тип, интервальный или byte. В множестве не может быть более 256 элементов, а их порядковые номера должны лежать в пределах от 0 до 255.

Множество описывается с помощью служебных слов set of.

type имя_типа = set of базовый_тип;

Примеры описания множественных типов:

type Caps   = set of 'A' .. 'Z';
    Colors  = set of (RED, GREEN, BLUE);
    Numbers = set of byte;

Принадлежность переменных к множественному типу может быть определена прямо в разделе описания переменных, например:

var oct : set of 0 .. 7;

Тип 'множество' задает набор всех возможных подмножеств его элементов, включая пустое. Если базовый тип, на котором строится множество, имеет k элементов, то число подмножеств, входящих в это множество, равно 2k.

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

['A', 'D'] [1, 3, 6] [2, 3, 10 .. 13].

Порядок перечисления элементов базового типа в константах не имеет значения. Константа вида [ ] означает пустое подмножество. Переменная типа 'множество' содержит одно конкретное подмножество значений множества. Пусть имеется переменная b интервального типа:

var b : 1 .. 3; { переменная может принимать три различных значения: 1, 2 или 3 }

Переменная m типа 'множество'

var m : set of 1 .. 3;

может принимать восемь различных значений:

[ ] [1] [2] [3] [1, 2] [1, 3] [2, 3] [1, 2, 3]

Бестиповые файлы

Бестиповые файлы предназначены для хранения участков оперативной памяти на внешних носителях. После описания файловой переменной

var имя : file;

ее требуется связать с физическим файлом с помощью процедуры assign. Чтение и запись производится через буфер 'порциями', равными размеру буфера. Размер буфера, отличающийся от стандартного (128 байт), можно задать с помощью второго параметра процедур reset и rewrite при открытии файла.

reset(var f : file; bufsize : word)
rewrite(var f : file; bufsize : word)

Размер буфера должен находиться в пределах от 1 байта до 64 Кбайт.

Собственно чтение и запись выполняются с помощью процедур blockread и blockwrite.

blockread(var f : file; var x; count : word; var num : word);
blockwrite(var f : file; var x; count : word; var num : word);

Процедура blockread считывает в переменную x количество блоков count. Длина блока равна размеру буфера. Значение count должно быть больше или равно 1, за одно обращение нельзя ввести больше 64 Кбайт. При вводе никаких преобразований данных не выполняется. Необязательный параметр num возвращает количество прочитанных блоков.

Процедура blockwrite записывает в файл количество блоков, равное count, начиная с адреса, заданного переменной x. Длина блока равна длине буфера. Необязательный параметр num возвращает число успешно записанных блоков.

Для бестиповых файлов применяется как последовательный, так и прямой доступ.

).

program create_bfile;
var buf   : array[1 .. 4] of real;
    f_in  : text;
    f_out : file;
    i, k  : integer;
    name_in, name_out : string;
begin
{$I–}
    writeln('Введите имя входного файла'); readln(name_in);
    assign(f_in, name_in); reset(f_in);
    if IOResult <> 0 then begin
        writeln('Файл ', name_in,' не найден'); exit end;
    writeln('Введите имя выходного файла');    readln(name_out);
    assign(f_out, name_out); rewrite(f_out, sizeof(real) * 4);
{$I+}
    i := 0;
    while not eof(f_in) do begin
        inc(i);
        read(f_in, buf[i]);
        if i = 4 then begin
            blockwrite(f_out, buf, 1); i := 0; end;
    end;
    if i <> 0 then begin
        for k := i + 1 to 4 do buf[k] := 0;
        blockwrite(f_out, buf, 1);
    end;
    close(f_in); close(f_out);
end.

Компонентные файлы

Компонентные файлы применяются для хранения однотипных элементов в их внутренней форме представления. Тип компонент задается после ключевых слов file of.

var имя : file of тип_компонент;

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

type mas = array [1 .. 100] of real;
var a, b : mas;
    f    : file of mas;
begin
    assign(f, 'some_file.dat'); rewrite(f);
    ...
    write(f, a, b);
    close(f)
end.

Обратите внимание, что компонентой этого файла является массив целиком. За одну операцию записывается или считывается столько компонент, сколько перечислено в процедурах write или read.

Компонентные файлы, как и бестиповые, применяются не для просмотра их человеком, а для использования в программах.

Прямой доступ

Бестиповые и компонентные файлы состоят из блоков одинакового размера. В бестиповом файле размер блока равен длине буфера, а в компонентном — длине компоненты. Это позволяет применить к таким файлам прямой доступ, при котором операции выполняются с заданным блоком. Прямой доступ применяется только для физических файлов, расположенных на дисках.

С помощью стандартной процедуры seek производится установка текущей позиции в файле на начало заданного блока, и следующая операция чтения-записи выполняется, начиная с этой позиции. Первый блок файла имеет номер 0.

Ниже описаны стандартные подпрограммы для реализации прямого доступа.

filepos (var f) : longint

Функция возвращает текущую позицию в файле f. Для только что открытого файла это будет 0.

filesize (var f) : longint

Функция возвращает количество блоков в открытом файле f.

seek (var f; n: longint)

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

truncate (var f)

Процедура устанавливает в текущей позиции признак конца файла и удаляет все последующие блоки.

program get_bfile;
var buf      : array[1 .. 4] of real;
    f        : file;
    i, k     : integer;
    filename : string;
begin
{$I–}
    writeln('Введите имя входного файла'); readln(filename);
    assign(f, filename);
    reset(f, sizeof(real) * 4);
    if IOResult <> 0 then begin
        writeln('Файл ', filename, ' не найден'); exit end;
{$I+}
    while true do begin    
        writeln('Введите номер записи или –1 для окончания'); 
        readln(k);
            if (k > filesize(f)) or (k < 0) then begin
                writeln('Такой записи в файле нет',); exit end;
        seek(f, k);
        blockread(f, buf, 1);
        for i:= 1 to 4 do write(buf[i]:6:1);
    end;
    close(f);
end.

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

Совместимость типов

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

Совместимость по присваиванию

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

Значение типа T1 является совместимым по присваиванию с типом T2 (то есть допустим оператор T1 := T2 ), если выполняется одно из следующих условий.

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