Программирование Cи / Богатырев_Язык Си в системе Unix

А. Богатырёв, 1992-96 - 333 - Си в UNIX™

break;

}

tcsetattr(INPUT_CHANNEL, TCSADRAIN, &saved_modes);

}

/* Функция настройки на систему команд дисплея */ void tinit (void) {

/* static */ char Tbuf[2048];

/* Tbuf должен сохраняться все время, пока могут вызываться функции tgetstr().

*Для этого он либо должен быть static, либо вызов функции keyinit()

*должен находиться внутри tinit(), что и сделано.

*/

char *tname;

extern char *getenv();

if((tname = getenv("TERM")) == NULL){

printf("TERM не определено: неизвестный тип терминала.\n"); exit(2);

}

printf("Терминал: %s\n", tname);

/* Прочесть описание терминала в Tbuf */ switch (tgetent(Tbuf, tname)) {

case -1:

printf ("Нет файла TERMCAP (/etc/termcap).\n"); exit (1);

case 0:

printf ("Терминал '%s' не описан.\n", tname); exit (2);

case 1: break;

}

if(strlen(Tbuf) >= 1024)

printf("Описание терминала слишком длинное - возможны потери в конце описания\n");

keyinit(); /* инициализировать строки, пока Tbuf[] доступен */

}

void main(void){ setlocale(LC_ALL, ""); tinit();

/* keyinit(); */ dotest(); exit(0);

}

По поводу этого алгоритма надо сказать еще пару слов. Его модификация может с успехом применяться для поиска слов в таблице (команд, ключей в базе данных, итп.): список слов превращается в дерево. В таком поисковом алгоритме не требуются таймауты, необходимые при вводе с клавиатуры, поскольку есть явные терминаторы строк - символы '\0', которых нет при вводе с клавиатуры. В чем эффективность такого алгоритма? Сравним последовательный перебор при помощи strcmp и поиск в дереве букв:

"zzzzzzzzzza"

"zzzzzzzzzzb"

"zzzzzzzzzzbx"

"zzzzzzzzzzc"

"zzzzzzzzzzcx"

Для линейного перебора (даже в отсортированном массиве) поиск строки zzzzzzzzzzcx потребует

Всего: 57 шагов. Для поиска в дереве:

|_c__\0 |_x__\0

потребуется проход вправо (вниз) на 10 шагов, потом выбор среди 'a','b','c', потом - выбор среди '\0' и 'x'. Всего: 15 шагов. За счет того, что общий "корень" проходится ровно один раз, а не каждый раз заново. Но это и требует предварительной подготовки данных: превращения строк в дерево!

8.18. Напишите функцию для "экранного" редактирования вводимой строки в режиме CBREAK. Напишите аналогичную функцию на curses-е. В curses-ной версии надо уметь отрабатывать: забой (удаление символа перед курсором), отмену всей строки, смещение влево/вправо по строке, удаление символа над курсором, вставку пробела над курсором, замену символа, вставку символа, перерисовку экрана. Учтите, что параллельно с изменением картинки в окне, вы должны вносить изменения в некоторый массив (строку), которая и будет содержать результат. Эта строка должна быть аргументом функции редактирования.

Забой можно упрощенно эмулировать как

addstr( "\b \b" ); или

addch( '\b' ); delch();

Недостатком этих способов является некорректное поведение в начале строки (при x==0). Исправьте это!

8.19.На curses-е напишите функцию редактирования текста в окне. Функция должна возвращать массив строк с обрезанными концевыми пробелами. Вариант: возвращать одну строку, в которой строки окна разделяются символами '\n'.

8.20.Напишите функцию, рисующую прямую линию из точки (x1,y1) в (x2,y2). Указание: используйте алгоритм Брезенхема (минимального отклонения). Ответ: пусть функция putpixel(x,y,color) рисует точку в координатах (x,y) цветом color.

void line(int x1, int y1, int x2, int y2, int color){

int dx, dy, i1, i2, i, kx, ky; register int d; /* "отклонение" */ register int x, y;

short /* boolean */ l;

dy = y2 - y1; dx = x2 - x1; if( !dx && !dy ){

putpixel(x1,y1, color); return;

}

kx = 1; /* шаг по x */ ky = 1; /* шаг по y */

i1 = dy + dy; d = i1 - dx; i2 = d - dx; x = x1; y = y1;

for( i=0; i < dx; i++ ){ putpixel( x, y, color );

d += i2;

if( l ) y += ky; /* прирост высоты */ else x += kx;

8.21.Составьте программу, которая строит график функции sin(x) на отрезке от 0 до 2*пи. Учтите такие вещи: соседние точки графика следует соединять отрезком прямой, чтобы график выглядел непрерывным; не забывайте приводить double к int, т.к. координаты пикселов† - целые числа.

8.22.Напишите функцию, которая заполняет в массиве байт count бит подряд, начиная с x-ого бита от левого края массива:

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

Ответ (причем мы заполняем биты не просто единицами, а "узором" pattern):

void horizLine(char *addr,int x,int count,char pattern){ static char masks[8] = {

0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01 };

/* индекс в этом массиве равен числу 0-битов слева */ register i;

char mask;

short lbits, rbits; /* число битов слева и справа */

mask = masks[ lbits = x & 7 ]; /* x % 8 */ if( count >= (rbits = 8 - lbits)){

count -= rbits; onebyte = 0; }else{

mask &= ~masks[ lbits = (x+count) & 7 ]; onebyte = 1;

}

/* Первый байт */

*addr = (*addr & ~mask) | (pattern & mask); addr++;

/* Для pattern==0xFF можно просто

**addr++ |= mask;

*поскольку (a &~m)|(0xFF & m) = (a &~m) | m =

*(a|m) & (~m|m) = (a|m) & 0xFF = a | m

*Почему здесь нельзя написать *addr++ = (*addr...) ?

*Потому, что ++ может быть сделан ДО вычисления

*правой части присваивания!

*/

if(onebyte) return; /* Средние байты */

for(i = count/8; i > 0; --i)

*addr++ = pattern; /* mask==0xFF */ /* Последний байт */

if((lbits = count & 7) == 0) return; /* последний байт был полным */

mask = ~masks[lbits];

*addr = (*addr & ~mask) | (pattern & mask);

}

Заметим, что для быстродействия подобные алгоритмы обычно пишутся на ассемблере.

† Пиксел (pixel, pel) - picture element, в машинной графике - точка растра на экране.

8.23.Напишите при помощи curses-а "электронные часы", отображающие текущее время большими цифрами (например, размером 8x8 обычных символов) каждые 5 секунд. Используйте alarm(), pause().

8.24.Составьте программу, реализующую простой диалоговый интерфейс, основанный на меню. Меню хранятся в текстовых файлах вида:

файл menu2_12

-----------------------------------------------

ЗАГОЛОВОК_МЕНЮ +команда_выполняемая_при_входе_в_меню -команда_выполняемая_при_выходе_из_меню альтернатива_1

команда1_1 команда1_2

альтернатива_2 команда2_1

команда2_2 #комментарий команда2_3

альтернатива_3

>menu2_2 #это переход в другое меню альтернатива_4

>>menu3_7 #хранимое в файле menu3_7

...

...

-----------------------------------------------

Программа должна обеспечивать: возврат к предыдущему меню по клавише Esc (для этого следует хранить "историю" вызовов меню друг из друга, например в виде "полного имени меню":

.rootmenu.menu1_2.menu2_4.menu3_1

где menuI_J - имена файлов с меню), обеспечить выход из программы по клавишам 'q' и ESC, выдачу подсказки по F1, выдачу полного имени меню по F2. Вызов меню при помощи > означает замещение текущего меню новым, что соответствует замене последней компоненты в полном имени меню. Вызов >> означает вызов меню как функции, т.е. после выбора в новом меню и выполнения нужных действий автоматически должно быть выдано то меню, из которого произошел вызов (такой вызов соответствует удлинению полного имени, а возврат из вызова - отсечению последней компоненты). Этот вызов может быть показан на экране как появление нового "выскакивающего" окна поверх окна с предыдущим меню (окно возникает чуть сдвинутым - скажем, на y=1 и x=-2), а возврат - как исчезновение этого окна. Заголовок меню должен высвечиваться в верхней строке меню:

---------------------

Сначала реализуйте версию, в которой каждой "альтернативе" соответствует единственная строка "команда". Команды следует запускать при помощи стандартной функции system(команда).

Усложните функцию выбора в меню так, чтобы альтернативы можно было выбирать по первой букве при помощи нажатия кнопки с этой буквой (в любом регистре):

Compile

Edit

Run program

8.25. Напишите на curses-е функцию, реализующую выбор в меню - прямоугольной таблице:

слово1 слово4 слово7 слово2 *слово5 слово8 слово3 слово6

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

8.26. Используя библиотеку curses, напишите программу, реализующую клеточный автомат Конвея "Жизнь". Правила: есть прямоугольное поле (вообще говоря бесконечное, но принято в конечной модели замыкать края в кольцо), в котором живут "клетки" некоторого организма. Каждая имеет 8 соседних полей. Следующее поколение "клеток" образуется по таким правилам:

•если "клетка" имеет 2 или 3 соседей - она выживает.

•если "клетка" имеет меньше 2 или больше 3 соседей - она погибает.

•в пустом поле, имеющем ровно 3х живых соседей, рождается новая "клетка".

Предусмотрите: редактирование поля, случайное заполнение поля, останов при смерти всех "клеток", останов при стабилизации колонии.

8.27. При помощи curses-а напишите экранный редактор кодов доступа к файлу (в форме rwxrwxrwx). Расширьте программу, позволяя редактировать коды доступа у группы файлов, изображая имена файлов и коды доступа в виде таблицы:

Имена файлов задавайте как аргументы для main(). Указание: используйте для получения текущих кодов доступа системный вызов stat(), а для их изменения - системный вызов chmod().

9. Приложения.

9.1. Таблица приоритетов операций языка C++

Операции, расположенные выше, имеют больший приоритет.

Операторы Ассоциативность

--------------------------------------------------

1. () [] -> :: . Left to right

2.! ~ + - ++ -- & *

Здесь "*" и "&" в строке 2 - это адресные операции; в строке 2 "+" и "-" - унарные; "&" в строке 9 - это побитное "и"; "(typecast)" - приведение типа; "new" и "delete" - операторы управления памятью в C++.

Ассоциативность Left to right (слева направо) означает группировку операторов таким образом:

Ассоциативность Rigth to left (справа налево) это

9.2. Правила преобразований типов.

9.2.1. В выражениях.

1.Если операнд имеет тип не int и не double, то сначала приводится:

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

При вызове функций их аргументы - тоже выражения, поэтому в них приводятся char,short к int и float к double. Это говорит о том, что аргументы (формальные параметры) функций можно всегда объявлять как int и double вместо char,short и float соответственно. Зато спецификатор unsigned является существенным.

9.2.2. В присваиваниях.

op = expr;

Тип выражения expr приводится к типу левой части - op. При этом возможны приведения более "длинного" типа к более "короткому" при помощи усечения, вроде:

Вот еще некоторые приведения типов:

9.4. Таблица степеней двойки.

9.5. Двоичный код: внутреннее представление целых чисел.

Целые числа в большинстве современных компьютеров представлены в виде двоичного кода. Пусть машинное слово состоит из 16 бит. Биты нумеруются справа налево начиная с 0. Обозначим условно бит номер i через b[i]. Значением его может быть либо 0, либо 1.

Тогда unsigned число, записанное в слове, равно

d = 2**15 * b[15] + 2**14 * b[14] +

...

2**1 * b[1] + b[0];

(2**n - это 2 в степени n). Такое разложение числа d единственно. При сложении двух чисел биты складываются по правилам:

Числа со знаком интерпретируются чуть иначе. Бит b[15] считается знаковым: 0 - число положительно или равно нулю, 1 - отрицательно. Отрицательные числа хранятся в виде дополнительного кода:

-a = ~a + 1

Например:

2 = 0000000000000010 ~2 = 1111111111111101

~2+1 = 1111111111111110 = -2

-1 = 1111111111111111 -2 = 1111111111111110 -3 = 1111111111111101 -4 = 1111111111111100 -5 = 1111111111111011

Такое представление выбрано исходя из правила

a + (-a) = 0

сумма: 10|000000000000000

Как видим, произошел перенос 1 в бит номер 16. Но слово содержит лишь биты 0..15 и бит b[16] просто игнорируется. Получается, что сумма равна

0000000000000000 = 0

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

a - b = a + (-b) = a + (~b + 1)

Восьмеричные числа соответствуют разбиению двоичного числа на группы по 3 бита и записи каждой группы в виде соответствующей восьмеричной цифры (смотри таблицу выше). Шестнадцатеричные числа соответствуют разбиению на группы по 4 бита (nibble):