Реферат: Программирование на языке Турбо Паскаль

  for ch:=#32 to #255 do write(ord(ch),'—>',ch,'  ');

  readln;

end.

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

С использованием кодов работают ещё две функции, значения которых символьные:

1.   succ (от succeedent — последующий), она выдаёт символ со следующим кодом.

2.   pred (от predecessor — предшественник), выдаёт символ с предыдущим кодом.

Если попытаться в программе получить succ(#255) или pred(#0), то возникнет ошибка. Пользуясь этими функциями можно переписать предыдущую программу и по-другому:

...

ch:=#32;

while ch<>#255 do begin

  write(ord(ch),'—>',ch,'  ');

  ch:=succ(ch);

end;

...

Сравнение символов. Также как и числа, символы можно сравнивать на =, <>, <, >, <=, >=. В этом случае Паскаль сравнивает не сами символы, а их коды. Таблица ASCII составлена таким образом, что коды букв (латинских и большинства русских) возрастают при движении в алфавитном порядке, а коды цифр расположены по порядку: ord(‘0’)=48, ord(‘1’)=49, ... ord(‘9’)=57. Сравнения символов можно использовать везде, где требуются логические выражения: в операторе if, в циклах и т.п.

2. Строковый тип

Для хранения строк (то есть последовательностей из символов) в Турбо-Паскале имеется тип string. Значениями строковых переменных могут быть последовательности различной длины (от нуля и более, длине 0 соответствует пустая строка). Объявить строковую переменную можно двумя способами: либо var s: string; (максимальная длина строки — 255 символов), либо var s: string[n]; (максимальная длина — n символов, n — константа или конкретное число).

Для того чтобы положить значение в строковую переменную используются те же приёмы, что и при работе с символами. В случае присваивания  конкретной строки, это строка должна записываться в апострофах (s:='Hello, world!'). Приведём простейший пример со строками: программа спрашивает имя у пользователя, а затем приветствует его:

program Hello;

var s: string;

begin

  write('Как Вас зовут: ');

  readln(s);

  write('Привет, ',s,'!');

  readln;

end.

Хранение строк. В памяти компьютера строка хранится в виде последовательности из символьных переменных, у них нет индивидуальных имён, но есть номера, начинающиеся с 1). Перед  первым символом строки имеется ещё и нулевой, в котором хранится символ с кодом, равным длине строки. Нам абсолютно безразлично, какие символы хранятся в байтах, находящихся за пределами конца строки. Рассмотрим пример. Пусть строка s объявлена как string[9], тогда после присваивания s:=’Привет’; она будет хранится в следующем виде:

Для того чтобы в программе получить доступ к n-му символу строки используется запись s[n]. Если поменять значение s[0] то это отразится на длине строки. В следующем примере из строки 'Привет' мы сделаем 'Привет!': s[0]:=#7; s[7]:='!';.

Сравнение строк. Строки сравниваются последовательно, по символам. Сравниваются первые символы строк, если они равны — то вторые, и т. д. Если на каком-то этапе появилось различие в символах, то меньшей будет та строка, в которой меньший символ. Если строки не различались, а затем одна из них закончилась, то она и считается меньшей. Примеры: 'ананас'<'кокос', 'свинья'>'свинина', ''<'A', 'hell'<'hello'.

Склеивание (конкатенация) строк. К строкам можно применять операцию «+», при этом результатом будет строка, состоящая из последовательно записанных «слагаемых». Пример: после действия s:= 'abc'+'def'+'ghi'; переменная s будет содержать ‘abcdefghi’.

Процедуры и функции для работы со строками. Наиболее часто употребляется функция length(s: string): integer (после двоеточия записан тип значения, возвращаемого функцией, в нашем случае — целое число). Эта функция возвращает длину строки s.

Другие процедуры и функции приведены в таблице:

Лекция 6. Перечисляемый и ограниченный типы

1. Перечисляемый тип

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

type Days = (Mon, Tue, Wed, Thu, Fri, Sat, Sun);

После этого можно завести переменную этого типа (var day: Days;) и использовать её. Ниже приведены примеры использования:

day:=Wed;

...

if day>Fri then writeln('Сегодня выходной');

...

if day=Mon then writeln('Началась рабочая неделя');

Как вы уже заметили значения перечислимого типа можно сравнивать, при этом меньшим считается то, которое объявлено раньше (левее) в определении типа.

Для переменных перечисляемых типов возможно применение функций succ и pred, например, succ(Wed) дает Thu, Pred(Sun) дает Sat. Если попытаться написать Pred(Mon) или Succ(Sun), то уже на этапе проверки программы компилятором произойдет ошибка.

Хранение значений перечисляемого типа устроено внутри довольно просто: хранятся целые числа от 0 до n, в нашем случае n=6. Существует функция Ord, которая позволяет получить то число, в виде которого хранится какое-либо значение перечисляемого типа, например Ord(Wed) дает 2. При необходимости можно получить значение перечисляемого типа по его численному представлению, например, Days(1) есть Tue. После всего сказанного можно заметить, что при сравнении величин перечисляемого типа в действительности сравниваются их порядковые номера (Ord).

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

Пусть корабль может двигаться только по четырем направлениям: на север, на запад, на юг и на восток, то есть текущее направление движения определяется переменной типа Directions = (North, West, South, East);. Этому кораблю можно подавать приказы следующих типов: вперёд, назад, влево, вправо, то есть любой приказ задать переменной типа Orders = (Ahead, Back, Left, Right);. Пусть корабль двигался по направлению d1, после чего ему дали приказ p. Программа должна определить, в каком направлении корабль будет двигаться после выполнения приказа.

program Ship;

type Courses = (North, West, South, East);

     Orders  = (Ahead, Back, Left, Right);

var d1, d2: Courses;

    p: Orders;

    i: integer;

    s: string;

begin

  {Запрашиваем у пользователя информацию о курсе и приказе}

  writeln('Введите первоначальный курс корабля ');

  write('(0-север, 1-запад, 2-юг, 3-восток) ');

  readln(i);

  d1:=Courses(i);

  writeln('Введите приказ, данный кораблю ');

  write('(0-прямо, 1-назад, 2-влево, 3-вправо) ');

  readln(i);

  p:=Orders(i);

  {Определяем новый курс}

  case p of

    Ahead : d2:=d1;

    Back  : d2:=Courses((ord(d1)+2) mod 4);

    Left  : d2:=Courses((ord(d1)+1) mod 4);

    Right : d2:=Courses((ord(d1)+3) mod 4);

            {-1 - нельзя, так как (Ord(North)-1) mod 4 = -1}

  end;

  {Выводим результат на экран}

  case d2 of

    North : s:='север';

    West  : s:='запад';

    South : s:='юг';

    East  : s:='восток';

  end;

  writeln('Теперь корабль движется на '+s);

  readln;

end.

2. Ограниченный тип

Этот тип также рассмотрим на примере. Пусть в некоторой переменной нужно хранить текущее число, то есть номер дня в месяце. В Турбо Паскале можно задать тип DaysInMonth = 1..31;. Переменные и константы этого типа могут принимать только такие значения, если попытаться задать что-либо другое, то компилятор выдаст ошибку. В качестве границ могут употребляться и отрицательные числа, например Temperature=-60..50;

В качестве базового типа (то есть типа, из которого выбирается диапазон значений) могут использоваться почти все порядковые типы, то есть те, которые хранятся в виде целых чисел. К порядковым типам относятся: все целые типы (byte, integer, и т. п.), char, boolean, перечисляемые типы и ограниченные типы. В качестве базового типа нельзя использовать лишь сам ограниченный тип (трудно представить, как это можно сделать). С учетом этого правила допустимы такие объявления типов:

type SmallLatin = 'a'..'z';    {малые латинские буквы}

     MyBoolean  = True..False; {хотя это и бессмысленно}

     Holidays   = Sat..Sun;    {выходные}

Нельзя в качестве базового типа употребить какой-либо вещественный тип, следующее объявление приведет к ошибке:

type Wrong = -1.25..1.25;

Заметим, что функции Ord, Succ и Pred могут применяться к любым порядковым типам, и, в частности, к ограниченным.

Лекция 7. Массивы

1. Понятие массива. Одномерные массивы

Массивы являются представителями структурированных типов данных, то есть таких, переменные которых составлены из более простых элементов согласно определённому порядку. Для массивов характерно то, что они являются совокупностью некоторого числа одинаковых элементов. В простейшем случае эти элементы могут быть занумерованы натуральными числами из некоторого диапазона. Рассмотрим пример такой переменной в Турбо Паскале:

var a: array [1..10] of real;

Переменная a состоит из десяти ячеек типа real, можно записывать и извлекать значения из них, пользуясь записью a[<номер ячейки>].

Пример 1. Поиск наибольшего числа среди элементов массива.

program FindMaximumInArray;

var a: array[1..10] of real;

    i,max: integer;

begin

  for i:=1 to 10 do begin

    write('Введите элемент номер ',i,' -> ');

    readln(a[i]);

  end;

  max:=a[1];

  for i:=2 to 10 do

    if a[i]>max then max:=a[i];

  writeln('Максимум равен ',max);

  readln;

end.

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

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

var Numbers: array [0..1000] of integer;

    Names: array [1..10] of string;

    Crit: array[shortint] of boolean;

    CountAll: array[char] of integer;

    Count: array['a'..'z'] of integer;

В следующем примере показано для чего может понадобиться последний тип.

Пример 2. Подсчет количества различных букв в строке.

program CountLetters;

var s: string;

    count: array['a'..'z'] of byte;

    ch: char;

    i: byte;

begin

  write('Введите строку > ');

  readln(s);

  for i:=1 to length(s) do

    if (s[i]>='a')and(s[i]<='z') then inc(count[s[i]]);

  writeln('Количество различных букв в строке: ');

  for ch:='a' to 'z' do

    if count[ch]<>0 then

      writeln(ch,': ',count[ch]);

  readln;

end.

2. Многомерные массивы

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

Примеры описаний многомерных массивов:

var Matrix: array[1..4,1..3] of real;

    Cube3D: array[1..5,1..5,1..5] of integer;

Рассмотрим пример использования двумерного массива.

Пример 3. Построить календарь на следующий год, то есть при вводе номера месяца и числа выдавать день недели.

program Calendar;

type tWeekDay = (Mon,Tue,Wed,Thu,Fri,Sat,Sun,NoDay);

                {NoDay - нет дня (например, 30.02)}

     tCalendar = array [1..12,1..31] of tWeekDay;

var CL: tCalendar;

    m,d: byte;    {месяц и число}

    wd: tWeekDay; {день недели}

begin

  {Строим массив:}

  {1. Заполним весь календарь значениями "нет дня":}

  for m:=1 to 12 do

    for d:=1 to 31 do CL[m,d]:=NoDay;

  {2. Строим массив-календарь:}

  m:=1; d:=1;

  wd:=Mon;

  repeat

    CL[m,d]:=wd;

    case m of

      4,6,9,11:        if d=30 then begin m:=m+1; d:=1; end else d:=d+1;

      1,3,5,7,8,10,12: if d=31 then begin m:=m+1; d:=1; end else d:=d+1;

      2:               if d=28 then begin m:=m+1; d:=1; end else d:=d+1;

    end;

    wd:=tWeekDay((ord(wd)+1) mod 7);

  until m=13;

  {Выводим на экран:}

  repeat

    write('Номер месяца > '); readln(m);

    write('Число > '); readln(d);

    case CL[m,d] of

      Mon:   writeln('Понедельник');

      Tue:   writeln('Вторник');

      Wed:   writeln('Среда');

      Thu:   writeln('Четверг');

      Fri:   writeln('Пятница');

      Sat:   writeln('Суббота');

      Sun:   writeln('Воскресенье');

      NoDay: writeln('Такого дня нет в календаре');

    end;

  until false;

end.

3. Сортировка и поиск

В прикладных программах широко распространены два типа операций, связанных с массивами:

1.   Упорядочивание элементов массива по возрастанию или убыванию (сортировка)

2.   Поиск элемента в массиве.

Рассмотрим простейший вариант сортировки массива (сортировка выбором). Пусть есть массив из n элементов; сначала найдём в нём самый маленький среди элементов с номерами 2,3,...n и поменяем местами с первым элементом, затем среди элементов с номерами 3,4,...n найдём наименьший и обменяем со вторым, и т. д. В результате наш массив окажется отсортированным по возрастанию.

program SelectSort;

const n = 10;

var a: array [1..n] of integer;

    i,j,jmin,buf: integer;

    {jmin - номер наименьшего элемента,

     buf используется при обмене значений двух элементов}

begin

  for i:=1 to 10 do begin

    write('Введите элемент номер ',i,' -> ');

    readln(a[i]);

  end;

  for i:=1 to n-1 do begin

    jmin:=i;

    for j:=i+1 to n do

      if a[j]<jmin then jmin:=j;

      buf:=a[i];

      a[i]:=a[jmin];

      a[jmin]:=buf;

  end;

  write('Результат: ');

  for i:=1 to 10 do write(a[i],' ');

  readln;

end.

Другой способ — пузырьковая сортировка, он работает чуть быстрее, чем предыдущий. На первом этапе двигаемся от n-го элемента до 2-го и для каждого из них проверяем, не меньше ли он предыдущего; если меньше, то меняем местами текущий и предыдущий. В итоге первый элемент будет наименьшим в массиве. На втором этапе также проходим элементы от n-го до 3-го, на третьем — от n-го до 4-го, и т. д. В итоге массив будет отсортирован по возрастанию.

program BubbleSort;

...

var i,j: integer;

    buf: integer;

begin

  ...

  for i:=2 to n do

    for j:=n downto i do

      if a[j]<a[j-1] then begin

        buf:=a[j];

        a[j]:=a[j-1];

        a[j-1]:=buf;

      end;

end.

Лекция 8. Тип запись

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

type tPerson = record

        Name,Surname,SecondName: string[30];

        Male: boolean;

        Address: string;

        Phone: longint;

     end;

Объявление переменной типа запись выполняется стандартно, с помощью var. Части записи (в нашем случае: Name, Surname, SecondName, Male, Address, Phone) называются полями. Обращение к полю записи в программе производится с помощью знака ‘.’ (точка). Пример обращения к полям:

var p: tPerson;

...

begin

  ...

  p.Surname:=’Иванов’;

  p.Name:=’Иван’;

  p.SecondName:=’Иванович’;

  ...

  if (p.Phone<0) or (p.Phone>999999)

    then writeln(‘Ошибка’);

  ...

end.

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

with <имя_записи> do <оператор>;

Чаще всего в качестве оператора используется составной оператор.

Пример:

with p do begin        

  Surname:=’ Иванов’;

  Name:=’Иван’;

  ...

end;

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

const N = 30;

type  tStaff = array [1..N] of tPerson;

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

type  tPoint = record

         x,y: integer;

      end;

      tRectangle = record

         LeftTop: tPoint;

         Width, Height: integer;

         Color: integer;

      end;

Для такой записи можно применять ещё одну форму оператора with, которая может «присоединять» несколько имён записей, например:

var rect: tRect;

with rect, LeftTop do begin

  x:=100;

  y:=150;

  Color:=11;

  ...

end;

Без использования with появились бы выражения вида rect.Color, rect.LeftTop.x, rect.LeftTop.y и т. п.

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

const MaxVertex = 200;

type  tPolygon = record

         size: integer;

         V: array [1..MaxVertex] of tPoint;

         Color: tColor;

      end;

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

Страницы: 1, 2, 3, 4, 5