Приложения

ПРИЛОЖЕНИЕ А

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

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

Язык Си

Далее

Kernighan Brian W. and Ritchie Dennis M., The С Programming 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 С Programming 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. В неe включены некоторые мощные расширения этой системы, реализованные в Калифорнийском университете (Беркли).

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

Далее   Содержание

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

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

Циклы
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. Арифметические операции

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

nurse = 22;
ptr = &nurse; /* указатель на nurse */
val = *ptr

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

struct {
	int code;
	float cost;
			} item;
item.code = 1265;

struct {
	int code;
	float cost;
} item, *ptrst;
ptrst = &item;
ptrst-> code = 3451;

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

(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. Используйте следующий формат для oператора описания:
        обизначение-типа имя-переменной;

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

int erest;
unsigned short cash;

char ch, init, ans;

float mass = 6.0E24;

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

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

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

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

Пример:

for(n = 0; n < 10; n++)
	printf(" %d %d\n", n, 2*n + 1);

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

Форма записи:
do оператор while(выражение)

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

Пример:

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

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

Форма 1:
if(выражение) оператор
Оператор выполняется, если выражение истинно.

Форма 2:
if(выражение)
оператор1 else
оператор2
Если выражение истинно, выполняется oпepaтop1. В противном случае выполняется оператор2.

Форма 3:
if(выражение1)
oпepaтop1 else if(выражение2)
оператор2 else
оператор3
Если выражение1 истинно, то выполняется oпepaтop2.
Если выражение1 ложно, но выражение2 истинно, выполняется оператор2.
Если же оба выражения ложны, выполняется оператор3.

Пример:

if(legs == 4)
	printf(" Это, возможно, лошадь.\n");
else if(legs > 4)
	printf(" Это не лошадь.\n");
else   /* выполнить, если legs < 4 */
	{ legs++;
	  printf(" Теперь у нее еще одна нога.\n"); 
	}

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

Форма записи:
switch(выражение)
{
     case метка1 : оператор1;
     case метка2 : опeратор2;
     default     : оператор3;
}
Можно записывать более двух помеченных операторов, а вариант default не обязателен.

Пример:

switch(буква) { 
case 'a' :
case 'е' : printf(" %d гласная\n", буква);
case 'с' :
case 'n' : printf(" %d в \" наборе саnе \" \n", буква);
default  : printf(" Прекрасный день. \n");
}

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

break

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

Пример:

switch(number) {
	case 4: printf(" Хороший выбор!\n");
	break;
	case 5: printf("Этo неплохой выбор. \n");
	break;
	default: printf("Этo плохой выбор.\n");

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

Пример:

while((ch = getchar( )) != EOF) {
	if(ch == ' ') continue;
	putchar(ch);
	chcount ++; } 

Оператор 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;

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;

Порядок размещения полей в 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⁰

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

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 и оставляет двоичную дробь неизменной. Умножение на число, нe являющееся степенью 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(ВEEPPORT, 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( )] на версии "пультового ввода-вывода", являющиеся небуферизованными. И в результате, если вы нажимаете, скажем, клавишу [а], немедленно звучит нота, и вам нe нужно нажимать клавишу [ввод]. Между прочим, эти функции не только не выполняют эхо-печать, но и не начинают автоматически новую строку. Поэтому мы вставили оператор printf( ) для эхо-печати вводимой переменной tempo и использовали символы \n и \r для перемещения курсора на новую строку и возврата его к левой сторонe экрана. Если вы хотите, чтобы символы, которые соответствуют нажимаемым клавишам, отображались одновременно на экране, вставьте

putchar(key);

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

KjhGfdsA

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

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

Далее   Содержание

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

stats(&montana);

stat(name) struct player * name;

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

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

stats(montana);

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

#define red  0

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

index = blue; /* несоответствие типа */
color = 3;    /* несоответствие типа */

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

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

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

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

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

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

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

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

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

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

enum feline pet;
pet = tiger;

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

if ( per = = cat) ...
if ( color ! = violet)
...

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

color = red + blue;
pet = puma * lion;

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

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

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

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

[Содержание] [Вверх]
Язык Си	Приложения