{косвенная рекурсия

{раздел выполнения основной программы} PR_2

Здесь процедура Pr_1 при первом вызове инициирует случайное трехзначное число "n1" - выигрышный номер. При каждом вызове процедура Pr_1 запрашивает ввод трехзначного номера билета "n". Если номер билета не совпал (n<>n1) и остались еще билеты (i<>0), то снова вызывается процедура Pr_1, иначе вызывается процедура Pr_2 (окончание рекурсивного вызова). Если номера совпали (n1=n), то выводится сообщение: "Вы угадали, получите выигрыш в банке!". Процедура Pr_2 либо вызывает процедуру Pr_1, либо программа заканчивается (оператор Halt). В процедуре Pr_2 заголовок не имеет параметров, а в процедуре Pr_1 параметры указываются при первом описании. В данном случае приводится управляемая на каждом шаге рекурсия (процедура запрашивает номер билета). Включив тело процедуры Pr_2 в Pr_1 и введя операторы цикла, нетрудно избавиться от рекурсивного вызова процедур.

Структурированные типы данных

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

В Турбо Паскале пять структуированных типов:

массивы;

строки;

множества;

записи;

файлы;

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

Перечисляемый тип данных

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

перечисляемый тип, заключается в круглые скобки.

Программист объединяет в одну группу в соответствии с каким-либо признаком всю совокупность значений, составляющих перечисляемый тип. Например, перечисляемый тип Rainbow (РАДУГА) объединяет скалярные значе-

ния RED, ORANGE, YELLOW, GREEN, LIGHT_BLUE, BLUE, VIOLET (КРАСНЫЙ, ОРАНЖЕВЫЙ, ЖЕЛТЫЙ, ЗЕЛЕНЫЙ, ГОЛУБОЙ, СИНИЙ, ФИОЛЕТОВЫЙ). Перечисляемый тип Traffic_Light (СВЕТОФОР) объединяет скалярные значения RED, YELLOW, GREEN (КРАСНЫЙ, ЖЕЛТЫЙ, ЗЕЛЕНЫЙ).

Перечисляемый тип описывается в разделе описания типов, например: Type

Rainbow = (RED, ORANGE, YELLOW,

GREEN, LIGHT_BLUE, BLUE, VIOLET);

Каждое значение является константой своего типа и может принадлежать только одному из перечисляемых типов, заданных в программе. Например, перечисляемый тип Traffic_Light не может быть определен в одной программе с типом Rainbow, так как оба типа содержат одинаковые константы.

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

Например:

type Traffic_Light= (RED, YELLOW, GREEN); var Section: Traffic_Light;

Это означает, что переменная Section может принимать значения RED, YELLOW или GREEN.

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

var Section: (RED, YELLOW, GREEN);

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

К переменным перечисляемого типа может быть применим оператор присваивания:

Section:= YELLOW;

Упорядоченная последовательность значений, составляющих перечисляемый тип, автоматически нумеруется, начиная с нуля и далее через единицу. Отсюда следует, что к перечисляемым переменным и константам могут быть применены операции отношения и стандартные функции Pred, Succ, Ord.

Интервальный тип данных

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

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

Примеры отрезков: 1..10 -15..25

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

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

Массивы

Массивы – это совокупности однотипных элементов. Характеризуются они следующим:

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

число компонент массива определяется при его описании и в дальнейшем не меняется.

Для обозначения компонент массива используется имя переменной-массива

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

Описание типа массива задается следующим образом:

имя типа = array[ список индексов ] of тип

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

Вводить и выводить массивы можно только поэлементно.

Пример 1. Ввод и вывод одномерного массива. const

mas = array of integer;

a: mas; i: byte;

writeln("введите элементы массива"); for i:=1 to n do readln(a[i]); writeln("вывод элементов массива:");

for i:=1 to n do write(a[i]:5); end.

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

var a,b,c: array of integer;

Если массивы a и b описаны как: var

a = array of integer;

b = array of integer;

то переменные a и b считаются разных типов. Для обеспечения совместимости применяйте описание переменных через предварительное описание типа.

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

Так как тип, идущий за ключевым словом of в описании массива, – любой тип Турбо Паскаль, то он может быть и другим массивом.

Например: type

mas = array of array of integer;

Такую запись можно заменить более компактной: type

mas = array of integer;

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

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

for i:=1 to m do

for j:=1 to n do a:=random(10);

Для "красивого" вывода матрицы на экран используйте такой цикл: for i:=1 to m do begin

for j:=1 to n do write(a:5); writeln;

Пример. Найти длину n-мерного вектора a (n <= 50): x = (a12+a22+...+an2)

const maxSize = 50;

x: double; i, n: byte;

write(‘n = ’) ; read (n) ;

{ вычисление суммы }

x := 0 ;

for i:= 1 to n do

x := x + sqr (a [i]) ;

{ вычисление длины вектора }

x := sqrt (x) ;

write (‘длина вектора a =‘, x: 8:2) ;

Пример. Найти количество положительных, отрицательных и нулевых элементов массива a (количество элементов <= 50).

const maxSize = 50;

type vector = array of double; var a: vector;

i, n, kplus, kminus, kzero: byte;

write(‘n = ’) ; read (n) ;

{ ввод массива } for i:= 1 to n do

write (‘a[‘, i, ‘]=‘) ; read (a[i]) ;

{ инициализация счетчиков } kplus:= 0 ; kminus:= 0 ; kzero:= 0 ; for i:= 1 to n do

then inc (kminus) else if a [i] > 0

then inc (kplus) else inc (kzero) ;

write (‘k+ =‘, kplus , ‘ k- =‘, kminus, ‘ k0 =‘, kzero) ;

Пример. Проверить, является ли числовой массив a упорядоченным по возрастанию (количество элементов <= 50).

const maxSize = 50;

type vector = array of double; var a: vector;

write(‘n = ’) ; read (n) ;

{ ввод массива } for i:= 1 to n do begin

write (‘a[‘, i, ‘]=‘) ; read (a[i]) ;

p:= 0 ; { установка флажка} for i:= 1 to n - 1 do

if a <= a [i] then p:= 1;

{ если нарушилось возрастание, то смена флажка } if p = 1

then write (‘нет’) else write (‘да’) ;

Нахождение максимального элемента массива - подход к алгоритму. n = 1 тогда nMax:= 1 ;

n = 2 тогда nMax:= 1 ;

if a > a then nMax:= 2 ;

n = 3 тогда …… if a > a then nMax:= 3 ;

Пример. Найти значение и номер максимального элемента числового массива a (количество элементов <= 50).

const maxSize = 50;

type vector = array of double; var a: vector;

i, n, nMax: byte;

write(‘n = ’) ; read (n) ;

write (‘a[‘, i, ‘]=‘) ; read (a[i]) ;

for i:= 1 to n do

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

{ если встретился больший элемент, то запомнили его номер }

write (‘номер =’, nMax , ‘ max значение =‘, a :8: 2) ;

Сортировка числового массива - подход к алгоритму пузырьковой сортировки.

Для определенности - по возрастанию:

n = 2 тогда if a < a

then { если элементы стоят неправильно, то меняем их местами} begin t:= a ;

a := a ; a := t ; end;

n = 3 тогда if a < a

then begin t:= a ; a := a ;

{ максимальный элемент на месте}

Пример. Упорядочить по возрастанию числовой массив a (количество элементов <= 50).

const maxSize = 50;

type vector = array of double; var a, b: vector;

i, n, k: byte; t: double;

write(‘n = ’) ; read (n) ;

{ ввод массива } for i:= 1 to n do begin

write (‘a[‘, i, ‘]=‘) ; read (a[i]) ;

b:= a ; { присваивание массива} for k:= 1 to n-1 do

for i:= 1 to n - k do if b < b[i]

then begin t:= b[i] ;

b [i] := b ; b := t ;

end; writeln (‘упорядоченный массив:’) ; for i:= 1 to n do

writeln (‘b[‘, i, ‘]=‘, b[i] :8:2) ;

Пример. Найти сумму элементов матрицы a, состоящей из n строк и m

столбцов (n <= 5, m <= 4). uses wincrt;

const RSize = 5; CSize = 4;

sum: double; i, j, n, m: byte;

{ ввод массива } for i:= 1 to n do

for j:= 1 to m do begin

{ вычисление суммы }

for i:= 1 to n do

for j:= 1 to m do sum:= sum + a ;

write (‘сумма =‘, sum: 8:2) ;

Пример. Найти количество нулевых элементов в каждом столбце массива a. uses wincrt;

const RSize = 5; CSize = 4;

type matr = array of double; var a: matr;

i, j, n, m, kzero: byte;

for i:= 1 to n do

for j:= 1 to m do begin

write (‘a[‘, i, ‘,’, j, ‘]=‘) ; read (a) ;

for j:= 1 to m do{ цикл по столбцам } begin

{ инициализация счетчика } kzero:= 0 ;

for i:= 1 to n do if a [i] = 0

then inc (kzero) ;

writeln (j, ‘-й столбец:k0 =‘, kzero) ;

Пример. Найти номера строк массива a, в которых есть хоть один 0. uses wincrt;

const RSize = 5; CSize = 4;

type matr = array of double; var a: matr;

i, j, n, m, p: byte;

write(‘n = ’) ; read (n) ; write(‘m = ’) ; read (m) ; { ввод массива }

for i:= 1 to n do

for j:= 1 to m do begin

write (‘a[‘, i, ‘,’, j, ‘]=‘) ; read (a) ;

end ; for i:= 1 to n do

p:= 0 ; { установка флажка} for j:= 1 to m do

then p:= 1;{смена флажка } if p = 1

then writeln (‘номер строки=’, i);

Пример. Найти значение и номера максимального элемента числового массива a

const RSize = 5; CSize = 4;

type matr = array of double; var a: matr;

i, j, n, m, Rmax, Cmax: byte;

write(‘n = ’) ; read (n) ; write(‘m = ’) ; read (m) ; { ввод массива }

for i:= 1 to n do

for j:= 1 to m do begin

write (‘a[‘, i, ‘,’, j, ‘]=‘) ; read (a) ;

end ; Rmax:=1 ; Cmax:= 1 ; for i:= 1 to n do

for j:= 1 to m do

if a > a then

Rmax:= i; Cmax:= j ; end;

write (‘max = a[‘ , Rmax, ‘,’ , Cmax,‘ ]= ‘ , a :8: 2)

Пример. Переставить строки матрицы a в порядке возрастания элементов первого столбца.

const RSize = 5; CSize = 4;

type matr = array of double; var a , b: matr;

i, j, k, n, m: byte; t: double;

write(‘n = ’) ; read (n) ; write(‘m = ’) ; read (m) ; { ввод массива }

for i:= 1 to n do

for j:= 1 to m do begin

write (‘a[‘, i, ‘,’, j, ‘]=‘) ; read (a) ;

for k:= 1 to n-1 do

for i:= 1 to n - k do

if b < b

then { перестановка строк } for j:= 1 to m do

b := b ; b := t ; end;

writeln (‘упорядоченный массив:’) ; for i:= 1 to n do

for j:= 1 to m do

write (b :8:2) ;

writeln; { переход к новой строке }

Пример. Выполнить умножение матрицы a на вектор x. uses wincrt;

const RSize = 5; CSize = 4; VSize = 5 ;

type matr = array of double; vector = array of double;

i, j, k, n, m: byte;

write(‘n = ’) ; read (n) ; write(‘m = ’) ; read (m) ;

{ ввод матрицы } for i:= 1 to n do

for j:= 1 to m do begin

write (‘a[‘, i, ‘,’, j, ‘]=‘) ; read (a) ;

{ ввод вектора }

for j:= 1 to m do begin

write (‘x[‘, j, ‘]=‘) ; read (x[j]) ;

for i:= 1 to n do begin

for j:= 1 to m do

y[ i ] := y[ i ] + a * x[j] ;

{ вывод результата }

for i:= 1 to n do

writeln (‘y[‘, i, ‘]=‘, y[i] :8:2) ;

Пример. Выполнить умножение матрицы a на матрицу b. uses wincrt;

const RSize = 5; CSize = 5;

type matr = array of double; var a, b, c: matr;

i, j, k, n, m, L: byte;

write(‘n = ’) ; read (n) ; write(‘m = ’) ; read (m) ; { ввод матрицы a} for i:= 1 to n do

for j:= 1 to m do begin

write (‘a[‘, i, ‘,’, j, ‘]=‘) ; read (a) ;

end ; write(‘L = ’) ; read (L) ;

{ ввод матрицы b} for i:= 1 to m do

for j:= 1 to L do begin

write (‘b[‘, i, ‘,’, j, ‘]=‘) ; read (b) ;

{ количество строк матрицы b равно количеству столбцов матрицы a} for i:= 1 to n do

for j:= 1 to L do begin

c[ i , j] := 0 ;

for k:= 1 to m do

c[ i , j] := c[ i , j] + a * b ;

{ вывод результата }

for i:= 1 to n do begin

for j:= 1 to L do

write (c :8:2) ; writeln;

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

type Cardsuit = (clubs , diamonds , hearts , spades ) ;

Здесь производится объявление типа данных Cardsuit (карточная масть), значениями которого может быть любая из четырёх перечисленных констант. Переменная типа Cardsuit может принимать одно из значений clubs, diamonds, hearts, spades , допускается сравнение значений типа перечисление на равенство или неравенство, а также использование их в операторах выбора (в Паскале - case) в качестве значений, идентифицирующих варианты.

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

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

Перечисляемый тип может использоваться в объявлениях переменных и формальных параметров функций (процедур, методов). Значения перечислимого типа могут присваиваться соответствующим переменным и передаваться через параметры соответствующих типов в функции. Кроме того, всегда поддерживается сравнение значений перечислимого типа на равенство и неравенство. Некоторые языки поддерживают также другие операции сравнения для значений перечислимых типов. Результат сравнения двух перечислимых значений в таких случаях определяется, как правило, порядком следования этих значений в объявлении типов - значение, которое в объявлении типа встречается раньше, считается «меньше» значения, встречающегося позже. Иногда перечислимый тип или некоторый диапазон значений перечислимого типа также может быть использован в качестве типа индекса для массива. В этом случае для каждого значения выбранного диапазона в массиве имеется один элемент, а реальный порядок следования элементов соответствует порядку следования значений в объявлении типа.

Реализация

Обычно в процессе компиляции значения перечислений представляются при помощи целых чисел. В зависимости от конкретного языка программирования такое представление может быть либо полностью скрыто от программиста, либо доступно ему с помощью тех или иных «обходных манёвров» (например, принудительного преобразования значения типа перечисление к значению типа «целое число»), либо даже управляемо программистом (в таких случаях программист имеет возможность явно указать, какими числами будут кодироваться все или некоторые значения типа-перечисления). У всех вариантов есть свои положительные и отрицательные стороны. С одной стороны, возможность использования числовых значений констант, составляющих тип-перечисление, особенно при злоупотреблении ею, лишает смысла использование этих типов и создаёт опасность появления ошибок (когда используются числовые значения, для которых в типе нет соответствующих констант). С другой стороны, явное управление значениями даёт некоторые дополнительные возможности. Например, позволяет использовать типы-перечисления при организации интерфейса с модулями, написанными на других языках, если они используют или возвращают кодированные целыми числами значения из некоторого предопределённого набора.

Ещё одна возможность, которую дают перечислимые типы на уровне реализации языка - экономия памяти. При небольшом объёме типа-перечисления для хранения значения этого типа достаточно нескольких битов (вышеприведённый тип Cardsuit требует всего два бита на значение, в то время как стандартное целое число на большинстве используемых архитектур занимает 32 бита - в 16 раз больше), и компилятор может использовать этот факт для уплотнения хранения данных в памяти. Это может быть особенно важно, если несколько значений типов-перечислений хранятся в одной записи - уплотнение записей при обработке больших их количеств может освободить много памяти. Правда, необходимо отметить, что компиляторы обычно не реализуют эту возможность, по крайней мере, в последнее время, когда компьютерная память существенно подешевела.

Критика

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

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

Описание перечислений в различных языках

Enum cardsuit { CLUBS , DIAMONDS , HEARTS , SPADES };

Динамические языки слабой типизации с C-подобным синтаксисом (например perl или JavaScript), как правило, не имеют перечислений.

C++

Перечисления в языке C++ прямо наследуют поведение перечислений языка C, за исключением того, что перечисляемый тип в C++ - настоящий тип, и ключевое слово enum используется только при объявлении такого типа. Если при обработке параметра являющегося перечислением, какое-либо значение из перечисления не обрабатывается (например один из элементов перечисления забыли обработать в конструкции switch), то компилятор может выдать предупреждение о забытом значении.

enum Cardsuit { Clubs , Diamonds , Spades , Hearts }

Java

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

Переменными называют величины, значения которыхмогут изменяться в процессе выполнения программы. Каждая переменная задается своим уникальным именем, построенным по правилам, указанным в начале главы. Максимально возможная длина имени зависит от реализации Паскаля, теоретически можно давать переменным имена вплоть до 63 символов длиной, что едва ли актуально – обычно имена не длиннее 5-10 символов.

Поскольку любые данные в памяти компьютера хранятся в числовой форме и двоичной системе счисления, кроме имени, переменной обязательно следует присвоить и тип , определяющийдиапазон значений , принимаемых переменной, испособ ее обработки машиной. Поясним сказанное на примере. Как видно из Приложения 1, латинская большая буква "A" имеет десятичный код 65, или 01000001 в двоичном представлении. Без дополнительной информации отипе данных, хранящихся в некоторой ячейке памяти, компьютеру было бы невозможно решить, что именно представляют из себя эти данные – число 65, код символа "A" или что-то еще. В любом языке программирования, в том числе и в Паскале, существует стандартный набор типов, к которым может быть отнесена та или иная совокупность ячеек памяти. Информацию о типах данных Паскаля удобно свести в таблицу. Строки этой таблицы будут упорядочены постаршинству типов , от самого "младшего", требующего наименьшее число байт для представления, и, соответственно, представляющего наименьший диапазон возможных значений, до самого "старшего", представляющего наибольший диапазон значений. В таблице представлены не все возможные, а лишь основные типы данных Паскаля.

Ключевое слово Паскаля	Название и описание типа	Объем памяти, байт	Диапазон возможных значений
	Логический: хранит одну логическую переменную
	Символьный: хранит код одного символа из набора ASCII-кодов		от 0 до 255 включительно (2 8 =256)
	Целочисленный
	Целочисленный без знака		±2 16 - диапазон вдвое больше, так как 16-й бит не занят под знак числа
	Длинное целое: для представления больших целочисленных значений
	Вещественное число с точностью представления до 11-12 знака в дробной части		~ 2.910 -39 - 1.710 38
	Вещественное число с точностью представления до 15-16 знака в дробной части		~ 510 -324 – 1.710 308
	Последовательность символов типа Charдлиной от 1 до 255	2-256 (данные строки + 1 байт для хранения ее длины)	Любые строки текста, состоящие из печатаемых символов

Теоретически для записи переменной типа Booleanбыло бы достаточно 1 бита, но минимальная адресуемая единица памяти – 1 байт (см. Приложение 1). В этом же Приложении уточните, как именно объем памяти в байтах, выделяемой под переменную, влияет на диапазон представляемых ей значений.

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

Разумеется, задача правильного выбора типов данных целиком ложится на программиста. Например, если некоторый счетчик в Вашей программе может принимать целочисленные значения от 1 до 100000, неправильно было бы описывать его как переменную типа Integer– ведь 2 15 =32768 и при достижении счетчиком этой величины произойдетсброс его значения, которое станет равно -32768. Разумным в данном случае было бы описание счетчика как переменной типаLongint.

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

var Список1:Тип1;

Список2:Тип2;

СписокN:ТипN;

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

описывает 2 вещественных переменных с именами tиr, а также целочисленную переменную с именемi. Ключевое словоvarможно и продублировать, но обычно такой необходимости нет. Сокращениеvarобразовано от английского слова "Variable" (переменная).

Теги: Си перечисление, enum.

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

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

Enum <имя> { <имя поля 1>, <имя поля 2>, ... <имя поля N> }; //здесь стоит;!

Например

#include #include enum Gender { MALE, FEMALE }; void main() { enum Gender a, b; a = MALE; b = FEMALE; printf("a = %d\n", a); printf("b = %d\n", b); getch(); }

В этой программе объявлено перечисление с именем Gender. Переменная типа enum Gender может принимать теперь только два значения – это MALE И FEMALE.

По умолчанию, первое поле структуры принимает численное значение 0, следующее 1, следующее 2 и т.д. Можно задать нулевое значение явно:

#include #include enum Token { SYMBOL, //0 NUMBER, //1 EXPRESSION = 0, //0 OPERATOR, //1 UNDEFINED //2 }; void main() { enum Token a, b, c, d, e; a = SYMBOL; b = NUMBER; c = EXPRESSION; d = OPERATOR; e = UNDEFINED; printf("a = %d\n", a); printf("b = %d\n", b); printf("c = %d\n", c); printf("d = %d\n", d); printf("e = %d\n", e); getch(); }

Будут выведены значения 0 1 0 1 2. То есть, значение SYMBOL равно значению EXPRESSION, а NUMBER равно OPERATOR. Если мы изменим программу и напишем

Enum Token { SYMBOL, //0 NUMBER, //1 EXPRESSION = 10, //10 OPERATOR, //11 UNDEFINED //12 };

То SYMBOL будет равно значению 0, NUMBER равно 1, EXPRESSION равно 10, OPERATOR равно 11, UNDEFINED равно 12.

Принято писать имена полей перечисления, как и константы, заглавными буквами. Так как поля перечисления целого типа, то они могут быть использованы в операторе switch.

Заметьте, что мы не можем присвоить переменной типа Token просто численное значение. Переменная является сущностью типа Token и принимает только значения полей перечисления. Тем не менее, переменной числу можно присвоить значение поля перечисления.

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

#include #include #include static char *ErrorNames = { "Index Out Of Bounds", "Stack Overflow", "Stack Underflow", "Out of Memory" }; enum Errors { INDEX_OUT_OF_BOUNDS = 1, STACK_OVERFLOW, STACK_UNDERFLOW, OUT_OF_MEMORY }; void main() { //ошибка случилась printf(ErrorNames); exit(INDEX_OUT_OF_BOUNDS); }

Так как поля принимают численные значения, то они могут использоваться в качестве индекса массива строк. Команда exit(N) должна получать код ошибки, отличный от нуля, потому что 0 - это плановое завершение без ошибки. Именно поэтому первое поле перечисления равно единице.

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

Typedef enum enumName { FIELD1, FIELD2 } Name;

В стандарте C++ нет типа данных, который можно было бы считать действительно символьным. Для представления символьной информации есть два типа данных, пригодных для этой цели, – это типы char и wchar_t .

Переменная типа char рассчитана на хранение только одного символа (например, буквы или пробела). В памяти компьютера символы хранятся в виде целых чисел. Соответствие между символами и их кодами определяется таблицей кодировки , которая зависит от компьютера и операционной системы. Почти во всех таблицах кодировки есть прописные и строчные буквы латинского алфавита, цифры 0, ..., 9, и некоторые специальные символы. Самой распространенной таблицей кодировки является таблица символов ASCII (American Standard Code for Information Interchange – Американский стандартный код для обмена информацией).

Так как в памяти компьютера символы хранятся в виде целых чисел, то тип char на самом деле является подмножеством типа int .

Под величину символьного типа отводится 1 байт .

Тип char может использоваться со спецификаторами signed и unsigned . В данных типа signed char можно хранить значения в диапазоне от –128 до 127. При использовании типа unsigned char значения могут находиться в диапазоне от 0 до 255. Для кодировки используется код ASCII . Символы с кодами от 0 до 31 относятся к служебным и имеют самостоятельное значение только в операторах ввода-вывода.

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

Тип wchar_t предназначен для работы с набором символов, для кодировки которых недостаточно 1 байта, например в кодировке Unicode . Размер типа wchar_t равен 2 байтам. Если в программе необходимо использовать строковые константы типа wchar_t , то их записывают с префиксом L , например, L " Слово ".

Например:

char c="c"; char a,b; char r={"A","B","C","D","E","F","\0"}; char s = "ABCDEF";

Логический (булевый) тип данных (тип bool)

В языке С++ используется двоичная логика ( истина , ложь ). Лжи соответствует нулевое значение , истине – единица . Величины данного типа могут также принимать значения true и false .

Внутренняя форма представления значения false соответствует 0, любое другое значение интерпретируется как true . В некоторых компиляторах языка С++ нет данного типа, в этом случае используют тип int , который при истинных значениях выдает 1, а при ложных – 0. Под данные логического типа отводится 1 байт .

Перечисляемый тип (тип enum)

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

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

Например:

enum year {winter, spring, summer, autumn}; enum week {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};

Тип void

Множество значений этого типа пусто. Тип void имеет три назначения:

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

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

Основные типы данных

Тип	Обозначение		Название	Размер памяти, байт (бит)	Диапазон значений
Тип	Имя типа	Другие имена	Название	Размер памяти, байт (бит)	Диапазон значений
целый	int	signed	целый	4 (32)
	int	signed int	целый	4 (32)
	unsigned int	unsigned	беззнаковый целый	4 (32)	0 до 4 294 967 295
	short	short int	короткий целый	2 (16)	-32 768 до 32 767
	short	signed short int	короткий целый	2 (16)	-32 768 до 32 767
	unsigned short	unsigned short int	беззнаковый короткий целый	2 (16)	0 до 65 535
	long	long int	длинный целый	4 (32)	-2 147 483 648 до 2 147 483 647
	long	signed long int	длинный целый	4 (32)	-2 147 483 648 до 2 147 483 647
	unsigned long	unsigned long int	беззнаковый длинный целый	4 (32)	0 до 4 294 967 295
	long long	long long int	длинный-предлинный целый	8 (64)	-9 223 372 036 854 775 808 до 9 223 372 036 854 775 807
	long long	signed long long int	длинный-предлинный целый	8 (64)
	unsigned long long	unsigned long	беззнаковый длинный-предлинный целый	8 (64)	0 до 18 446 744 073 709 551 615
	unsigned long long	long int	беззнаковый длинный-предлинный целый	8 (64)	0 до 18 446 744 073 709 551 615
символьный	char	signed char	байт (целый длиной не менее 8 бит)	1 (8)	-128 до 127
	unsigned char	-	беззнаковый байт	1 (8)	0 до 255
	wchar_t	-	расширенный символьный	2 (16)	0 до 65 535
вещественный	float	-	вещественный одинарной точности	4 (32)	3.4Е-38 до 3.4Е+38 (7 значащих цифр)
	double	-	вещественный двойной точности	8 (64)
	long double	-	вещественный максимальной точности	8 (64)	1.7Е-308 до 1.7Е+308 (15 значащих цифр)
	bool	-	логический	1 (8)	true (1) или false (0)
	enum	-	перечисляемый	4 (32)	-2 147 483 648 до 2 147 483 647

Преобразования типов

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

Преобразование типов – это приведение значения переменной одного типа в значение другого типа.

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

Формат операции явного преобразования типов:

имя_типа (операнд)

Например, int(x), float(2/5), long(x+y/0.5) .

Пример 1 .

//Взятие цифры разряда сотых в дробном числе #include "stdafx.h" #include using namespace std; int _tmain(int argc, _TCHAR* argv){ float s,t; long int a,b; printf("Введите вещественное число\n"); scanf("%f", &s); t=s*100; a=(int)t; //переменная t приводится к типу int в переменную a b=a%10; printf("\nЦифра разряда сотых числа %f равна %d.", s, b); system("pause"); return 0; }

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

Пример 2. Временной интервал

Заданы моменты начала и конца некоторого промежутка времени в часах, минутах и секундах (в пределах одних суток). Найти продолжительность этого промежутка в тех же единицах.

Исходными данными для этой задачи являются шесть целых величин, задающих моменты начала и конца интервала, результатами – три целых величины (тип int ).

Обозначим переменные для хранения начала интервала hour1 , min1 и sec1 , для хранения конца интервала – hour2 , min2 и sec2 , а результирующие величины – hour , min и sec .

Для решения этой задачи необходимо преобразовать оба момента времени в секунды, вычесть первый из второго, а затем преобразовать результат обратно в часы, минуты и секунды. Следовательно, потребуется промежуточная переменная sum_sec , в которой будет храниться величина интервала в секундах. Она может иметь весьма большие значения, ведь в сутках 86400 секунд, что выходит за пределы типа short int . Следовательно, для этой переменной выберем длинный целый тип (long int , сокращенно long ).

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

//Временной интервал. Форматированный ввод-вывод данных #include "stdafx.h" #include using namespace std; int _tmain(int argc, _TCHAR* argv){ int hour1, min1, sec1, hour2, min2, sec2, hour, min, sec; long int sum_sec; printf("Введите время начала интервала (час мин сек)\n"); scanf("%d%d%d", &hour1,&min1,&sec1); printf("Введите время окончания интервала (час мин сек)\n"); scanf("%d%d%d", &hour2,&min2,&sec2); sum_sec = (hour2-hour1)*3600+(min2-min1)*60+sec2-sec1; hour = sum_sec/3600; min = (sum_sec-hour*3600)/60; sec = sum_sec-hour*3600-min*60; printf("Продолжительность промежутка от %d:%d:%d до %d:%d:%d\n",hour1,min1,sec1,hour2,min2,sec2); printf(" равна %d:%d:%d\n",hour,min,sec); system("pause"); return 0; }

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

1. Преобразование целых типов со знаком .

Целое со знаком преобразуется к более короткому целому со знаком , с потерей информации: пропадают все разряды числа, которые находятся выше (или, соответственно – ниже) границы, определяющей максимальный размер переменной.
Целое со знаком преобразуется к более длинному целому со знаком . Путем размножения знака. То есть все добавленные биты двоичного числа будут заняты тем же числом, которое находилось в знаковом бите : если число было положительным, то это будет, соответственно 0, если отрицательным, то 1.
Целое со знаком к целому без знака . Первым шагом целое со знаком преобразуется к целому со знаком, соответствующему целевому типу, если этот тип данных крупнее. У получившегося значения бит знака не отбрасывается, а рассматривается равноправным по отношению к остальным битам, то есть теперь все биты образуют числовое значение.
При преобразовании величины с плавающей точкой к целым типам она сначала преобразуется к типу long (дробная часть плавающей величины при этом отбрасывается), а затем величина типа long преобразуется к требуемому целому типу. Если значение слишком велико для long , то результат преобразования не определен. Обычно это означает, что на усмотрение компилятора может получиться любой "мусор". В реальной практике с такими преобразованиями обычно сталкиваться не приходится.