Песни о Паскале (СИ)

Текст добавлен: 6 ноября 2017, 03:30

Текст книги "Песни о Паскале (СИ)"

Автор книги: Олег Деревенец

Жанр:

Драматургия

сообщить о нарушении

Текущая страница: 11 (всего у книги 29 страниц)

Назад к карточке книги

repeat Read(InFile, sym); until Ord(sym)>32;

{ чтение последующих символов }

repeat

s:= s+sym;

if Eoln(InFile) then Break;

Read(InFile, sym);

until not ((Ord(sym)>32));

ReadFam:= S;

end;

{– Процедура обработки строки –}

procedure HandleString;

var N : integer; { оценка, прочитанная из файла }

Cnt: integer; { количество оценок }

Sum: integer; { сумма баллов }

Rating: Real; { средний балл }

Fam: string; { фамилия }

begin

Fam:= ReadFam; { читаем фамилию }

{ для выравнивания столбцов добавляем пробелы }

while Length(Fam) < 12 do Fam:= Fam + ' ';

Sum:=0; Cnt:=0; { очищаем накопитель и счетчик оценок }

While not Eoln(InFile) do begin { пока не конец строки }

Read(InFile, N); { читаем оценку в переменную N }

Sum:= Sum+N; { накапливаем сумму баллов }

Cnt:= Cnt+1; { наращиваем счетчик оценок }

end;

if Cnt>0

then begin { если оценки в четверти были }

Rating:= Sum / Cnt; { вычисляем и печатаем ср. балл }

Writeln(OutFile, Counter:3, Fam:18, Cnt:8,

Sum:14, Rating:11:1);

end

else { а если оценок не было }

Writeln(OutFile, Counter:3, Fam:18,' : Ученик не аттестован');

end;

begin {– Главная программа –}

Counter:= 0; { обнуляем счетчик строк }

{ открываем входной файл }

Assign(InFile,'Journal2.in'); Reset(InFile);

{ создаем выходной файл }

Assign(OutFile,'Journal2.out'); Rewrite(OutFile);

{ выводим шапку таблицы }

Writeln(OutFile, 'Номер Фамилия Количество Сумма Средний');

Writeln(OutFile, ' оценок баллов балл');

{ пока не конец входного файла… }

while not Eof(InFile) do begin

Counter:= Counter+1; { наращиваем счетчик строк }

HandleString; { обрабатываем строку }

{ переход на следующую строку }

if not Eof(InFile) then Readln(InFile);

end;

{ закрываем оба файла }

Close(InFile); Close(OutFile);

end.

Итоги

• Для чтения отдельного слова в строке файла не годятся ни оператор Readln (он прочитает всю строку), ни оператор Read, который не видит конца строки. Слово читается посимвольно оператором Read с отслеживанием признака окончания строки и других условий.

• Строку выходного файла можно формировать порциями, применяя несколько вызовов процедуры Write. Каждый такой вызов формирует часть строки и продвигает позицию записи, оставляя её в текущей строке. Для перехода к следующей строке вызывается процедура Writeln.

А слабо?

А) Напишите программу для преобразования первого варианта базы данных «Police.txt» (которая содержит по одному числу в строке) во второй вариант (будет содержать по три числа в строке).

Б) Файл с физическими данными старшеклассников содержит три колонки: фамилия, рост и вес ученика. Создайте программы для решения следующих задач:

• отбор кандидатов для занятий баскетболом, – рост кандидата должен составлять не менее 175 см;

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

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

Глава 32

Порядковые типы данных

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

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

Типы данных: простые и сложные

Кто из вас видел «предметы вообще»? Также не бывает и «данных вообще», – они обязательно принадлежат к тому либо иному типу. Учреждая переменную, параметр или функцию, потрудитесь сообщить их тип компилятору, иначе он не уяснит, сколько памяти отвести для этих данных и что позволено совершать с ними.

На рис. 73 представлены почти все типы данных, встроенные в язык Паскаль. Их принято делить на три категории: простые, сложные и указатели. К настоящему моменту вы знакомы со многими простыми типами данных и одним сложным – строковым типом String.

Чем разнятся сложные типы от простых? Тем ли, что сложные труднее изучать? Отчасти так, но суть не в этом. Сложные типы обладают внутренней структурой, в которой выделяются отдельные элементы. Так, например, можно выделить отдельные символы в строке. Простые же типы данных не «раскалываются» на мелкие детали.

А указатели? Их применяют для доступа к данным других типов. Указатель чем-то похож на адрес электронной почты или на гиперссылку, в свое время я расскажу об указателях все.

Рис.73 – Типы данных языка Паскаль

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

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

Целое братство

Целые числа образуют дружную «семью» из нескольких братьев. Вам пока знаком лишь один из них – это тип Integer, а где остальные? Начнем с двух младших братьев: типов Byte и ShortInt.

Изучая символы, мы узнали, что они кодируются целыми числами. Основной набор составляют 256 символов с кодами от 0 до 255 включительно. Этот диапазон значений может храниться в ячейке памяти, называемой байтом (BYTE). Байт – это наименьшая порция данных, адресуемая в памяти компьютера. Вы знаете, что байтом названа и единица измерения информации. Мог ли язык Паскаль пренебречь этим фактом? Нет, и ещё раз нет! В Паскале существует тип данных, который так и называется – Byte. Переменные типа Byte объявляются так:

var A, B, C : byte;

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

Перейдем к брату-близнецу байта – коротышке ShortInt. Его имя расшифровывается как Short Integer – «короткое целое». Почему близнец? А потому, что он тоже занимает один байт памяти, но вмещает другой диапазон чисел – от минус 128 до плюс 127. Вместе с нулем получаются те же 256 значений. Этот тип данных тоже введен для экономии памяти. В самом деле, к чему тратить лишнюю память на переменные, хранящие маленькие числа? Отведем им один байт, только кодировать будем так, чтобы половина значений стала отрицательной. Так родился близнец-коротышка ShortInt.

Понятно, что ёмкости младших братьев хватает далеко не всегда, – даже количество дней в году не помещается в байтовой переменной. Для действий с более крупными числами программист обращается к средним братьям: типам Integer и Word. Каждый из них занимает по два байта памяти. Но если тип Integer вмещает диапазон чисел от минус 32768 до плюс 32767 (справедливо для Borland Pascal), то для типа Word диапазон сдвинут в положительную область и составляет от 0 до 65535. Кстати, название этого типа чисел – Word – переводится как «слово». Оно восходит ко временам 16-разрядных мини-ЭВМ, где длина так называемого машинного слова составляла два байта.

Когда не хватает ёмкости средних братьев, программисты зовут старшего – четырехбайтовый тип LongInt (Long Integer – «длинное целое»). Этот тип данных вмещает числа, превышающие два миллиарда. В табл. 2 представлены целочисленные типы данных языка Паскаль.

Примечание. Размеры и ёмкость целочисленных типов зависят от компилятора и его настроек. Так, в 32-разрядном компиляторе Delphi типы Integer и LongInt совпадают и представлены 4-мя байтами, а также имеется 8-байтовый тип Int64.

Табл. 2 – Целочисленные типы данных (для Borland Pascal)

Тип данных

Размер в байтах

Диапазон возможных значений

От

До

Byte

255

Shortint

–128

127

Word

65535

Integer

–32768

32767

Longint

–2147483648

2147483647

Хорошо, ну а если и ёмкости LongInt недостаточно? Неужели это предел? Конечно, нет. Но рассмотренных целочисленных типов хватает в большинстве случаев, где требуется точный подсчет. Подчеркиваю ещё раз – точный. Вещественные числа, о которых я расскажу в следующей главе, вмещают огромные значения, но представляют их приближенно. Для точного представления громадных чисел используют сложные типы данных.

Капля, переполняющая чашу

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

{$R+ – включить проверку диапазонов }

var N : byte;

begin

N:= 255; { 255 – максимальное значение для байта }

N:= N+1;

Writeln(N); Readln;

end.

Введите и откомпилируйте эту программу. В первой её строке вставлена директива, разрешающая компилятору следить за диапазонами числовых переменных. Эта директива соответствует флажку «Range checking» в окне опций компилятора (рис. 74).

Рис.74 – Окно опций компилятора

Запуск программы приведет к сообщению об ошибке «Runtime Error 201». Это значит, что попытка превысить диапазон для байтовой переменной, вызвала аварию программы.

Теперь измените директиву в первой строке, отключив проверку диапазонов (замените знак «+» знаком «–»).

{$R– – отключить проверку диапазонов }

Этот вариант программы не выдаст сообщений об ошибке, но результат ошеломит вас – это будет ноль! Вот так чаша! Числовая переменная оказалась необычной посудой, – лишняя капля полностью опустошила её! И теперь можно вновь заполнять пустую чашу. Убедитесь в этом, поменяв единицу на другое слагаемое, например 5, – в результате сложения получится 4. Открытое нами явление называют переполнением (по-английски – OVERFLOW).

В следующем опыте запустим такую программу.

{$R– – отключить проверку диапазонов }

var N : byte;

begin

N:= 0; { 0 – минимальное значение для байта }

N:= N-1;

Writeln(N); Readln;

end.

Результат ещё удивительней: теперь программа напечатает число 255! То есть, удалив из пустой чаши несуществующую каплю, мы наполнили её доверху! Этот фокус называют антипереполнением, то есть переполнением наоборот.

Проделав опыты с переменными других числовых типов, вы убедитесь, что переполнение и антипереполнение может постигнуть любую из них. Так, добавление единицы к положительному числу 32767 в переменной типа INTEGER дает отрицательный результат -32768. Отсюда следует общее правило: добавление единицы к максимальному значению для числового типа дает минимальное значение. И наоборот: вычитание единицы из минимального значения дает максимальное. Рис. 75 наглядно показывает это.

Рис.75 – Изменение числовых переменных при переполнении и антипереполнении

Такая вот чудная арифметика! Причина переполнений и антипереполнений кроется в устройстве регистров процессора, – в свое время мы узнаем о них больше при изучении двоичной системы счисления. Или вспомните одометр – прибор для подсчёта пробега автомобиля: по достижении предельного количества километров (99999) одометр сбрасывается в ноль.

Сейчас важно понять, что присвоение переменной некоторого выражения не гарантирует правильного результата, – он будет верным лишь при отсутствии переполнений и антипереполнений. Когда в вычислении участвуют переменные разных типов, оно выполняется в самом емком формате, то есть в Longint, а затем результат «обрубается» в соответствии с типом принимающей переменной, например:

{ $R– }

var B: Byte; S: ShortInt; W: Word; N: Integer;

...

N:= B + S + W;

Здесь даже при положительных значениях всех суммируемых операндов, результат в переменной N может оказаться отрицательным! Если вам не по нраву такое поведение программы, включайте директиву проверки диапазонов $R+.

Инкремент и декремент

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

procedure Inc (var N : longint); { прибавление единицы к переменной N }

procedure Dec (var N : longint); { вычитание единицы из переменной N }

Хотя параметр N в процедурах объявлен как LONGINT, в действительности здесь может стоять переменная любого порядкового типа: INTEGER, WORD, BYTE, CHAR и даже BOOLEAN.

var B: byte; N: integer; C: char;

...

Inc(B); { B:= B+1 }

Dec(N); { N:= N–1 }

C:= ‘A‘; Inc(C); { ‘B‘}

Процедуры инкремента и декремента – так их называют – выполняются быстрее операторов присваивания N:=N+1 и N:=N-1.

Работающим в IDE Borland Pascal, следует учесть, что здесь процедуры инкремента и декремента не подвластны директиве $R+ (в отличие от сложения и вычитания). То есть, переполнения и антипереполнения не вызывают аварий.

Диапазоны

Контроль переполнений директивой $R+ повышает надежность программ. Но порой нужны более сильные ограничения. Предположим, некая переменная M по смыслу является порядковым номером месяца в году. Стало быть, её значения должны быть ограничены диапазоном от 1 до 12. Программист может указать это компилятору, объявив переменную как диапазон, и явно задав допустимые пределы её изменения:

var M : 1..12;

Диапазон выражается двумя константами: минимальным и максимальным значениями, разделенными двумя точками. Теперь, при включенной директиве $R+, будет выдано сообщение об ошибке при попытке присвоить этой переменной любое значение за пределами 1…12. Во всем прочем диапазон – это обычный целочисленный тип (в данном случае – однобайтовый).

Перечисления

Рассмотрим ещё пример.

var M : 1..12; { месяцы }

D : 1..7; { дни недели }

…

M:= D; { здесь возможна смысловая ошибка }

Здесь объявлены две переменные: M – номер месяца в году, и D – номер дня недели. Это сделано через диапазоны, что гарантирует соблюдение границ. Но ничто не мешает нам присвоить месяцу значение дня, – ведь это не нарушит установленных пределов. Другое дело – смысл. Есть ли смысл в таком присваивании, или налицо ошибка программиста? Вероятней всего – последнее. Выявить ошибки такого рода помогает ещё один тип данных – перечисление.

Перечислением программист дает имена всем возможным значениям переменных, эти имена перечисляются внутри круглых скобок. Например, переменные M1 и M2 могут быть объявлены через сокращенные названия месяцев, а переменные D1 и D2 – через сокращенные названия дней недели.

var M1, M2 : (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dcb);

D1, D2 : (Mond, Tues, Wedn, Thur, Frid, Satu, Sund);

Теперь компилятор разрешит присваивать переменным только объявленные значения, например:

M1:= Apr; { допустимо }

M1:= M2; { допустимо }

M1:= 3; { ошибка }

M1:= Jan+2; { ошибка }

D2:= M1; { ошибка }

Кстати, один из перечислимых типов вам знаком – это булев тип. Объявление булевой переменной равнозначно объявлению перечисления.

var B : ( FALSE, TRUE ); { равнозначно B : Boolean; }

Имена в перечислениях – это не строковые константы. Поэтому имя Jan и строка «Jan» совсем не одно и то же. Иначе говоря, оператор Write(M1) не напечатает вам название месяца, который содержится в переменной M1. Вы спросите, а как же печать булевых данных? Ведь они печатаются как «TRUE» и «FALSE». Да, но это единственное исключение.

Порядковые типы

Итак, вы познакомились с пятью числовыми типами данных, диапазонами и перечислениями. Вместе с булевым и символьным типами они составляют семейство порядковых типов данных, а значит, имеют общие свойства и области применения. Рассмотрим их.

Определение порядкового номера

Название «порядковый» говорит о том, что значения этих типов данных упорядочены относительно друг друга. С числами все ясно, – здесь порядок очевиден. А символы? Если вспомнить алфавит и таблицу кодировки символов, вопрос отпадет.

Хорошо, а как насчет перечислений и булевого типа? Оказывается, в памяти компьютера они тоже хранятся как числа. Например, упомянутое выше перечисление месяцев в памяти компьютера кодируется числами 0, 1, 2 и так далее, то есть как числовой диапазон 0..11. Таким образом, значение Jan соответствует нулю, Feb – единице и так далее. Подобным образом кодируются и булевы данные: FALSE – нулем, а TRUE – единицей.

В Паскале есть функция, определяющая числовой код данных любого порядкового типа. Она называется Ord (от Order – «порядок»), вот примеры её применения (в комментариях указаны результаты).

Writeln ( Ord(5) ); { 5 }

Writeln ( Ord(’F’) ); { 70 – по таблице кодировки}

Writeln ( Ord(Mar) ); { 2 – смотри перечисление месяцев }

Writeln ( Ord(False) ); { 0 }

Writeln ( Ord(True) ); { 1 }

Для числа функция возвращает само число, для символа – код по таблице кодировки, а для перечислений – порядковый номер в перечислении, считая с нуля.

Сравнение

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

if M2 > M1 then … { если второй месяц больше первого }

if D1 = D2 then … { если дни совпадают }

Нельзя сравнивать данные разных перечислимых типов.

if M2 > D1 then … { месяц и день – недопустимо }

if 'W' > 20 then … { символ и число – недопустимо }

Но любые типы можно сравнить, приведя их к числовому типу.

if Ord(M2) = Ord(D1) then … { сравниваются числовые коды }

if Ord(’W’) > 20 then … { сравнивается код символа с числом }

Прыг-скок

Итак, числа, символы, булевы данные, диапазоны и перечисления принадлежат к порядковым типам. В общем случае наращивать и уменьшать порядковые переменные путём сложения и вычитания нельзя (можно лишь числа и диапазоны). Но рассмотренные ранее процедуры инкремента (INC) и декремента (DEC) умеют это делать, они были введены в Паскаль фирмой Borland. Другим таким средством являются функции SUCC и PRED, которые существовали ещё в исходной «виртовской» версии языка.

Функция SUCC (от слова SUCCESS – «ряд», «последовательность») принимает значение порядкового типа и возвращает следующее значение того же самого типа, например:

Writeln ( Succ(20) ); { 21 }

Writeln ( Succ(’D’) ); { ’E’ }

Writeln ( Succ(False) ); { True }

m:= Succ(Feb); { переменной m присвоено Mar }

Функция PRED (от PREDECESSOR – «предшественник») возвращает предыдущее значение порядкового типа:

Writeln ( Pred(20) ); { 19 }

Writeln ( Pred(’D’) ); { ’C’ }

Writeln ( Pred(True) ); { False }

m:= Pred(Feb); { переменной m присвоено Jan }

Функции SUCC и PRED подчиняются директиве контроля диапазонов $R+. Например, следующие операторы вызовут аварийное прекращение программы:

{ $R+ }

m:= Succ(Dcb); { превышение верхнего предела }

m:= Pred(Jan); { выход за нижний предел }

В Borland Pascal есть одна тонкость: директива $R+ не действует, если функции SUCC и PRED вызываются для чисел, например:

{ $R+ }

var B : byte;

...

B:=255; B:= Succ(B); { нет реакции на переполнение }

B:=0; B:= Pred(B); { нет реакции на антипереполнение }

В таких случаях в Borland Pascal имеет силу директива проверки переполнения $Q+, которая соответствует флажку «Overflow Checking» в окне опций компилятора (рис. 74). Директивы $R+ и $Q+ можно применять совместно, например:

{ $R+, Q+ }

var B : byte; { допустимые значения для байта от 0 до 255 }

C : ’a’..’z’; { это ограниченный диапазон символов }

...

C:=’z’; C:= Succ(C); { сработает R+ }

B:=255; B:= Succ(B); { сработает Q+ }

Счетчики циклов

В операторе FOR-TO-DO для счетчика цикла мы применяли числовые переменные. Теперь разнообразим меню: ведь для этого годятся переменные любого порядкового типа, например:

var m : (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dcb);

...

for m:= Jan to Dcb do...

А вот так вычисляется сумма кодов для символов от «a» до «z», здесь счетчиком цикла является символьная переменная:

var Sum : word; Chr : char;

...

Sum:=0;

for Chr:= ’a’ to ’z’ do Sum:= Sum + Ord(Chr);

Метки в операторе выбора

Вот ещё одно следствие числового кодирования: любой порядковый тип может служить меткой в операторе CASE-OF-ELSE-END:

var c : char;

...

Case c of

’0’..’9’: Writeln(’Цифра’);

’a’..’z’: Writeln(’Латинская строчная’);

’A’..’Z’: Writeln(’Латинская заглавная’);

end;

А вот ещё пример.

type TMonth = (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dcb);

var m : TMonth; { здесь хранится один из месяцев }

...

Case m of

Jan, Feb, Dcb : Writeln(’Зима’);

Mar..May : Writeln(’Весна’);

Jul..Aug : Writeln(’Лето’);

Sep..Nov : Writeln(’Осень’);

end;

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

Разумный контроль

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

Итоги

• Существуют три категории типов данных: простые, сложные и указатели.

• Простые типы данных делятся на порядковые и вещественные.

• К порядковым типам относятся целые числа, символы, перечисления и булевы данные.

• Целые числа представлены пятью типами, которые отличаются размерами и диапазонами.

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

• При включенной директиве $R+ нарушение диапазона приводит к аварии программы, а при отключенной – к переполнению или антипереполнению.

• Функцией ORD можно определить код любого значения порядкового типа.

• Переход к следующему или предыдущему значению порядкового типа выполняется функциями SUCC и PRED.

• Для быстрого прибавления и вычитания единицы предпочтительней применять процедуры INC и DEC.

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

А слабо?

А) Напомню, что функция SizeOf возвращает объём памяти, занимаемый переменной, например:

Writeln( SizeOf( LongInt ) ); { 4 }

Writeln( SizeOf( M1 ) ); { 1 }

Воспользуйтесь ею для распечатки размеров всех известных вам порядковых типов данных.

Б) Перечислимые типы и диапазоны строятся на базе других типов данных (Byte, ShortInt и так далее). Какие типы данных, по вашему мнению, будут положены в основу следующих диапазонов:

var N : -10..10;

M : -200..200;

R : 0..40000;

L : 0..400000;

S : ’0’..’9’;

В) Процедура печати Writeln не способна распечатать название месяца, представленного в перечислении. Напишите для этого свою собственную процедуру (объявите тип TMonth и воспользуйтесь оператором CASE).

Г) «Не думай о секундах свысока…». Штирлицу подарили секундомер, который показывал секунды, прошедшие с начала суток. Пусть ваша программа переведёт это число в привычные часы, минуты и секунды.

Подсказки: во-первых, примените операции DIV и MOD. Во-вторых, переменную для секунд объявите как LONGINT (а не INTEGER), поскольку количество секунд в сутках (86400) не поместится в типе INTEGER.

Глава 33

Вещественные числа

Почему так несовершенны все людские поделки? Даже компьютер и язык Паскаль! Эх, был бы числовой тип, пригодный на все случаи жизни, но…

Пять целочисленных типов не покрывают всех потребностей в вычислениях. Во-первых, диапазон их значений не так уж велик. Скажем, население Земли – около шести миллиардов – не поместится в переменной типа LongInt. А что сказать о комарином «населении»? Это, во-первых. А во-вторых, такими числами нельзя выразить дробные значения.

Выручают вещественные числа. Откуда такое чудное название? – Этими числами можно выразить количество сыпучих и жидких веществ. Если так, то целые числа следовало назвать штучными. У вещественных чисел есть и другое название – действительные. Которое из двух предпочтете? – дело вкуса.

Изображение вещественных чисел

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

3.33333343267441E-0002

Мы видим десятичную дробь, на хвосте которой болтается буква «E» и число -0002. Вот разгадка этой записи: дробь, что расположена до буквы «E», называется мантиссой, а число за этой буквой – порядком. Порядок показывает, на сколько позиций надо передвинуть десятичную точку в мантиссе для получения числа в привычном виде. Здесь порядок отрицательный, поэтому точка сдвигается на две позиции влево, а значит перед нами число 0.0333333343267441. Для положительного порядка точку двигают вправо, стало быть, число

3.33333343267441E+0003

в форме с фиксированной точкой запишется так: 3333.33343267441.

Разумеется, что при нулевом порядке точку не трогают. Вот и вся премудрость научного формата, который называют ещё форматом с плавающей точкой. Если научная форма кажется вам причудливой и неудобной, изобразите иначе следующие числа.

9.1093829140E-0031 – масса электрона, кг

1.9889200000E+0030 – масса солнца, кг

Вывод вещественных чисел

Паскаль может избавить вас от мысленных передвижений десятичной точки: при печати вещественных чисел допустимы спецификаторы ширины поля. Напомню, что для вещественных чисел спецификатор состоит из двух частей, разделенных двоеточием. Первая часть задает общую ширину поля печати, а вторая – количество знаков после точки. Рассмотрим несколько вариантов вывода одного и того же числа со спецификаторами и без них. Подопытным будет число 10/3, что соответствует бесконечному ряду троек: 3.333… и т.д. Вот программа для этого опыта.

{ Программа для исследования форматов вывода вещественных чисел }

begin

Writeln( 10/3); { без спецификаторов }

Writeln( 10/3 : 12); { указывается только ширина поля }

Writeln( 10/3 : 15:0); { только целая часть }

Writeln( 10/3 : 15:2); { два знака после точки }

Writeln( 10/3 : 15:3); { три знака после точки }

end.

Результат её работы таков.

3.33333333333333E+0000

3.333E+0000

3.33

3.333

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

Типы вещественных чисел

Подобно целым, вещественные числа представлены несколькими типами, которые разнятся размерами и диапазонами значений. Причина разнообразия все та же – стремление сэкономить память. В табл. 3 показаны четыре типа вещественных чисел языка Паскаль.

Табл. 3 – Вещественные типы

Тип данных

Точность

Диапазон возможных значений

Количество значащих цифр (точность)

Размер в байтах

От

До

Real

Стандартная

2.9 x 10

^–39

1.7 x 10

³⁸

11-12

Single

Одинарная

1.5 x 10

^–45

3.4 x 10

³⁸

7-8

Double

Двойная

5.0 x 10

^–324

1.7 x 10

³⁰⁸

15-16

Extended

Повышенная

3.6 x 10

^–4951

1.1 x 10

⁴⁹³²

19-20

Но почему в колонке минимальных значений я указал не нули, а очень маленькие числа? Да, ноль допустим, но для оценки точности вычислений важно знать именно этот предел. Разумеется, что указанные диапазоны распространяются и на отрицательные числа.

Теперь исследуем точность представления чисел разными типами данных.

{ Программа для исследования точности вещественных типов }

var F0 : Real; F1 : single; F2 : double; F3 : extended;

begin

F0:= 1/3; F1:= 1/3; F2:= 1/3; F3:= 1/3;

Writeln('Single = ', F1:23:18);

Writeln('Real = ', F0:23:18);

Writeln('Double = ', F2:23:18);

Writeln('Extended= ', F3:23:18);

end.

Десятичное представление дроби 1/3 нам известно, – это бесконечная последовательность троек, а результат вычислений по этой программе перед вами (для Borland Pascal, в других компиляторах результаты могут немного отличаться):

Single = 0.333333343267440796

Real = 0.333333333333484916

Double = 0.333333333333333315

Extended= 0.333333333333333333

Как и следовало ожидать, тип Extended дает самую высокую точность, – после десятичной точки следуют одни тройки. Другие типы менее точны. Если так, зачем они нужны? Обратимся к истории.

Первые версии Паскаля ещё не застали персональных компьютеров. Тогда в языке существовал только один тип вещественных чисел – Real. Его считают стандартным типом Паскаля, и для обработки таких чисел годится любой процессор (но вычисления будут медленными).

Но вот появились компьютеры с математическими сопроцессорами, многократно ускоряющими счет. Эти сопроцессоры оперируют с форматами, отличными от Real. Для совместимости с новой техникой в язык были введены ещё три типа чисел, указанные в табл. 3. Тип Extended даёт наивысшую точность и самый широкий диапазон представления чисел. И это понятно, ведь его размер больше, чем у других, и составляет 10 байтов. Но почему он выигрывает и в скорости? А потому, что для сопроцессора тип Extended – родной, применяйте его для вычислений. А что же Single и Double? Поскольку они занимают меньше места в памяти, то лучше подходят для хранения больших объёмов данных.

Сравнение вещественных чисел

Вещественные числа часто сравнивают между собой. Однако проверка их на точное равенство таит неприятный сюрприз, – такие сравнения ненадежны! Все потому, что вещественные числа – приближенные; они могут быть очень близки, и все же чуточку не совпадать друг с другом. Точное совпадение – это удача, а не закономерность. Правильней сравнивать числа с некоторой точностью, как в показанном ниже примере.

Назад к карточке книги "Песни о Паскале (СИ)"