Приложения. 

ПРИЛОЖЕНИЕ А.  ДОПОЛНИТЕЛЬНАЯ ЛИТЕРАТУРА.

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

ЯзыкСи.

Kernighan Brian W. and Ritchie Dennis M., The СРrоgrаmming Language, Prentice-Hall, 1978. (Имеется перевод: КЕРНИГАН Б., Ритчи Д. Язык программирования Си.- M.: Финансы и статистика, 1985.).

Первая и наиболее авторитетная книга по языку Си. (Заметим. что один из авторов этой книги Деннис Ритчи - создатель языка Си.) Практически она является официальным описанием языка и включает много интересных примеров. Однако авторы предполагают, что читатель знаком с системным программированием.

Feuer Alan R., The С Puzzle Hook, Prentice-Hall, 1982. (Имеется перевод: Фьюэр А. Задачи по языку Си.- M.: Финансы и статистика, 1985.).

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

Ritchie D. M., Johnson S. С., Lesk M. E., and Kernighan В. W., The СРrоgrаmming Language, The Bell System Technical Journal, Vol. 57, No. 6, July-August 1978.

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

BYTE, Vol. 8, No. 8, August 1983.

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

Программирование.

Kernighan Brian W. and Plauger P. J., The Elements of Programming Style (Second Edition), McGraw-HiII, 1978.

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

Kernighan Brian V. and Plauger P. J., Software Tools, Addison-Wesley, 1976.

В книге описывается несколько полезных программ и программных систем, причем делается упор на эффективное проектирование структур программ. Представлены описания языка RATFOR (рационализированного Фортрана) и одной из версий Паскаля. Так как создание языка RATFOR - это попытка сделать сходной работу языков Фортран и Си, он лучше всего подходит пользователям языка как для знакомства с ним.

Операционная система UNIX.

Waite Mitchell, Martin Don and Praia Stephen , UNIX Primer Plus, Howard W. Sams and Company, Inc., 1983.

Эта книга - легко читаемое введение в операционную систему UNIX. В нее включены некоторые мощные расширения этой системы, реализованные в Калифорнийском университете (Беркли).

ПРИЛОЖЕНИЕ Б. КЛЮЧЕВЫЕ СЛОВА ЯЗЫКА СИ.

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

Ключевые слова выполнения программы.

Циклы.

For while do.

Принятие решения и выбор.

If else switch case default.

Переходы.

Break continue goto.

Типы данных.

Char int short long unsigned float double struct union typedef.

Классы памяти.

Auto extern register static.

Разное.

Return sizeof.

Еще не реализованное.

Entry.

Применяемые только в некоторых системах.

Asm endasm fortran enum.

ПРИЛОЖЕНИЕ В. ОПЕРАЦИИ ЯЗЫКА СИ.

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

I. Арифметические операции.

+	Прибавляет величину, находящуюся справа, к величине, стоящей слева
-	Вычитает величину, стоящую справа, из величины, указанной слева
-	Будучи унарной операцией, изменяет знак величины, стоящей справа
*	Умножает величину справа на величину, находящуюся слева
/	Делит величину, стоящую слева, на величину справа. Результат усекается, если оба операнда целые числа
%	Дает остаток от деления величины слева на величину, стоящую справа (только для целых чисел)
++	Прибавляет 1 к значению переменной, стояшей слева (префикная форма), или к переменной, стояшей справа (постфиксная форма)
--	Аналогично ++, но вычитает 1

Операции (от высшего приоритета к низшему)	Порядок выполнения
()   {}   ->   .	Л-П
!   ~   ++   --   -   (тип)   *   &   sizeof (все унарные)	П-Л
*   /   %	Л-П
+   -	Л-П
<<   >>	Л-П
<   <=   >   >=	Л-П
==   !==	Л-П
&	Л-П
/\	Л-П
|	Л-П
&&	Л-П
||	Л-П
?:	Л-П
=   +=   -=   *=   /*   %=	П-Л
,	Л-П
Условные обозначения: Л-П - порядок выполнения слева направо, а П-Л - наоборот.

II. Операции присваивания.

=     Присваивает значение, указанное справа, переменной, стоящей слева.

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

-=	вычитает величину П из переменной Л
*=	умножает переменную Л на величину П
/=	делит переменную Л на величину П
%=	выдает остаток от деления переменной Л на величину П

Пример:

Rabbits *= 1.6; то же самое, что rabbits = rabbits * 1.6;  

III. Операции отношения.

Каждая из этих операций сравнивает значение слева со значением справа. Оператор отношения, состоящий из операции и двух ее операндов, имеет значение 1, если выражение истинно, и значение 0, если выражение ложно.

<	меньше
<=	меньше или равно
==	равно
>=	больше или равно
>	больше
!=	не равно

IV. Логические операции.

Обычно логические операции "считают" условные выражения операндами. Операция ! имеет один операнд, расположенный справа. Остальные операции имеют два операнда: один слева и один справа.

&&	Логическое И: результат операции имеет значение "истина", если оба операнда истинны, и "ложь" в противном случае.
||	Логическое ИЛИ: результат операции имеет значение "истина", если один или оба операнда истинны, и "ложь" в противном случае.
!	Логическое НЕ: результат имеет значение "истина", если операнд имеет значение "ложь", и наоборот.

V. Операции над указателями.

&	Операция получения адреса: выдаст адрес переменной, имя которой стоит за обозначением операции: &nurse является адресом переменной nurse
*	Косвенная адресация: выдает значение, записанное по адресу, на который ссылается указатель:

Nurse = 22;

Ptr = &nurse; /* указатель на nurse */

Val = *ptr.

В результате работы этих операторов переменной val присваивается значение 22.  

VI. Операции над структурами и объединениями.

.

Операция принадлежности (точка) используется совместно с именем структуры (или объединения) для задания элемента этой структуры (иди объединения). Если name является именем структуры, а member - элементом, указанным в структурном шаблоне, то name.member определяет этот элемент структуры. Операцию принадлежности можно аналогичным образом применять и к объединениям.

Пример:

Struct {

 int code;

 float cost;

   } item;

Item.code = 1265;

Выполняется присваивание значения элементу code структуры item.

->

Косвенная адресация (определение принадлежности) элемента используется совместно с указателем на структуру (или объединение) для идентификации того или иного элемента этих структур (или объединения). Предположим, что ptrstr является указателем на структуру, a member - элементом, указанным в структурном шаблоне. Тогда ptrstr -> member определяет, что это элемент структуры, на которую ссылается указатель. Операцию косвенной адресации элемента можно применять аналогичным образом и к объединениям.

Пример:

Struct {

 int code;

 float cost;

} item, *ptrst;

Ptrst = &item;

Ptrst-> code = 3451;

Эти операторы присваивают значение элементу code структуры item. Следующие три выражения эквивалентны:

Ptrst -> code    

Item.code    

(*ptrst).code.

VII. Дополнительные операции.

sizeof	Выдает размер (в байтах) операнда, стоящего справа. Операндом может быть обозначение типа, заключенное в скобки, как, например, в sizeof(float), либо имя конкретной переменной или определенного массива и т. д., как, например, в sizeof foo.
(type)	Операция приведения типа: превращает следующее за ней значение в тип, определенный ключевым словом (или словами), заключенным в скобки. Например, (float)9 превращает целое 9 в число с плавающей точкой 9.0. Операция "запятая" связывает два выражения в одно и гарантирует, что левое выражение будет вычислено первым. Типичным примером использования является включение дополнительной информации в управляющее выражение цикла for:for(step = 2, fargo = 0; fargo < 1000; step *= 2) fargo + = step;
?:	Операция условия имеет три операнда, каждый из которых является выражением. Они расположены следующим образом:выражение1 ? выражение2 : выражение3. Значение всего выражения равно значению выражения2, если выражение1 истинно, и значению выражения3 в противном случае.

Примеры:

(5 > 3) ? 1 : 2 имеет значение 1.

(3 > 5) ? 1 : 2 имеет значение 2.

(a > b) ? а : b имеет значение большего а и b.

ПРИЛОЖЕНИЕ Г. ТИПЫ ДАННЫХ И КЛАССЫ ПАМЯТИ  

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

Ключевые слова: Основные типы данных определяются с помощью следующих семи ключевых слов: int, long, short, unsigned, char, float, double

Целые со знаком: Могут иметь положительные и отрицательные значения.

Int: основной тип целых чисел для конкретной системы.

Long или long int: могут иметь целое как минимум такого же размера, как самое большое int и, возможно, больше.

Short или short int: самое большое целое типа short не больше самого большого int, а возможно, и меньше. Обычно long должно быть больше short, a int должно быть таким же, как одно из них. Например, версия языка Си Lattice С для компьютера IBM PC имеет 16-разрядные целые типа short и int и 32-разрядные long. Все это зависит от используемой системы.

Целые без знака: имеют только нулевые и положительные значения. Они не могут быть больше самого большого возможного положительного числа.

Ключевое слово: unsigned используется перед обозначением типа: unsigned int, unsigned long, unsigned short.

Отдельно стоящее unsigned обозначает то же самое, что и unsigned int.

Символы: это типографские знаки, такие, как А, & и +.

Обычно каждый из них занимает в памяти только один байт.

Char: ключевое слово для этого типа.

Числа с плавающей точкой: они могут иметь положительные и отрицательные значения.

Float: основной (для используемой системы) размер чисел с плавающей точкой.

Double или long float: больший (возможно) элемент для размещения чисел с плавающей точкой. С его помощью в принципе можно использовать больше значащих цифр и, возможно, больший порядок.

Как описать простую переменную:

     1. Выберите необходимый тип.

     2. Выберите имя для переменной.

     3. Используйте следующий формат для оператора описания:

        обизначение-типа имя-переменной;

Обозначение-типа состоит из одного или более ключевых слов типа. Вот несколько примеров:

Int erest;unsigned short cash;

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

Char ch, init, ans;

     5. Можно инициализировать ту или иную переменную в операторе описания:

Float mass = 6.0E24;

Классы памяти.

I.Ключевые слова:

Auto, external, static, register.

II. Основные замечания

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

III. Свойства

Классы, перечисленные выше пунктирной линии, описываются внутри функции.

Классы, перечисленные ниже этой линии, определяются вне функции.  

Класс памяти	Ключевое слово	Продолжительность	Область деиствия
Автоматический	auto	Временно	Локальная
Статический	static	Постоянно	Локальная
Внешняя	extern	Постоянно	Глобальная (все файлы)
Внешняя статическая	static	Постоянно	Глобальная (один файл)

ПРИЛОЖЕНИЕ Д. УПРАВЛЕНИЕ ХОДОМ ВЫПОЛНЕНИЯ ПРОГРАММЫ.

Язык Си имеет несколько конструкций, предназначенных для управления выполнением программы. Здесь мы кратко описываем операторы циклов (while, for и do while), ветвлений (if, if else и switch) и переходов (goto, break и continue).

Оператор while.

Ключевое слово: while.

Общие замечания:

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

Форма записи:

While(выражение) оператор;

"Оператор" повторяется до тех пор, пока выражение не станет ложным, или нулем.

Примеры:

 while(n++ < 100).

 printf(" %d %d\n", n, 2*n + 1);

While(fargo < 1000) {

  fargo = fargo + step;

  step = 2 * step;   }.

Оператор for.

Ключевое слово: for.

Общие замечания:

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

Форма записи: for(инициализация; проверка условия; коррекция) оператор;

Цикл повторяется до тех пор, пока проверяемое выражение не станет ложным, или нулем.

Пример:

 for(n = 0; n < 10; n++).

            printf(" %d %d\n", n, 2*n + 1);

Оператор do while.

Ключевые слова: do, while.

Общие замечания:

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

Форма записи:

Do оператор while(выражение).

Оператор повторяется до тех пор, пока выражение не станет ложным, или нулем.

Пример:

Do.

Scanf(" %d", &number) while(number != 20);

Использование операторов if для выбора вариантов 

Ключевые слова: if, else.

Общие замечания:

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

Форма 1:

If(выражение) оператор.

Оператор выполняется, если выражение истинно.

Форма 2:

If(выражение)

Оператор1 else.

Оператор2.

Если выражение истинно, выполняется оператор1. В противном случае выполняется оператор2.

Форма 3:

If(выражение1)

Оператор1 else if(выражение2)

Оператор2 else.

Оператор3.

Если выражение1 истинно, то выполняется оператор2.

Если выражение1 ложно, но выражение2 истинно, выполняется оператор2.

Если же оба выражения ложны, выполняется оператор3.

Пример:

If(legs == 4).

 printf(" Это, возможно, лошадь.\n");

Else if(legs > 4).

 printf(" Это не лошадь.\n");

Else   /* выполнить, если legs < 4 */

 { legs++;

   printf(" Теперь у нее еще одна нога.\n");

 }

Множественный выбор при помощи switch 

Ключевое слово: switch.

Общие замечания:

Управление программой переходит к оператору, имеющему значение выражения в качестве метки. Затем программа продолжает выполняться, проходя остальные операторы, если снова не произойдет переключения направления. И выражение, и метки должны иметь целые значения (включая тип char), а метки должны быть либо константами, либо выражениями, состоящими только из констант. Если ни одна метка не соответствует значению выражения, управление передается оператору, помеченному default, если он существует. В ином случае управление передается оператору, следующему за оператором switch.

Форма записи:

Switch(выражение)

{

     case метка1 : оператор1;

     case метка2 : оператор2;

     default     : оператор3;

}

Можно записывать более двух помеченных операторов, а вариант default не обязателен.

Пример:

Switch(буква) {

Case 'a' :

Case 'е' : printf(" %d гласная\n", буква);

Case 'с' :

Case 'n' : printf(" %d в \" наборе саnе \" \n", буква);

Default  : printf(" Прекрасный день. \n");

}

Если буква имеет значение 'а' или 'е', печатаются все три сообщения; 'с' и 'n' вызывают печать двух последних строк. Все остальные значения приводят к печати последнего сообщения.

Переходы в программе.

Ключевые слова: break, continue, goto.

Общие замечания:

Эти три команды вызывают переход от одного оператора программы к другому, расположенному в ином месте (в теле программы).

Break.

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

Пример:

Switch(number) {

 case 4: printf(" Хороший выбор!\n");

 break;

 case 5: printf("Это неплохой выбор. \n");

 break;

 default: printf("Это плохой выбор.\n");

Continue.

Команда continue может использоваться с любыми тремя формами цикла, но не со switch. Она приводит к тому, что управление программой игнорирует оставшиеся операторы цикла. Для цикла while или for начинается следующий шаг цикла. Для цикла do while проверяется условие выхода, а затем, если нужно, начинается следующий шаг цикла:

Пример:

While((ch = getchar( )) != EOF) {

 if(ch == ' ') continue;

 putchar(ch);

 chcount ++; }.

Этот фрагмент программы выполняет эхо-копирование и подсчет символов, не являющихся пробелами.  

Goto.

Оператор goto вызывает передачу управления в программе оператору, помеченному указанной меткой. Для отделения помеченного оператора от его метки используется двоеточие. Метке присваивается имя по правилам, принятым для имени переменной. Помеченный оператор может находиться до или после оператора goto.

Форма записи: goto label;

...

Label : statement 

Пример:

Top : ch = getchar( );

If(ch != 'y') goto top; 

ПРИЛОЖЕНИЕ Е. МАНИПУЛЯЦИИ РАЗРЯДАМИ: ОПЕРАЦИИ И ПОЛЯ.

Для некоторых программ необходима (илн по крайней мере полезна) возможность манипулировать отдельными разрядами в байте или слове. Например, часто варианты режимов устройств ввода-вывода устанавливаются байтом, в котором каждый разряд действует как признак "включено-выключено". В языке Си есть ДВА средства, помогающие манипулировать разрядами. Во-первых, набор из шести "поразрядных" операций, выполняющихся над разрядами. Во-вторых, форма данных, называемая field (поле), дающая доступ к разрядам переменной типа int. Теперь мы кратко опишем эти характерные черты языка Си.

Операции.

В языке Си предусматриваются поразрядные логические операции и операции сдвига. Далее мы будем записывать значения в двоичном коде, чтобы вы могли видеть, как выполняются операции. В реальных программах используются целые переменные или константы, записанные в обычной форме. Например, вместо (00011001) можно использовать 25 или 031, либо даже 0х19. В наших примерах будут применяться 8-разрядные числа, в которых разряды пронумерованы от 7 до 0 слева направо.

Поразрядные логические операции.

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

~ : Дополнение до единицы, или поразрядное отрицание

Эта унарная операция изменяет каждую 1 на 0, а 0 на 1. Поэтому.

~(10011010) == (01100101).

&: Поразрядное И

Эта бинарная операция сравнивает последовательно разряд за разрядом два операнда. Для каждого разряда результат равен 1, если только оба соответствующих разряда операндов равны 1. (В терминах "истинно-ложно" результат получается истинным, если только каждый из двух одноразрядных операндов является истинным.) Так,

(10010011) & (00111101) == (00010001).

Потому что только четвертый и первый разряды обоих операндов содержат 1.

| : Поразрядное ИЛИ

Эта бинарная операция сравнивает последовательно разряд за разрядом два операнда. Для каждого разряда результат равен 1, если любой из соответствующих разрядов операндов равен 1. [В терминах "истинно-ложно" результат получается истинным, если один из двух (или оба) одноразрядных операндов является истинным.] Так,

(10010011) | (00111101) == (10111111).

Потому что все разряды, кроме шестого, в одном из двух операндов имеют значение 1.

^: Поразрядное исключающее ИЛИ

Эта бинарная операция сравнивает последовательно разряд за разрядом два операнда. Для каждого разряда результат равен 1, если один нз двух (но не оба) соответствующих разрядов операндов равен 1. [В терминах "истинно-ложно" результат получается истинным, если один из двух (но не оба) одноразрядных операндов является истинным.] Поэтому.

(10010011) ^ (00111101) == (10101110).

Заметим, что, поскольку нулевой разряд в обоих операндах имеет значение 1, нулевой разряд результата имеет значение 0.

Применение

Описанные выше операции часто используются для установки некоторых разрядов, причем другие разряды остаются неизменными. Например, предположим, что мы определили MASK в директиве #define MASK, равным 2, т. е. двоичному значению 00000010, имеющему ненулевое значение только в первом разряде. Тогда оператор.

Flags = flags & MASK;

Установит все разряды flags (кроме первого) в 0, потому что любое значение разряда при выполнении операции. & дает 0, если разряд второго операнда равен 0. Однако первый разряд останется неизменным. (Если первый разряд операнда содержит 1, то результат операции 1 & 1 равен 1, а если первый разряд имеет значение 0, то 0 & 1 будет равно 0.) Аналогично оператор.

Flags = flags | MASK;

Установит первый разряд в 1 и оставит все остальные разряды неизменными. Это происходит потому, что любое значение разряда при выполнении операции 1, если разряд второго операнда равен нулю, остается без изменения, а если разряд второго операнда равен 1, то первый разряд результата будет иметь значение 1.

Поразрядные операции сдвига.

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

&& : Сдвиг влево

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

(10001010) << 2 == 00101000.

Где каждый разряд сдвинулся на две позиции влево.

>> : Сдвиг вправо

Эта операция сдвигает разряды левого операнда вправо на число позиций, указанное правым операндом. Разряды, сдвигаемые за правый предел левого операнда, теряются. Для чисел типа unsigned позиции, освобождающиеся слева, заполняются нулями. Для чисел со знаком результат зависит от типа ЭВМ. Освобождающиеся позиции могут заполняться нулями или значением знакового разряда (самого левого). Для значений без знака имеем.

(10001010) >> 2 == (00100010).

Где каждый разряд переместился на две позиции вправо.

Применение

Эти операции выполняют сдвиг, а также эффективное умножение и деление на степени 2:

Number << n     умножает number на 2 в n-й степени.

Number >> n     делит number на 2 в n-й степени, если число неотрицательное.

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

Поля.

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

Struct {

Unsigned autfd: 1;

Unsigned bldfc: 1;

Unsigned undln: 1;

Unsigned itals: 1;

} prnt;

Переменная prnt содержит теперь четыре 1-разрядных ноля. Обычную операцию принадлежности элемента структуры можно использовать для присвоения значении отдельным полям:

Prnt.itals = 0;

Prnt.undln = 1;

Поскольку каждое поле состоит только из одного разряда, мы можем использовать для присваивания лишь значение 0 или 1.

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

Размер поля не ограничивается одним разрядом. Мы можем делать, например, так:

Struct {

Unsigned code1 : 2;

Unsigned code2 : 2;

Unsigned code3 : 8;

} prcode;

Таким путем создаются два 2-разрядных поля и одно 8-разрядное. Мы можем выполнять присваивания, подобные следующим:

Prcode.code1 = 0;

Prcode.code2 = 3;

Prcode.code3 = 102;

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

Что произойдет, если общее число объявленных вами разрядов превысит размер переменной типа int? В этом случае используется следующая ячейка памяти типа int. Одиночное поле не может перекрывать границу между двумя int, компилятор автоматически сдвигает определение перекрывающего поля таким образом, чтобы данное поле было выравнено по границе int. Если это происходит, он оставляет в первом int безымянное "пустое место".

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

Struct {

         field1 : 1;

                  : 2;

         field2 : 1;

                  : 0;

         field3 : 1; } stuff;

Здесь есть 2-разрядный промежуток между stuff.field1 и stuff.field2, a stuff.field3 запоминается в следующем int.

Порядок размещения полей в int зависит от типа ЭВМ. В одних машинах поля располагаются слева направо, в других - справа налево.

ПРИЛОЖЕНИЕ Ж. ДВОИЧНЫЕ И ДРУГИЕ ЧИСЛА 

Двоичные числа.

В основе способа, который мы обычно используем для записи чисел, лежит число 10. Может быть, вы когда-то слышали, что число 3652 имеет 3 в позиции тысяч, 6 в позиции сотен, 5 в позиции десятков и 2 в позиции единиц. Поэтому мы можем представить число 3652 в виде.

3 ´ 1000 + 6 ´ 100 + 5 ´ 10 + 2 ´ 1.

Однако 1000 - это 10 в кубе, 100 - десять в квадрате, 10 - десять в первой степени, а 1, как принято в математике, 10 (или любое положительное число) в нулевой степени. Следовательно, мы можем записать 3652 как.

3 ´ 10³ + 6 ´ 10² + 5 ´ 10¹ + 2 ´ 10⁰

Так как наша система записи чисел основывается на степенях десяти, мы можем сказать, что 3652 записывается по основанию 10.

Вероятно, мы создали такую систему потому, что имеем 10 пальцев на руках. Компьютер же, в каком-то смысле, имеет только два "пальца", поэтому его можно установить только в состояние 0 или 1 (выключено или включено). Это делает систему с основанием 2 естественной для компьютера. Как она работает? Используются степени 2 вместо степеней 10. Например, такое двоичное число, как 1101, означало бы.

1 ´ 2³ + 1 ´ 2² + 0 ´ 2¹ + 1 ´ 2^0.

В десятичной записи оно становится равным.

1 ´ 8 + 1 ´ 4 + 0 ´ 2 + 1 ´ 1 = 13.

Система с основанием 2 (или "двоичная") позволяет выразите любое число (если у пас достаточно разрядов в двоичной системе, как комбинацию единиц и нулей. Это очень "приятно" для компьютера, особенно если учесть, что у него нет иного выбора. Посмотрим, как работает такой механизм для 1-байтного целого числа.

Можно считать его 8 разрядов пронумерованными слева направо от 7 до 0. Такие "номера разрядов" соответствуют степеням 2. Представьте себе, что байт выглядит примерно так:

Здесь 128 - это 2 в 7-и степени и т. д. Самое большое число, которое может содержать этот байт, имеет во всех разрядах 1 : 11111111. Значение такого двоичного числа.

128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255.

Самое маленькое двоичное число было бы равно 00000000, или просто 0. Байт может содержать числа от 0 до 255 для всех 256 возможных значений.

Двоичные числа с плавающей точкой.

 Числа с плавающей точкой хранятся в памяти в виде двух частей: двоичной дроби и двоичного порядка. Посмотрим, как это делается.

Двоичные дроби

Обычную дробь .324 можно представить в виде.

3/10 + 2/100 + 4/1000,

Где знаменатели - увеличивающиеся степени 10. В двоичной дроби мы используем в качестве знаменателей степени 2. Поэтому двоичную дробь .101 можно записать в виде.

1/2 + 0/4 + 1/8,

Что в десятичном виде даст.

.50 + .00 + .125.

Или .625.

Многие дроби, такие как 1/3, нельзя точно предоставить десятичной форме, и аналогично многие дроби нельзя точно представить в двоичной форме. Действительно, только дроби, которые являются комбинациями чисел, кратных степеням 1/2, можно представить точно. Поэтому 3/4 и 7/8 можно точно представить как двоичные дроби, а 1/3 и 2/5 нельзя.

Представление чисел с плавающей точкой

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

Другие основания системы счисления.

Пользователи компьютеров часто применяют системы счисления по основанию 8 или 16. Так как 8 и 16 являются степенями 2, эти системы более тесно связаны с двоичной системой счисления компьютеров, чем десятичная система.

Восьмеричные числа

"Восьмеричными" называются числа в системе счисления по основанию 8. В этой системе различные позиции в числе представляют степени числа 8. Мы используем для этого цифры от 0 до 7. Например, восьмеричное число 451 (записываемое как 0451 на языке Си) представляется в виде.

4 ´ 8² + 5 ´ 8¹ + 1 ´ 8¹ = 297 (по основанию 10).

Шестнадцатеричные числа

"Шестнадцатеричными" (или hex) называются числа в системе по основанию 16. Поскольку у нас нет отдельных цифр для предстанления значении от 10 до 15, мы используем в этих целях буквы от А до F. Например, шестнадцатеричное число A3F (записанное как 0´А3F на языке Си) представляется как.

10 ´ 16² + 3 ´ 16¹ + 15 ´ 16⁰ = 2623 (по основанию 10).

ПРИЛОЖЕНИЕ З. "МУЗЫКА" В СИСТЕМЕ IBM PC.

Громкоговорителем персонального компьютера IBM PC можно управлять, используя его порты ввода-вывода. В гл. 6 мы обсуждали, как применять порт 97 для возбуждения звукового сигнализатора компьютера IBM PC. Мы применяли специальные функции ввода-вывода inp( ) и outp( ), которые предусмотрены в некоторых компиляторах с языка Си для систем IBM PC. Большинство компиляторов IBM PC позволяют также применять эквивалентные средства на языке ассемблера. Мы видели, как надо использовать циклы, реализующие временную задержку, для управления продолжительностью звучания; в этом приложении мы расширим наш подход, что позволит нам выбирать и частоту. Мы составим функцию, аргументами которой являются частота и продолжительность звучания. Затем покажем образец программы, использующей функцию tone( ) для превращения части клавиатуры машины IBM PC в простую музыкальную клавиатуру.

Функция tone ( )  

Вот заголовок нашей функции:

Tone(freq, time);

Int freq, time;

Переменная freq описывает частоту тона, выражаемую в герцах (Гц), т. е. числом колебаний в секунду. Переменная time характеризует продолжительность звучания в десятых долях секунды, значение 10 для time означает продолжительность 10 десятых, или 1 секунда. Теперь мы должны разработать способы передачи этой информации на звуковоспроизводящее устройство. Сначала рассмотрим продолжительность звучания.

Продолжительность звучания.

Мы можем регулировать продолжительность так, как было указано в гл. 6. Вспомним, что громкоговоритель управляется устройством, называемым "Программируемый параллельный интерфейсный контроллер 8255". Специальные каналы ввода-вывода, называемые портами, связывают этот и другие контроллеры с "мозгом" системы, микропроцессором 8088. Мы используем порт 97 для включения громкоговорителя, цикл, чтобы отмечать время, и затем порт 97 для отключения громкоговорителя. Вот фрагмент программы, которая будет выполнять эти действия:

#define TIMESCALE.

1270         /* число отсчетов времени в 0,1 с */

#define BEEPPORT  97 /* порт управляет громкоговорителем */

#define ON 79         /* сигнал включения громкоговорителя */

Count = TIMESCALE  *time;  /* преобразование времени.

В единицы таймера */

Port = inp(BEEPPORT);     /* запоминание состояния порта */

Outp(BEEPPORT, ON);       /* включение громкоговорителя */

For(i = 0; i < count; i++).

;                          /* отметка времени */

Outp(ВЕЕРРОRТ, port);      /* выключение громкоговорителя, восстановление состояния */

Значение count (число отсчетов) дает время, в течение которого громкоговоритель включен. Коэффициент TIMESCALE преобразует десятые доли секунды в эквивалентное количество отсчетов времени. Конечно, мы должны установить требуемую частоту звука до того, как зазвучит громкоговоритель, поэтому рассмотрим этот параметр.  

Частота звука.

Частоту звука можно установить при помощи другого устройства, называемого "Программируемым интервальным таймером 8253". Этот контроллер в числе прочего определяет, сколько импульсов в секунду следует послать на громкоговоритель. Устройство 8253 вырабатывает базовую частоту 1,190,000 Гц, которая значительно выше граничной частоты восприятия звука человеком. Однако мы можем послать на устройство 8253 число для деления этой базовой частоты. Например, если мы направляем туда 5000, то получаем частоту, следования импульсов.

 1,190,000/5000 = 238 Гц,

 которая немного ниже среднего звука си (нота, а не версии более низкого класса рассматриваемого языка). Если мы знаем, какая частота freq нам нужна, можно вычислить требуемый делитель, скажем, так:

 divisor = 1,190,000/freq;

 Наша функция позволяет сделать это, в связи с чем нам нужно только знать, как подать значение переменной divisor на устройство 8253. Теперь требуется использовать еще два порта.

Первый шаг заключается в установке таймера 8253 в правильный рабочий режим для приема делителя. Это достигается посылкой значения 182 (0´В6 в шестнадцатеричном коде) через порт 67. Как только такая посылка будет выполнена, можно использовать порт 66 для передачи делителя.

Посылка делителя представляет собой несложную задачу. Сам делитель является 16-разрядным числом, но его следует передавать двумя частями. Сначала мы посылаем младший байт, или последние 8 разрядов числа, а затем старший байт, т.е. начальные 8 разрядов числа. В следующей программе мы называем эти части lobyt и hibyt и вычисляем их значения через divisor:

Lobyt = divisor % 256;

Hibyt = divisor % 256;

Можно также использовать поразрядные операции:

Lobyt = divisor & 255;

Hibyt = divisor >> 8;

Первый оператор в каждой паре строк примеров устанавливает первые восемь разрядов в 0, оставляя в последних восьми разрядах первого байта число. Проверьте результаты операцией получения модуля и поразрядной операцией И, чтобы увидеть, как это делается. Второй оператор каждой пары берет исходное значение divisor и сдвигает его на 8 позиций вправо (что эквивалентно делению на 2⁸, или на 256). Восемь левых разрядов устанавливаются в 0, сохраняя 8-разрядное число, содержащее исходные значения восьми левых разрядов.

Ниже показана такая функция целиком:

/* tone(freq, time) -- устанавливает звук заданной частоты и продолжительности */

#define TIMERMODE  182  /* код установки таймера в нужный режим */

#define FREQSCALE 119000L /* базовая частота в герцах */

#define TIMESCALE 1230L /* число отсчетов времени в 0,1 с */

#define T_MODEPORT 67 /* порт управляет режимом работы таймера */

#define FREQPORT  66 /* порт регулирует частоту звука*/

#define BEEPPORT  97 /* порт управляет громкоговорителем */

#define ON   97 /* сигнал включения громкоговорителя */

Tone(freq, time).

Int freq, time;

{

Int hibyt, lobyt, port;

Long i, count, divisor;

Divisor = FREQSCALE/freq; /* масштабирование частоты в единицах таймера */

Lobyt = divisor % 256; /* разбивает целое */

Hibyt = divisor / 256; /* на два байта */

Count = TIMESCALE * time; /* преобразует время в единицы таймера */

Outp(T_MODEPORT, TIMERMODE); /* подготавливает таймер к вводу */

Outp(FREQPORT, lobyt); /* устанавливает младший байт регистра таймера */

Outp(FREQPORT, hibyt); /* устанавливает старший байт регистра таймера */

Port = inp(BEEPPORT); /* запоминает состояние порта */

Outp(BEEPPORT, ON) /* включает громкоговоритель */

For(i = 0, i < count; i++).

;          /* отметка задержки */

Outp(BEEPPORT, port); /* выключает Громкоговоритель, восстанавливает состояние */

Мы определяем TIMESCALE в директиве #define как целое тип long, потому что вычисление TIMESCALE * time будет выполняться для типа long, а не int. Иначе результат, если он больше 32767 будет усекаться перед занесением в count. 

Использование функции tоnе( ).

Наша функция tone( ) в значительной степени дублирует действие оператора SOUND языка Бейсик для компьютера IBM PC Здесь мы используем ее для создания довольно ограниченной ( 8 нот, одна октава) клавиатуры, в которой используются 8 клавишей, начиная с А, для воспроизведения нот. Ниже приведена соответствующая программа, а также некоторые пояснения к ней.

/* простая музыкальная клавиатура */

#include <conio.h> /* использует небуфсризованный ввод-вывод */

#include <ctype.h>

#define С 262 /* определяет частоты */

#define D 294.

#define E 330.

#define F 349.

#define G 392.

#define А 440.

#define В 494.

#define C2 524.

Main( ).

{

Int key, freq, tempo, time;

Puts(" Введите, пожалуйста, основной темп: 10 = 1 с.");

Scanf(" %d", &tempo);

Printf(" %d \n \r", tempo);  /* эхо-ввод */

Puts(" Спасибо. Используйте клавиши а - k для воспроизведения нот.\n\r");

Puts(" Клавиша переключения регистра удваивает продолжительность звучания.

    Символ ! прекращает работу.");

While((key = getchar( )) != '!').

{ time = isupper(key)? 2 * tempo : tempo;

  key = tolower(key);

  switch (key) {

   case 'a' :  tone(C, time);

    break; 

   case 's' : tone(D, time);

    break;

   case 'd' :   tone(E, time);

    break;

   case 'f' :  tone(E, time);

    break;

   case 'g' :   tone(G, time);

    break;

   case 'h' :  tone(A, time);

    break;

   case 'j' :  tone(B, time);

    break;

   case 'k' :  tone(C2, time);

    break;

   default :    break; }.

 }

Рuts("До свидания!\n\r");

} }

Главной особенностью созданной программы является оператор switch, который присваивает разные звуки восьми клавишам от А до К. Кроме того, программа удваивает продолжительность звучания ноты, если вы используете верхний регистр. Эта продолжительность (time) устанавливается перед оператором switch, затем верхний регистр переключается на нижний, чтобы сократить число необходимых меток.

Вторая важная особенность заключается в том, что мы используем заголовочный файл conio.h. Этот файл содержит директивы #define, которые заменяют обычные функции ввода-вывода [такие, как getchar( )] на версии "пультового ввода-вывода", являющиеся не буферизованными. И в результате, если вы нажимаете, скажем, клавишу [а], немедленно звучит нота, и вам не нужно нажимать клавишу [ввод]. Между прочим, эти функции не только не выполняют эхо-печать, но и не начинают автоматически новую строку. Поэтому мы вставили оператор printf( ) для эхо-печати вводимой переменной tempo и использовали символы \n и \r для перемещения курсора на новую строку и возврата его к левой стороне экрана. Если вы хотите, чтобы символы, которые соответствуют нажимаемым клавишам, отображались одновременно на экране, вставьте.

Putchar(key);

В программу.

Хотя ввод не буферизован, клавиатура имеет свой собственный буфер. Это позволяет вам, если вы хотите, заранее набирать все требуемые символы. А ноты будут звучать в собственном устойчивом темпе. Вот, пример, начало мелодии "Радость мира".

KjhGfdsA.

Предоставляем вам возможность закончить эту мелодию.

ПРИЛОЖЕНИЕ И. РАСШИРЕНИЕ ЯЗЫКА СИ.

 Версия 7 ОС UNIX предоставляет два важных расширения языка Си. Первое заключается в том, что можно использовать саму структуру (а не только адрес или элемент структуры) в качестве аргумента функции. Второе расширение позволяет использовать новую форму данных, называемую "перечислимый тип данных". Теперь рассмотрим эти расширения.

Структуры в качестве аргументов функции.

В не расширенном языке Си можно передавать функции адрес структуры. Например, если montana является структурной переменной структурного типа player, мы можем обратиться к функции следующим образом:

Stats(&montana);

Функция stats( ) будет иметь примерно такой заголовок:

Stat(name) struct player * name;

После вызова функции указатель name будет ссылаться на структуру montana и функция будет использовать montana в своих манипуляциях.

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

Stats(montana);

Теперь функция stats( ) должна иметь несколько иной заголовок:

Stats(name) struct player name;

На этот раз после вызова функции создается новая структурная переменная типа player. Новая переменная получает название name, и каждый элемент name имеет такое же значение, как и соответствующий элемент структуры montana.

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

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

Stats(montana);

Но на самом деле интерпретируют его как.

Stats(&montana);

В этом случае передается адрес, и функция работает с самой исходной структурной переменной, а не с ее копией. 

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

Ключевое слово enum позволяет создавать новый тип и определять значения, которые он может иметь. Приведем пример:

Enum spectrum (red, orange, yellow, green, blue, violet);

Enum spectrum color;

Первый оператор объявляет новый тип: spectrum. Он перечисляет также возможные значения переменных типа spectrum: red, orange и т. д. Они являются константами типа spectrum так же, как 4 является константой типа int, a 'g' - константой типа char.

Второй оператор объявляет color переменной типа spectrum. Вы можете присвоить переменной color любую константу типа spectrum; например:

Color = green;

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

Рассмотрим характер этих новых констант и операций, которые можно выполнять с использованием переменных типа.

Enum константы.

Как компьютер запоминает что-нибудь подобное red? Он может рассматривать это как символьную строку, но у нее нет кавычек. И действительно, red и другие enum константы запоминаются как целые числа. Например, попробуйте выполнить.

Printf("red = %d, orange = %d\n", red, orange);

И с учетом вышеуказанных описании вы получите такой результат:

Red = 0, orange = 1.

По существу переменная red и ее "сестры" действуют как синонимы целых чисел от 0 до 5. Результат подобен использованию.

#define red  0.

За исключением того, что соответствие, установленное при помощи оператора enum более ограниченно. Например, если index является переменной типа int, то оба нижеследующих оператора недопустимы:

Index = blue; /* несоответствие типа */

Color = 3;    /* несоответствие типа */

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

Значения по умолчанию.

Наш пример проиллюстрировал присваивание константам значений по умолчанию. Константам, появляющимся в описании enum, присваиваются целые числа 0, 1, 2 и т. д. в порядке их расположения. Так, описание.

Enum kids {nippy, slats, skip, nana, liz};

Присваивает nаnа значение 3.

Присвоенные значения.

Можно выбирать значения, которые вы хотите присвоить константам, но они должны быть целого типа (включая char). Для этого включите желаемые значения в описание:

Enum levels {low = 100, medium = 500, high = 2000};

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

Enum feline {cat = 20, tiger, lion, puma};

Присваивает переменной tiger значение 21, переменной lion - значение 22 и puma - значение 23.

Операции.

Теперь рассмотрим, что можно и нельзя делать с величинами типа enum.

Вы можете присвоить константу типа enum переменной того же типа.

Enum feline pet;

Pet = tiger;

Нельзя использовать другие операции присваивания:

Pet += cat; /* недопустимо */

Можно провести сравнение с целью выявления равенства или неравенства:

If ( per = = cat) ...

If ( color ! = violet)...

Нельзя использовать другие операции отношения:

If(color > yellow) /* недопустимо */

Можно применять арифметические операции к константам типа enum:

Color = red + blue;

Pet = puma * lion;

Имеют ли такие выражения какой-то смысл - это уже другой вопрос.

Нельзя использовать арифметические операции для переменных типа enum:

Color = color + green; /* недопустимо */

Нельзя использовать операции увеличения и уменьшения:

Color++ ; /* недопустимо */

Нельзя использовать константу типа enum для индекса массива:

Marbles[red] = 23; /* недопустимо */ 

ПРИМЕНЕНИЕ.

Основная причина использования типа enum заключается в улучшении читаемости программ. Если вы имеете дело с некоторым видом цветовых кодов, то использование red и blue что обычно типы enum предназначены для использования внутри программы, а не для ввода-вывода. Например, если вы хотите ввести значение для переменной color типа spectrum, то должны были бы ввести, скажем, целое число 1, а не слово orange. (Конечно, можно было бы создать функцию ввода, которая восприняла бы строку "orange" и затем преобразовала бы ее в целое число orange.)  

ПРИЛОЖЕНИЕ К. ТАБЛИЦА КОДОВ ASCII.

Числовые преобразования

Числовые преобразования десятичное - шестнадцатеричное - восьмеричное - двоичное - ASCII.

Десятеричное	Шестнадцатеричное	Восьмеричное	Двоичное	ASCII	Ключ*
X10	X16	X8	PXx
0	0	0	0	NUL	CTRL/I
1	1	1	10000001	SOH	CTRL/A
2	2	2	10000010	STX	CTRL/B
3	3	3	11	ЕТХ	CTRL/C
4	4	4	10000100	EOT	CTRL/D
5	5	5	101	ENQ	CTRL/E
6	6	6	110	АСК	CTRL/F
7	7	7	10000111	BEL	CTRL/G
8	8	10	10001000	BS	СТRL/Н,возврат
9	9	11	1001	HT	CTRL/I,табуляция
10	0А	12	1010	LF	CTRL/J,новая строка
11	0B	13	10001011	VT	CTRL/K
12	0С	14	1100	FF	CTRL/L
13	0D	15	10001101	CR	CTRL/M,возврат
14	0E	16	10001110	SO	CTRL/N
15	0F	17	1111	SI	CTRL/O
16	10	20	10010000	DLE	CTRL/P
17	11	21	10001	C1	CTRL/Q
18	12	22	10010	DC2	CTRL/R
19	13	23	10010011	DC3	CTRL/S
20	14	24	10100	DC4	CTRL/T
21	15	25	10010101	NAK	CTRL/U
22	16	26	10010110	SYN	CTRL/V
23	17	27	10111	TB	CTRL/W
24	18	30	11000	CAN	CTRL/X
25	19	31	10011001	EM	CTRL/Y
26	1A	32	10011010	SUB	CTRL/Z
27	1B	33	11011	ESC	ESC,возврат
28	1С	34	10011100	FS	СТRL<
29	1D	35	11101	GS	CTRL/
30	1E	36	11110	RS	CTRL/=
31	1F	37	10011111	US	СТRL/-
32	20	40	10100000	SP	Пробел
33	21	41	100001	!	!
34	22	42	100010	"	"
35	23	43	10100011	#	#
36	24	44	100100	$	$
37	25	45	10100101	½	½
38	26	46	10100110	&	&
39	27	47	100111	'	'
40	28	50	101000	(	(
41	29	51	10101001	)	)
42	2А	52	10101010	*	*
43	2В	53	101011	+	+
44	2С	54	10101100	'	'
45	2D	55	101101	-	-
46	2Е	56	101110	.	.
47	2F	57	10101111	/	/
48	30	60	110000	0	0
49	31	61	10110001	1	1
50	32	62	10110010	2	2
51	33	63	110011	3	3
52	34	64	10110100	4	4
53	35	65	110101	5	5
54	36	66	110110	6	6
55	37	67	10110111	7	7
56	38	70	10111000	8	8
57	39	71	111001	9	9
58	3А	72	111010	:	:
59	3В	73	10111011	;	;
60	3С	74	111100	<	<
61	3D	75	10111101	=	=
62	3Е	76	10111110	>	>
63	3F	77	111111	?	?
64	40	100	11000000	@	@
65	41	101	1000001	А	А
66	42	102	1000010	в	в
67	43	103	11000011	с	с
68	44	104	1000100	D	D
69	45	105	11000101	Е	Е
70	46	106	11000110	F	F
71	47	107	1000111	G	G
72	48	110	1001000	н	Н
73	49	111	11001001	I	I
74	4A	112	11001010	J	J
75	4В	113	1001011	к	К
76	4С	114	11001100	L	L
77	4D	115	1001101	M	M
78	4Н	116	1001110	N	N
79	4F	117	11001111	0	0
80	50	120	1010000	P	Р
81	51	121	11010001	Q	Q
82	52	122	11010010	R	R
83	53	123	1010011	S	S
84	53	124	11010100	T	Т
85	55	125	1010101	U	U
86	56	126	1010110	V	V
87	57	127	11010111	W	W
88	58	130	11011000	X	X
89	59	131	1011001	Y	Y
90	5А	132	1011010	Z	Z
91	5В	133	11011011	[	[
92	5С	134	1011100	/	/
93	5D	135	11011101	]	]
94	5Е	136	11011110	^	^
95	5F	137	1011111	-	-
96	60	140	1100000	.	.
97	61	141	11100001	a	a
98	62	142	11100010	b	b
99	63	143	1100011	с	c
100	64	144	11100100	d	d
101	65	145	1100101	е	е
102	66	146	1100110	f	f
103	67	147	11100111	g	g
104	68	150	11101000	h	h
105	69	151	1101001	i	I
106	6А	152	1101010	j	j
107	6В	153	11101011	k	k
108	6С	154	1101100	l	1
109	6D	155	11101101	m	m
110	6Е	156	11101110	n	n
111	6F	157	1101111	o	о
112	70	160	11110000	p	p
113	71	161	1110001	q	q
114	72	162	1110010	r	r
115	73	163	11110011	s	s
116	74	164	1110100	t	t
117	75	165	11110101	u	u
118	76	166	11110110	v	v
119	77	167	1110111	w	w
120	78	170	1111000	x	x
121	79	171	11111001	y	y
122	7A	172	11111010	z	z
123	7B	173	1111011	R	R
124	7С	174	11111100	/	/
125	7D	175	1111101	T	T
126	7Е	176	1111110	~	~
127	7F	177	11111111	DEL	DEL,отмена символа