Типы и еще раз типы

Мы с вами уже изучили довольно много типов и всего, что с ними связано. На сегодня уже закрыты такие темы как работа с массивами (за искл. некоторых алгоритмов, которые мы еще изучим в практических выпусках), преобразование типов, списки стандартных типов

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

  • Записи (record)

  • Файловые типы;

  • Перечисляемые типы;

  • Определяемые пользователем типы;

  • Объекты (object);

  • Некоторые другие (указатели...)

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

Итак, сегодня мы начинаем изучение новых типов, а именно записей или, как они изображаются в Паскале record. Эта тема даст вам мощный инструмент, послужит отличным введением в объектно-ориентированное программирование, как следствие приблизит к программированию под Win32 и расширит ваши возможности как программистов.

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


Работа с записями

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

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

  • Программа может спрашивать и выдавать следующие данные:

  1. Фамилия, имя, отчество;

  2. Адрес: улица, дом;

  3. Телефон;

  4. E-mail;

  • Пусть количество адресатов будет ограничено 10ю адресами.

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

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

Здесь мы и подходим к понятию записей. На самом деле запись - это контейнер, в котором именно "записано" несколько переменных. Чем-то похоже на массив, только переменные могут быть разных типов, каждая из них имеет свое имя.

Для начала давайте определим типы для наших данных (адрес):

  • Fio: String; {фио}

  • Adress: String: {адрес}

  • Phone: LongInt; {телефон, в виде числа}

  • Email: String; {e-mail}

Как видите, переменных несколько, все они имеют имена и разных типов. Что же делать с такими данными? В принципе, можно эту задачу решить и с одними массивами - завести 4 массива соотв. типов и параллельно сохранять в них переменные. Но это делается гораздо проще, если пользоваться записями.

Запись - это способ объединения нескольких переменных разных типов в одной. Благодаря этому достигается замечательная упорядоченность данных, программы при этом упрощаются и становятся логичнее.

Итак, как же создать запись? Разложу все этапы создания записи по порядку.

В первую очередь обращаю внимание на то, что записи описываются в разделе type, который подобен известным нам разделам var или const. В этом разделе описываются все типы, определяемые пользователем.

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

type

AdressItem = Record

После описываются все переменные, которые будут содержаться в записи, подобно тому, как они описываются в разделе var. Завершается запись словом end;. Вот пример записи, необходимой для нашей программы:

type

AdressItem = Record

Fio: String;

Adress: String;

Phone: LongInt;

Email: String;

end;

Как видите, описать запись совсем не сложно. Кроме того, обращаю внимание, что создав в программе запись вы получаете новый тип и нужно создать переменные этого типа. Здесь тоже нет ничего сложного. После того, как вы опишете запись в разделе type, можно создать переменные нового типа в разделе var:

var

A,B: AdressItem;

И все. Теперь вы имеете две записи. Но две записи - это мало, по условию нам нужно 10 записей (у нас адресная книжка на 10 адресов). Нет ничего проще! Вспоминаем массивы и их возможности - объединение группы переменных одного типа. Вот и сделаем массив из созданной записи:

var

Book: Array [1..10] of AdressItem;

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

Существует два способа обращения к элементам записи. Пока немного отойдем от созданного массива и поработаем с такой переменной:

var

A: AdressItem;

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

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

var

A: AdressItem;

begin

with

A do

Write('ФИО: ');

Readln(Fio);

Write('Адрес: ');

Readln(Adress);

Write('Телефон: ');

Readln(Phone);

end;

end

.

Думаю, синтаксис констркукции with понятен:

  • with _имя_записи_ do

  • .... действия с ее полями (ее переменными) .....

  • end;

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

2. Итак, второй способ обращения к полям записи. Он еще проще и гораздо компактнее. Суть его в следующем:

  • · К полю записи можно обратиться, указав имя записи и через точку имя поля.

В нашем примере с записью A программа принимает следующий оборот:

var

A: AdressItem;

begin

Write('ФИО: ');

Readln( A.Fio );

Write('Адрес: ');

Readln( A.Adress );

Write('Телефон: ');

Readln( A.Phone );

end.

Это, на мой взгляд совсем просто. Теперь давайте ворнемся к нашей программе "Записная книжка" и к нашему массиву из записей. Перед тем, как подготовиться в написанию самой программы давайте посмотрим, как можно с помощью приведенных выше двух способов обратиться к полям записи, которая является элементов массива. У нас это массив Book (Книжка).

Способ первый - с помощью with. Читаем первый элемент массива Book:

  • With Book[1] do begin

  • Write('ФИО: ');

  • Readln(Fio );

  • Write('Адрес: ');

  • Readln(Adress );

  • Write('Телефон: ');

  • Readln(Phone );

  • end.

Способ второй - с помощью оператора "точка". Читаем первый элемент массива Book:

  • begin

    Write('ФИО: ');

    Readln(Book[1].Fio );

    Write('Адрес: ');

    Readln(Book[1].Adress );

    Write('Телефон: ');

    Readln(Book[1].Phone );

    end.

Разобрались? Надеюсь, что да. Поверьте, здесь нет ничего сложного. Если все-таки немножко непонятно, ничего страшного - дальше разберетесь.

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

Program Adress_Book;
uses Crt;
type
AdressItem = record
Fio: String;
Adress: String;
Phone: LongInt;
Email: String;
end;
var
Book: Array [1..10] of Adressitem;
Nums, I: Byte;
Code: Integer;
C: Char;
Quit: Boolean;
{ процедура добавления новой записи }
Procedure New_Item;
var
F, A, Em: String;
Ph: LongInt;
begin
ClrScr;
Inc(Nums);
if Nums > 10 then
begin
Write('Максимальное количество записей!');
exit; {выход из процедуры}
end;
Writeln('Запись N', Nums); Writeln;
Write('Введите ФИО: ');
Readln(F);
Write('Введите адрес: ');
Readln(A);
Write('Введите телефон: ');
Readln(Ph);
Write('Введите E-mail: ');
Readln(Em);
Writeln;
with Book[Nums] do
begin
Fio := F;
Adress := A;
Phone := Ph;
Email := Em;
end;
Write('Новая запись успешно добавлена!');
end;
{ процедура отображения данных отдельной записи }
Procedure List_Item(N: Byte);
begin
if N > Nums then
begin
Write('Неправильный номер записи');
exit; {выход из процедуры}
end;
With Book[N] do
begin
Writeln('Запись N', N); Writeln;
Writeln('ФИО: ', Fio);
Writeln('Aдрес: ', Adress);
Writeln('Tелефон: ', Phone);
Writeln('E-mail: ', Email);
Writeln;
end;
Readln;
end;
begin
Quit := False;
Nums := 0;
repeat
ClrScr;
Writeln('Программа "Записная книжка"');
Writeln('==========================='); Writeln;
Writeln('Записи: ');
Writeln('--------------------');
if Nums = 0 then Writeln('Записей нет. Книжка пуста.')
else
For I := 1 to Nums do
Writeln(I, ' - ФИО: ', Book[I].Fio);
Writeln('--------------------'); Writeln; Writeln;
Writeln('''a'' - добавить запись');
Writeln('Номер - показать запись');
Writeln('Esc - выход');
Writeln;
Write('Ваш выбор: ');
C := ReadKey;
case C of
'1'..'9': begin
Val(C, I, Code);
List_Item(I);
end;
'a': New_Item;
#27: Quit := true;
end;
until Quit;
end.

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

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

  • New_Item - добавляет новую запись;

  • List_Item - отображает одну из записей.

Остальное - это главный блок программы, раздел repeat - until. Теперь вкратце обо всех частях программы.

Во-первых, разберемся с переменными. Как Вы видите, их очень мало, кроме того - две вообще не имеют непосредственного отношения к программе. Это I (только для цикла), а также Code, которая используется лишь для возвращения кода возможной ошибки в процедуре Val (см. пред. выпуск).

Итак, вы видите, что в самом начале описана сама запись. Далее - создается массив Book, нового созданного типа AdressItem, то есть каждый его элемент - это запись AdressItem. Дальше - переменная Nums, которая содержит текущее количество записей в нашей адресной книге. Переменная C - это для выбора элемента меню. Quit: Boolean - проверка на выход. Цикл у нас идет как раз исходя из этой переменной. Если пользователь решил выйти из записной книжки, то Quit просто становиться true и основной цикл прекращается, программа останавливается.

Ну а теперь о процедурах. Первая - New_Item. Она демонстрирует работу по занесению значений в отдельную запись. В самом ее начале увеличивается переменная Nums, что означает добавление новой записи (на одну становиться больше). Кроме того, пере тем, как произвести увеличение этой переменной, проверяется - она больше 10? Если да, то достигнут максимум сообщений и больше добавлять нельзя, о чем процедура своевременно оповещает и завершает свою работу без выполнения дальнейших действий, для чего служит операция exit;

Дальше - читаются несколько переменных. После этого считанные значения заносятся в поля записи. Вот и все.

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

Ну а теперь о главном теле программы и ее основном цикле. В самом начале программы основным переменным присваиваются значения, порядка ради:

  • Quit := False; { это значит, что выхода пока нет }

  • Nums := 0; { записей нуль, книжка пуста }

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

  • Очищаем экран;

  • Распечатываем меню программы;

  • Распечатываем записи книжки в виде "N_записи - ФИО: _поле_Fio_записи_", то есть выводим список имеющихся имен. При этом, как видите, сначала проверяется переменная Nums и если она равна нулю (записей нет), то ничего печататься не будет, а выведется строка "Записей нет. Книжка пуста". И еще - обратите внимание, в этом действии я использую точку - Book[I].Fio - для обращения к полю записи, а не конструкцию With ... do. Здесь это гораздо удобнее.

  • Читается символ (Помните, функция ReadKey из модуля Crt не требует подтверждения ввода нажатием Enter.

  • В зависимости от того, чему равна эта переменная, вызывается определенная процедура, либо осуществляется выход.

Это все. Как видите, программа совершенно не сложная. Зато хорошо демонстрирует работу с записями.

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

В связи с этим формируется домашнее задание, которое вам необходимо выполнить для успешного освоения материала следующего выпуска. Оно заключается в том, чтобы добавить в эту книжку несколько новых функций. Присылать мне эти задания не нужно, это только для вас. НО: если вы их не выполните, то материал следующего выпуска понять будет довольно сложно, так как я НЕ БУДУ ПРИВОДИТЬ исходный код некоторых процедур, задаваемых на дом.

Итак, домашнее задание для самостоятельной работы:

  • Напишите процедуру УДАЛЕНИЯ ЛЮБОЙ ПО НОМЕРУ ЗАПИСИ из массива (подсказка: вспоминайте алгоритм сдвига элементов по массиву из пред. выпусков);

  • Добавьте возможность ПОИСКА ИНФОРМАЦИИ по всей записной книжке, то есть осуществите возможность найти телефон и посмотреть все его данные; найти телефон по ФИО; найти ФИО по адресу и т.п. (подсказка: вспоминайте работу со строками!)

  • В программе есть небольшая ошибка. Найдите и исправьте ее. Интересно, кто сообразит :))

Ну вот, собственно и все! Согласитесь, отличная это штука - ЗАПИСИ. Разве нет?



Опубликовал admin
16 Ноя, Воскресенье 2003г.



Программирование для чайников.