Типы данных (ч. 2)

Алгоритмы и структуры данных

Контрольные вопросы по предмету

0


Подпишитесь на бесплатную рассылку видео-курсов:

Текст видеолекции

Концепция типа для данных

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

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

   В языке  ПАСКАЛЬ существует правило:  тип явно задается в описании переменной или функции,  которое предшествует их использованию.  Концепция типа языка ПАСКАЛЬ имеет следующие основные свойства:

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

   -тип значения,  задаваемого константой, переменной или выражением,

можно определить по их виду или описанию;

   -каждая операция или функция требует аргументов фиксированного типа и выдает результат фиксированного типа.

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

   Тип определяет:

   -возможные значения переменных, констант, функций, выражений, принадлежащих к данному типу;

   -внутреннюю форму представления данных в ЭВМ;

   -операции и  функции,   которые  могут выполняться над величинами, принадлежащими к данному типу.

   Обязательное описание типа приводит к избыточности в тексте программ,  но  такая избыточность является важным вспомогательным средством разработки программ и рассматривается как необходимое  свойство современных алгоритмических языков высокого уровня.  В языке ПАСКАЛЬ

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

   К  cкалярным типам относятся стандартные типы и типы, определяемые пользователем.

   Стандартные типы  включают  целые,   действительные,   символьный, логические и адресный типы. Типы, определяемые пользователем, - перечисляемый и интервальный.

   Структурированные типы имеют четыре разновидности:  массивы,  множества, записи и файлы.

   Кроме перечисленных,  TURBO PASCAL  включает еще два типа - процедурный и объектный.

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

   -все возможные значения порядкового типа представляют собой ограниченное упорядоченное множество;

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

   -к любому порядковому типу могут быть применены стандартные функции Pred и Succ, которые возвращают предыдущее и последующее значения соответственно;

   -к любому порядковому типу могут быть применены стандартные функции Low и High,  которые возвращают наименьшее и наибольшее значения

величин данного типа.

   В языке ПАСКАЛЬ введены понятия эквивалентности и совместимости типов.

   Два типа Т1 и Т2 являются эквивалентными (идентичными),  если выполняется одно из двух условий:

   -Т1 и Т2 представляют собой одно и то же имя типа;

   -тип Т2  описан  с использованием типа Т1 с помощью равенства или

последовательности равенств. Например:

   type

      T1 = Integer;

      T2 = T1;

      T3 = T2;

 

   Менее строгие ограничения определены совместимостью типов. Например, типы являются совместимыми, если:

   -они эквивалентны;

   -являются оба либо целыми, либо действительными;

   -один тип - интервальный, другой - его базовый;

   -оба интервальные с общим базовым;

   один тип - строковый, другой - символьный.

   В ТУРБО ПАСКАЛЬ ограничения на совместимость типов можно обойти с помощью приведения  типов.  Приведение типов позволяет рассматривать одну и ту же величину в памяти ЭВМ как принадлежащую  разным  типам. Для этого используется конструкция

    Имя_Типа(переменная или значение).

     Например,       Integer('Z')

 представляет собой значение кода символа 'Z' в двухбайтном представлении целого числа, а      Byte(534)   даст значение 22, поскольку целое число 534 имеет тип Word и занимает два байта, а тип Byte занимает один байт, и в процессе приведения старший байт будет отброшен.

 Целые числа

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

1 -12 1234567

В таблице 1 представлены целые типы:

Таблица 1. Целые типы данных

Тип

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

Размер памяти под переменную

Примечание

Integer

-2147483648 .. 2147483647

4 байта

Знаковое

Cardinal

0 .. 4294967295

4 байта

Без знака

Shortint

-128 .. 127

1 байт

Знаковое

Smallint

-32768 .. 32767

2 байта

Знаковое

Longint

-2147483648 .. 2147483647

4 байта

Знаковое

Int64

-263 .. 263 - 1

8 байт

Знаковое

Byte

0 .. 255

1 байт

Без знака

Word

0 .. 65535

2 байта

Без знака

Longword

0 .. 4294967295

4 байта

Без знака

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

Чаще всего вам придется работать с переменными типа Integer, это самый распространенный тип целых чисел, он годится почти для всех расчетов. Однако бывают моменты, когда не нужно такого большого диапазона значений. Например, вы будете использовать переменную для счетчика какого-то цикла, и знаете, что он будет длиться, к примеру, от 1 до 100. В таком случае, указав в качестве счетчика тип Integer, мы зря украдем у оперативной памяти 3 байта! 3 байта – это немного, но ведь в большой программе переменных будет очень много, и если все они будут тратить память попусту, то такая программа будет, мягко говоря, непрофессиональной. Приучайтесь сразу тратить столько байт оперативной памяти, сколько нужно. Не зря ведь придумали столько типов! Если Вы знаете, что в переменной будут числа от нуля и выше, то нет никакой необходимости брать знаковый тип, ведь отрицательным Ваше число все равно не будет!

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

Как мы уже говорили раньше, вещественные числа – это числа с запятой, после которой идут десятичные значения. Еще говорят, что они имеют плавающую точку (запомните это определение, оно будет часто встречаться). Некоторые начинающие программисты считают, что лучше такой тип переменных использовать всегда, даже при обработке целых чисел. Это большое заблуждение! Операции над числами с плавающей точкой отнимают у процессора гораздо больше времени, и требуют больше памяти. Компьютер воспринимает вещественное число, как два целых, и делает двойную работу при обработке чисел до запятой, и после нее. Однако иной раз бывает необходимо использовать именно такой тип данных. К примеру, если нужно поделить одно целое на другое. Хорошо, если это будет "4/2", результат тоже будет целым – 2. А если "4/3"? Тогда результатом будет 1,3333… и уж тут без вещественного числа не обойтись! А ведь мы заранее не знаем, какие числа будет делить пользователь, поэтому лучше сразу иметь в виду, что результат может быть не целым числом.

Как и целые, вещественные числа имеют несколько типов. В таблице 2. они представлены:

Таблица 2. Вещественные типы данных

Тип

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

Значащих цифр максимально

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

Real48

2.9 * 10-39 .. 1.7 * 1038

11-12

6

Real

5.0 * 10-324 .. 1.7 * 10308

15-16

8

Single

1.5 * 10-45 .. 3.4 * 1038

7-8

4

Double

5.0 * 10-324 .. 1.7 * 10308

15-16

8

Extended

3.6 * 10-4951 .. 1.1 * 104932

19-20

10

Comp

-263+1 .. 263-1

19-20

8

Currency

-922337203685477.5808 .. 922337203685477.5807

19-20

8

Третий столбец таблицы указывает количество максимально значащих цифр. Цифры, которые выходят за этот предел, будут игнорироваться. Тут важно помнить, что вещественные числа не равны целым. То есть, число 3,0 не будет равно 3! Чтобы сравнить оба эти числа, придется округлить вещественное число.

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

Откройте Delphi, создайте новый проект. На форму нужно поместить три компонента Label, три компонента Edit и одну кнопку, чтобы получилась такая картина:

Рис..1.  Внешний вид формы

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

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

Перед begin процедуры следует создать раздел var, и объявить там три переменных:

var   Perem1, Perem2 : Integer;   Perem3 : Double;

Затем вернемся в тело процедуры (между командами begin и end), и присвоим целым переменным введенные пользователем значения. Здесь нужно понять одну важную вещь. Пользователь будет вводить значения в компоненты Edit, и там они будут храниться в свойстве Text в виде строкового типа данных. Строку нельзя будет присвоить переменной какого-либо другого типа данных, присвоение

Perem1 := Edit1.Text; //ошибочное присвоение                       //– несовместимость типов данных

будет ошибочным. Разница довольно существенная: даже если пользователь вводит, казалось бы, целое число, например,

123

то компьютер видит строку символов, а вовсе не число:

'123'

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

StrToInt('String');

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

var    s: String;    i: Integer; begin    s := '1234';    i := StrToInt(s); //параметр – строковая переменная    i := StrToInt(‘123456’); //параметр – строка    i := StrToInt(Edit1.Text); //параметр – свойство Text                               //компонента Edit, имеющее строковый тип end;

Как видно из примера, имеется масса возможностей передать в функцию строку. В первом случае преобразования мы передаем строковую переменную s, в которой хранится строка '1234'. Функция преобразует эту строку в целое число, и в результате в переменную i попадет уже число 1234.

Во втором случае мы передаем непосредственно строку '123456', а в переменную i попадает преобразованное из этой строки число. В третьем случае мы в качестве параметра передаем тот текст, который пользователь ввел в поле ввода Edit1. Здесь следует сделать оговорку. Функция сработает правильно, если пользователь ввел туда действительно целое число. В противном случае возникнет ошибка. Пользователь – личность непредсказуемая, поэтому программист в таких случаях перед преобразованием типов всегда делает проверку – а действительно ли в поле ввода имеются только цифры от 0 до 9? Нет ли там случайно буквы или запятой? Такую проверку мы научимся делать позднее. Пока что придется самим следить, чтобы в этих полях ввода были только целые числа.

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

  Perem1 := StrToInt(Edit1.Text);   Perem2 := StrToInt(Edit2.Text);

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

  {защита от дураков:}   If Perem2 = 0 then begin                   //если это ноль, то:     ShowMessage('На ноль делить нельзя!');   //выводит сообщение     Edit3.Text := '0';                 //как результат записываем ноль   end   else begin                            //иначе:     Perem3 := Perem1 / Perem2;         //делим     Edit3.Text := FloatToStr(Perem3);  //преобразуем вещественное в                                        //строку и записываем результат   end;

Здесь следует обратить внимание на предпоследнюю строку. Функция FloatToStr() в качестве параметра принимает вещественное число, и возвращает это же число в виде строки. Например, в результате преобразования

s := FloatToStr(123.45);

переменной s будет присвоена строка '123.45', которую затем уже можно будет вывести пользователю в качестве результата. В нашем примере мы результат деления двух целых чисел преобразуем в строку и выводим его в поле Edit3. Справедливости ради следует заметить, что в качестве параметра можно передавать не только значение, но и выражение. Например, если указать

Edit3.Text := FloatToStr(Perem1 / Perem2);

то надобность в использовании вещественной переменной Perem3 отпадает. Попробуйте, как работают оба варианта.