|
|
Часть 3
Часть 3
Б И Б Л И О Т Е К А Ф У Н К Ц И Й
БИБЛИОТЕКА ФУНКЦИЙ
ДДДДДДДДДДДДДДДДДДД
Библиотечные функции естественно разделяются на две кате-
гории:
* функции, совместимые с ANSI стандартом языка "C";
* несовместимые с ANSI стандартом дополнительные библи-
отечные функции
ANSI C функции заложены в предложенный Американским
Институтом Национальных Стандартов стандарт для языка прог-
раммирования "C". Эти функции обеспечивают наибольшую сте-
пень переносимости между различными операционными окружения-
ми так же, как и большинство специфических MS DOS функций.
ANSI стандарт - это расширение исходного языка, предложенно-
го Kernighan и Ritchie, включающее в стандарт языка "C" ряд
черт языка C++.
Библиотека Zortech C очень тесно согласуется с предложен-
ным ANSI стандартом, а также содержит большое число дополни-
тельных функций, разработанных для облегчения программистам
использования аппаратуры и ресурсов операционной системы.
Библиотечные функции, которые включаются в предварительный
ANSI стандарт, помечаются следующим обращзом: /* ANSI */.
Использование таких функций увеличивает переносимость
прикладных программ. Этот раздел руководства содержит описа-
ние сообщений о системных ошибках и ошибках математических
функций, файлов заголовков и перечисленных в алфавитном по-
рядке функций. До этого дается информация о двух отдельных
группах функций:
* функции работы с файлами
* функции управления памятью
Некоторые Zortech функции требуют специальных знаний о
микропроцессоре 8086, аппаратуре персонального компьютера
или операционной системе MS DOS. Многое из этого можно
узнать при чтении следующих документов:
- Технический справочник по IBM PC (аппаратура).
- Справочник программиста по MS DOS (фирма Microsoft).
Обмен с файлами
Виды файлов
Файлы могут быть считаны или записаны в двух режимах:
текстовом режиме и двоичном режиме. Двоичный режим является
"родным" для MS DOS. В нем файлы считываются и записываются
байт за байтом, откуда и куда указано. В текстовом режиме
производятся различные преобразования, как-то:
Вывод: если указывается литера "перевод строки" '\n',
в действительности записываются '\r'\n' (лите-
ры "возврат каретки" и "перевод строки").
Ввод: при вводе "возврат каретки" '\r' игнорируется,
а литера control Z (0х1A) помечает конец файла.
Обычные текстовые файлы (например, файл исходного текста
программы) должны использовать текстовый режим, который вы-
бирается по умолчанию. Файлы, содержащие двоичные данные,
должны использовать двоичный режим. Смотрите о функции
fopen() для объяснения подробностей открытия файлов в раз-
личных режимах.
Высокий и низкий уровни обмена с файлами
Имеется два набора программ обмена с файлами: высокого
уровня и низкого уровня. Программы высокого уровня читают и
пишут файлы как в текстовом, так и в двоичном режимах. Низ-
коуровневые программы читают и пишут файлы только в двоичном
режиме.
Высокоуровневые и низкоуровневые программы никогда не
следует использовать одновременно с одним и тем же файлом.
Программисту,как правило,следует использовать высокоуровневые
программы,поскольку они в большей степени переносимы.
Низкий уровень обмена с файлами
Программы низкого уровня для обмена с файлами - это функ-
ции creat(), open(), close(), lseek(), read() и write(). Они
реализуются как прямое обращение (hooks) к операционной сис-
теме MS DOS.
Файл, с которым работают эти функции, задается дескрипто-
ром файла (handle). Ввод/вывод является небуферизованным и
двоичным. Ниже перечислены некоторые дескрипторы специальных
файлов, которые всегда открыты:
0 Стандартное устройство ввода.
1 Стандартное устройство вывода.
2 Стандартное устройство вывода сообщений об ошибках.
3 Стандартное дополнительное (auxiliary) устройство.
4 Стандартное печатающее устройство.
Высокий уровень обмена с файлами
Функции обмена с файлами высокого уровня, включая функции
fopen(), fread(), fwrite() и fclose(), построены на основе
низкоуровневых функций. Эти функции взаимодействуют через
указатель потока ввода/вывода (объявленного как FILE *). Вы-
сокоуровневые функции осуществляют буферизованный обмен.
Пять потоков ввода/вывода всегда открыты, это:
stdin Стандартный ввод
stdout Стандартный вывод
stderr Стандартный вывод сообщений об ошибках
stdaux Стандартный дополнительный поток (auxiliary)
stdprn Стандартный принтер
Для использования высокоуровневых функций Вы должны вклю-
чить строку
#include
в начало Вашего файла исходного текста программы.
Распределение памяти
'Куча' (Heap)
'Куча' - это область памяти, распределяемой динамически.
Память распределяется и освобождается при помощи функций
malloc(), realloc(), calloc() и free().
Для S (малой), M (средней) и T (тонкой) моделей про-
странство для 'кучи' может распределяться в MS DOS целиком
за раз или по мере необходимости. Большинство программ будет
использовать схему распределения памяти по умолчанию, кото-
рая расширяет сегмент данных, используя все доступное прост-
ранство памяти (до 64K) при запуске программы.
Другая схема выделения пространства под 'кучу' -
'по необходимости' - используется для программ, которые
исполняют другие программы, т.е. используют функции типа
spawn().
Распределение памяти под 'кучу' 'по необходимости' остав-
ляет максимальное количество доступной памяти дочерним про-
цессам. Вторая схема выбирается при объявлении и инициа-
лизации переменной _okbigbuf 0. Следующий пример показыва-
ет, как выбирается вторая схема распределения памяти:
int _okbigbuf = 0; /* Использовать схему распределения
памяти 'по необходимости' */
_okbigbuf != 0 означает использование больших дисковых бу-
феров для потока ввода/вывода вне сегмента данных. Все это
управление запрограммировано в C.ASM.
C.ASM - это стартовый C модуль, который автоматически
прикомпоновывается в начало Вашей программы и инициализиру-
ет сегментные регистры в соответствии с используемой моделью
памяти; C.ASM также гарантирует, что программа имеет кор-
ректную структуру, как это требует MS DOS. Этот модуль уста-
навливает также схему распределения памяти, которая будет
использоваться для получения памяти из сегментов данных.
Для получения более подробной информации по распределению
памяти смотрите раздел 'интерфейс с ассемблером' справочно-
го руководства.
Стек (Stack)
Стек растет вниз по направлению к статически размещенным
данным. Если стек переходит границу выделенного пространст-
ва, то статически распределенные данные будут разрушены и
программа может выполняться необъяснимым образом. Для про-
верки того, что стек не нарушает границу, имеется функция
_chkstack().
Функцию _chkstack() следует вызывать из функций, которые,
возможно, используют слишком много стекового пространства.
Если это случается, _chkstack() аварийно завершает выполне-
ние программы с сообщением о переполнении стека.
Ключ -s компилятора может использоваться для генерации
программы с проверкой переполнения стека при входе в каждую
функцию. Хотя это увеличивает размер программы и влияет на
скорость исполнения, но обеспечивает помощь при решении проб-
лемы переполнения стека. Если обнаружится переполнение стека,
сообщение:
STACK OVERFLOW
выводится на экран терминала и программа аварийно завершает-
ся. Размер стека может быть установлен статически путем ини-
циализации глобальной переменной _stack:
unsigned _stack = nnnn;
в начале Вашей программы; 'nnnn' - это размер в байтах тре-
буемого стека. По умолчанию размер стека равен 2048 байт.
Допустимыми значениями для nnnn являются 1024 ... 30000. Па-
мять, распределенная под стек, не забирается от статических
данных в C и L моделях памяти,так как стек помещается в свой
собственный сегмент.
Глобальные переменные
Имеется несколько глобальных переменных, которые опреде-
ляют состояние частей программы. Здесь описываются имена пе-
ременных и их использование.
_8087
Всякий раз в начале использования программы определяется,
имеется ли в наличии сопроцессор 8087, 80287 или 80387. Если
есть, все вычисления с плавающей точкой могут выполняться
этим сопроцессором. Если же его нет, все вычисления с плава-
ющей точкой программно эмулируются. Глобальная переменная
_8087 определяется в файле C.ASM и может быть проверена на
предмет наличия сопроцессора _8087. Если значение переменной
_8087 равно 0, сопроцессора 8087 нет. Значение переменной,
равное 1, указывает на то, что сопроцессор 8087 найден;
2 - имеется 80287; 3 - имеется 80387.
Поведение Zortech библиотек также управляется этой пере-
менной. Например:
extern int _8087;
if(_8087)
printf("8087 присутствует\n");
else
printf("8087 отсутствует\n");
Варианты арифметики с плавающей точкой
Предлагается четыре способа выполнения операций с плаваю-
щей точкой:
1. Нет никаких операций с плавающей точкой. Не загру-
жать из библиотеки программы выполнения операций с
плавающей точкой.
2. Все операции с плавающей точкой исполнять в 8086.
Если имеется 8087, не использовать его.
3. Выполнять операции с плавающей точкой, используя
8086. Если имеется 8087, использовать его для вычис-
лений вместо 8086. Библиотечные математические функ-
ции переключить на встроенные 8087 программы, если
есть 8087. Эта опция используется по умолчанию.
4. Генерирует прямой код для 8087. Для запуска прог-
раммы требуется наличие 8087.
Преимущества:
1. Размер результирующей программы становится значи-
тельно меньше.
2. 8087 не нужен. Результаты в точности повторяются
на всех 8086 машинах. Компилятор сам использует эту
опцию.
3. Без 8087 работает также как 2, но при наличии ис-
пользуется 8087 и программа будет работать быстрее.
4. Генерируется самый быстрый и компактный код, и
потенциально получаются наиболее точные результаты
(арифметика в 8087 выполняется с использованием 80
бит против 64 бит для 8086). Относительное увеличе-
ние скорости, получаемое при использовании 8087,
весьма сильно зависит от отношения скоростей 8087 и
основного процессора), а также от используемой Вами
версии 8087 (80287, 80387, совместимые с ними
и т.д.). Для персонального компьютера эти улучшения
становятся заметными на программах, интенсивно ис-
пользующих операции с плавающей точкой.
Недостатки:
1. Нельзя выполнить никакой операции с плавающей точ-
кой.
2. Самый медленный код. Менее точные вычисления. Раз-
мер программы велик.
3. Результаты могут зависеть от того, имеется ли сопро-
цессор 8087. Программа того же размера как и для
случая 2.
4. Для работы требуется 8087. Исполнение команд про-
цессора 8087 при его отсутствии может вызвать крах
системы.
Вариант 1:
Программа создается явной прикомпоновкой модуля INT.OBJ.
INT.OBJ определяет все точки входа программ библиотеки для
работы с плавающей точкой, так что ни одна из таких программ
не выбирается из библиотеки. Если происходит какой-либо
вызов программы вычислений с плавающей точкой, печатается
сообщение:
FLOATING POINT NOT LOADED (программы выполнения операций
с плавающей точка не загружены)
и программа останавливается. Один и тот же INT.OBJ модуль
используется для всех моделей памяти.
Прикомпоновка модуля INT.OBJ может быть указана программе
ZTC с помощью флага [-mi]. ZTC использует переменную окруже-
ния LIB для поиска INT.OBJ и передает его редактору связей.
Например:
ZTC -mi hello
Вариант 2:
Вариант 2 реализуется при помощи следующего фрагмента
программы:
main()
{ extern int _8087;
_8087 = 0; /* никогда не использовать 8087 */
...
}
Вариант 3:
Вариант 3 реализуется по умолчанию.
Вариант 4:
Вариант 4 создается при трансляции программы посредством
ZTC с флагом -f.
Например:
ZTC file -f
Поскольку код программы, оттранслированной с флагом -f,
будет приводить к краху системы при ее запуске и отсутствии
8087, очень рекомендуем в этом случае включить в Вашу прог-
рамму следующий фрагмент:
main ()
{ extern int _8087;
if(_8087==0) /* если 8087 отсутствует */
{ printf("Эта программа требует 8087\n");
exit(1); /* останов программы*/
}
...
}
Более 'отчаянные' программисты, которые используют ва-
риант 4, могут модифицировать и перекомпилировать эти библи-
отеки для удаления из них всех не 8087 программ работы с пла-
вающей точкой для того, чтобы сделать программу меньше и
несколько быстрее.
Одни те же Zortech библиотеки используются во всех вариан-
тах.
Заметим, что нет различий в call/return соглашениях
между функциями, поэтому obj модули, которые компили-
руются в разных вариантах, могут свободно компоновать-
ся вместе.
Например, прикладная программа, которая осуществляет мат-
ричные преобразования, может иметь две версии преобразований:
ZTC -c -f matrix -DINLINE8087 -omatrix87.obj
ZTC -c matrix
ZTC main matrix.obj matrix87.obj
Файл matrix.c может содержать:
#ifdef INLINE8087
void matrix87()
/* для версии с 8087 нужно другое имя */
#else
void matrix()
#endif
{
...
}
Файл main.c может содержать:
extern int _8087;
...
if(_8087) /* если имеется 8087 */
matrix87(); /* используется версия для 8087 */
else
matrix();
/* используется версия с программной реализацией*/
/* плавающей точки */
Таким образом исполняемая программа может пользоваться
всеми преимуществами сопроцессора 8087, но также будет рабо-
тать корректно и при его отсутствии. Подобные примеры можно
увидеть в библиотечном файле math.c.
_okbigbuf (только для T, S и M моделей памяти)
Эта переменная определяет, какую схему распределения па-
мяти использовать. Существует два способа распределения:
Способ 1:
Распределяет всю доступную память (до 64K) под 'ку-
чу' при старте программы. Этот способ используется
по умолчанию.
Способ 2:
Память распределяется под 'кучу' только при необхо-
димости. Этот способ должен быть использован, если
потребуется функция spawn. Для использования этого
способа объявите _okbigbuf как это показано ниже.
Для более подробной информации смотрите 'Распреде-
ление памяти'.
Использование:
int _okbigbuf = 0; /* Отводить память по мере */
/* необходимости */
_okbigbuf!=0 означает также использование больших диско-
вых буферов для потока ввода/вывода вне сегмента данных. Все
это управляется модулем C.ASM.
_osmajor
Эта переменная определяет основной номер исполняемой вер-
сии MS DOS. Значение _osmajor будет равно 3 при работе под
управлением MS DOS 3.2 или 2 при работе под MS DOS 2.0.
Использование:
extern unsigned char _osmajor;
_osminor
Эта переменная определяет дополнительный номер исполняе-
мой версии MS DOS. Значение _osminor будет равно 11 при ра-
боте под управлением MS DOS 2.11 или 1 при работе под
MS DOS 3.1.
Использование:
extern unsigned char _osminor;
_psp
Эта переменная содержит адрес сегментного параграфа для
префикса программных сегментов. Эта переменная может исполь-
зоваться для построения 'дальних' указателей, обеспечивающих
доступ к префиксу программных сегментов из программы поль-
зователя.
Использование:
extern unsigned _psp;
errno
Этой переменной присваиваются номера ошибок после исполь-
зования некоторых библиотечных функций при появлении ошибок.
Значения errno следующие:
E2BIG 100
EACCES 5
EBADF 6
EDOM 102
EEXIST 80
EMFILE 4
ENOENT 2
ENOEXEC 01
ENOMEM 8
ENOTDIR 3
ERANGE 103
Использование:
extern int errno;
Смотрите также файл errno.h для описания смысла каждого
значения ошибки.
СООБЩЕНИЯ ОБ ОШИБКАХ
ДДДДДДДДДДДДДДДДДДДДДД
Ошибки ДОС
В таблицах ниже перечислены сообщения об ошибках, возвра-
щаемые функцией perror(), с соответствующим номером ошибки в
errno.
E2BIG Список аргументов слишком большой.
(Список аргументов превышает 128 байт).
EACCES Отказ в разрешении доступа.
(Например, запись в файл, открытый толь-
ко по чтению).
EBADF Плохой дескриптор файла.
EDOM Аргумент математической функции вне об-
ласти определения.
EEXIST Файл уже существует.
EMFILE Слишком много открытых файлов.
ENOENT Нет такого файла или каталога.
ENOEXEC Ошибка формата исполняемого файла.
ENOMEM Нет достаточного пространства памяти.
(Например, недостаточно памяти для ис-
полняемой функции).
ENOTDIR Маршрут к каталогу не найден.
ERANGE Результат вне диапазона значений.
(Аргумент математической функции слиш-
ком велик).
Смотрите пример из описания библиотеки по функции perror()
для выяснения использования этих сообщений об ошибках.
Ошибки математических функций
Ошибки, встречающиеся при исполнении математических функ-
ций, возвращаются функцией matherror().
math.h
DOMAIN Недопустимая операция.
OVERFLOW Результат слишком велик для его пред-
ставления.
PLOSS Частичная потеря точности значимости.
SING Особенность аргумента, (например, нуле-
вое значение передается функции log(),
требующей ненулевого параметра).
TLOSS Полная потеря точности значимости.
UNDERFLOW Результат слишком мал для его представ-
ления.
ФАЙЛЫ ЗАГОЛОВКИ
ДДДДДДДДДДДДДДДД
assert.h
Определяет макрос assert().
Если идентификатор NDEBUG не был определен в командной
строке компилятора или в #define директиве, макрос опреде-
лен и служит для проверки заданного параметром выражения.
Если это утверждение ложно, печатается сообщение и программа
завершается.
Если NDEBUG определен, assert определяется как пустой
текст. В результате все assert утверждения как бы становятся
комментариями.
conio.h
Объявляет прототипы для функций ввода/вывода на консоль.
getch getche inp inpw outp oupw
ctype.h
Определяет макросы и константы, используемые при класси-
фикации литер.
isalnum isalpha isascii iscntrl isdigit
isgraph islower isprint ispunct isspace
isupper isxdigit toascii
В файл ctype.h включено также глобальное объявление
массива _ctype. Этот массив является ориентированной на
ASCII таблицей кодов классификации.
direct.h
Объявляет прототипы для функций работы с каталогогами.
chdir getcwd mkdir rmdir
disp.h
Определяет макросы, объявляет константы и прототипы для
функций прямого доступа к экрану.
disp_close disp_eeol disp_eeop
disp_endstand disp_flush disp_getmode
disp_move disp_open disp_pokew
disp_printf disp_putc disp_reset43
disp_scroll disp_set43 disp_setattr
disp_setmode disp_usebios disp_startstand
disp_setcursortype
dos.h
Определяет макросы, константы и объявляет интерфейсные
функции для MS DOS и IBM PC. Они включают в себя доступ к
вводу/выводу через порты, определения видов файлов, процедур
обработки прерываний, а также структуры регистров.
Объявления прототипов dos-пакета:
dos_abs_disk_read dos_abs_disk_write
dos_getdiskfreespace dos_get_ctrl_break
dos_get_verify dos_set_ctrl_break
dos_set_verify
Объявления прототипов для функций MS DOS работы с катало-
гами:
findfirst findnext
Объявления прототипов функций для 'дальнего' распределе-
ния памяти:
farmalloc farcalloc farrealloc
farfree farcoreleft
Объявления функций доступа к портам ввода/вывода:
inp inpw outp outpw
Регистровые структуры, используемые функциями intdos(),
intdosx(), int86(), int86x():
WORDREGS BYTEREGS REGS SREGS
Макросы для работы с дальними указателями
(сегмент:смещение):
FP_SEG FP_OFF MK_FP
fg.h
Определяет константы, типы, прототипы функций пакета быст-
рой графики. Следующие константы соответствуют графическим
режимам:
FG_CGAMEDRES 0х04 IBM CGA , 320*200, цветной
(режим 0х04)
FG_CGAHIRES 0х06 IBM CGA , 640*200 (режим 0х06)
FG_EGACOLOR 0х0E IBM EGA с нормальным цветным ото-
бражением (режим 0х0E)
FG_EGAMONO 0х0F IBM EGA с IBM монохромным монито-
ром (режим 0х0F)
FG_EGAECD 0х10 IBM EGA с улучшенным цветным ото-
бражением (режим 0х10)
FG_VGA11 0х11 IBM VGA , 640*480, 1 цвет.
FG_VGA12 0х12 IBM VGA , 640*480, 16 цветов.
FG_VGA13 0х13 IBM VGA , 320*200, 256 цветов.
FG_HERCHALF 0х02 Hercules ("Геркулес"), монохромный,
1 страница дисплейной памяти.
FG_HERCFULL 0х03 Hercules, монохромный, 2 страницы
дисплейной памяти.
FG_TOSHIBA 0хFA TOSHIBA J-3100.
FG_8514A Графический адаптер IBM 8514A.
Функции:
fg_adjustxy fg_drawarc fg_writebox
fg_drawbox fg_drawdot fg_drawellipse
fg_drawline fg_drawlinep fg_drawmatrix
fg_drawthickline fg_enclose fg_fillbox
fg_flush fg_getcolormap fg_init
fg_init_all fg_init_cga fg_init_cgamedres
fg_init_egacolor fg_init_egaecd fg_init_egamono
fg_init_herc fg_blit fg_init_toshiba
fg_init_vga11 fg_init_vga12 fg_init_vga13
fg_putc fg_puts fg_readbox
fg_readdot fg_restore fg_save
fg_setactivepage fg_setcolormap fg_setdisplaypage
fg_text_mode fg_term fg_setlinepattern
Типы линий:
FG_LINE_MEDIUM_DOTTED FG_LINE_LONG_DASH
FG_LINE_DENSE_DOTTED FG_LINE_SHORT_DASH
FG_LINE_MEDIUM_DASHED FG_LINE_MAX
FG_LINE_DASH_DOTTED FG_LINE_SOLID
FG_LINE_SPARSE_DOTTED FG_LINE_USER_DEFINED
FG_LINE_DASH_W_2_DOTS
Цвета:
FG_BLACK FG_BLUE FG_GREEN
FG_CYAN FG_BLUE_GREEN FG_RED
FG_PURPLE FG_YELLOW FG_WHITE
FG_LIGHT_BLUE_GREEN FG_LIGHT_GREEN FG_GRAY
FG_LIGHT_BLUE FG_LIGHT_RED FG_MAGENTA
FG_LIGHT_CYAN FG_LIGHT_WHITE FG_BROWN
FG_LIGHT_MAGENTA FG_HIGHLIGHT FG_BLINK
errno.h
Определяет мнемонические константы, используемые функцией
perror.
Смотрите раздел по сообщениям об ошибках.
int.h
Содержит объявления функций и структур для программ обра-
ботки прерываний.
int_getvector int_intercept int_off
int_restore int_setvector int_on
io.h
Содержит объявления функций для низкоуровневой работы с
файлами.
close creat delete filesize getDS
isatty lseek open read remov
rename write unlink
limits.h
Определяет предельные значения и диапазоны числовых вели-
чин.
math.h
Объявляет прототипы математических функций:
acos asin atan atan2 atof
ceil cos cosh exp fabs
floor fmod frexp hypot ldex
log log10 modf poly pow
sin sinh sqrt tan tanh
msmouse.h
Объявляет прототипы для MS-MOUSE функций работы с 'мышью':
msm_condoff msm_getpress msm_getrelease
msm_getstatus msm_hidecursor msm_init
msm_lightpenoff msm_lightpenon msm_readcounters
msm_setareax msm_setareay msm_setcurpos
msm_setgraphcur msm_setratio msm_settextcur
msm_showcursor msm_signal msm_setthreshhold
msm_term
process.h
Объявляет прототипы всех функций управления процессами:
_exit execl execlp execv execvp
spawnl spawnlp spawnv spawnvp
setjmp.h
Объявляет тип jmp_buf, используемый функциями setjmp и
longjmp (также объявленными).
signal.h
Определяет следующие значения для сигналов:
SIG_DFL SIG_ERR SIG_IGN SIGABRT SIGFPE
SIGILL SIGINT SIGSEGV SIGTERM
Объявляет функции raise() и signal().
sound.h
Объявляет прототипы для функций работы со звуком:
sound_beep sound_click sound_tone
stdarg.h
Определяет макросы, используемые для чтения списка аргу-
ментов переменной длины:
va_list va_start va_arg va_end
stddef.h
Определяет общие типы данных.
errno Глобальная переменная, содержащая номер
сообщения об ошибке.
ptrdiff_t Синоним типа, который является разностью
двух указателей.
size_t Синоним типа, который может быть исполь-
зован для хранения размера переменной.
stdio.h
Определяет константы, типы, макросы и прототипы функций
для потокового ввода/вывода.
bdos clearerr fclose feof ferror
fflush fgetc fgets fileno filesize
flushall fopen fprintf fputc fputs
fread freopen fscanf fseek ftell
fwrite getc getch getchar getche
gets max min printf putc
putchar puts rewind stdaux stderr
stdin stdout stdprn scanf setbuf
setvbuf sprintf sscanf ungetc vfprintf
vprintf vsprintf
BUFSIZ размер по умолчанию буфера, используемого
для потокового ввода/вывода.
_NFILE Определяет максимальное число одновременно
открытых файлов.
EOF Определяет значение, возвращаемое программой
ввода/вывода при обнаружении конца файла.
NULL Нулевое значение указателя.
BIGBUF Размер буфера для использования в потоках
ввода/вывода при _okbigbuf==1.
stdlib.h
Объявляет прототипы для следующих функций:
abort abs atexit atof atoi
bsearch calloc div exit free
getenv itoa labs atol ldiv
malloc qsort rand realloc srand
strtod strtol strtoul system
string.h
Объявляет прототипы функций обработки строк:
strcat strchr strcmp strcmpl strcpy
strcspn strdup strerror strlen strlwr
strncat strncmp strncpy strnset strpbrk
strrchr strrev strset strspn strstr
strtok strupr swab
Объявляет прототипы функций работы с памятью:
memcpy memcmp memchr memset
sys\stat.h
Определяет флаги, используемые при создании и открытии
файлов. Объявляет прототипы функций для stat() и fstat().
S_IFCHR S_IFDIR S_IFMT S_IFREG
S_IEXEC S_IREAD S_IWRITE
stat.h не может включаться в C++ файлы, stat.h годен
только для C файлов из-за конфликта имен между struct stat и
int stat().
time.h
Объявляет прототипы функций работы со временем.
asctime clock ctime difftime gmtime
localtime mktime strftime time
БИБЛИОТЕЧНЫЕ ФУНКЦИИ
ДДДДДДДДДДДДДДДДДДДДД
Описание каждой библиотечной функции имеет разделы:
использование
описание
пример
возвращаемое значение
рекомендация,
описанные ниже.
имя_функции
Каждая библиотечная функция начинается с имени функции.
Каждое имя функции предназначено для использования в
C-программе и может включать ведущий подчерк (`_'), заглав-
ные буквы (`FP_OFF') и совместное использование регистров
(`getDS'). Важно отметить, что использование `printf' и
`PRINTF' не эквивалентно.
Использование:
Во-первых, в этом разделе содержится директива компилято-
ру #include . является именем фай-
ла заголовков, содержащего прототип функции. Прототип содер-
жит описание типа возвращаемого значения и входных парамет-
ров. Файл заголовков может также содержать описание типов,
структур и констант, используемых функцией.
Последующая информация содержит описание прототипа функ-
ции в том же виде, как он определен в файле заголовков. Воз-
можно объявление функции путем приведения прототипа функции,
включенного в этот файл, вместо использования директивы
`#include'.
Поскольку функция может использовать другие типы данных,
включенные в файл заголовков, включение этого файла обеспечи-
вает необходимый контроль ошибок, а не только объявление про-
тотипа функции.
Описание:
Содержит информацию о назначении функции, описывает ее
аргументы и другие детали использования функции.
Пример:
В большинстве случаев приводится полностью законченный
вычислительный пример, который можно ввести и выполнить.
Каждый пример включает все необходимые файлы заголовков, ис-
пользуемые функцией. В большинстве случаев используется
также stdio.h файл. Это обусловлено тем, что printf является
функцией с переменным числом параметров, так что включение
stdio.h файла, содержащего прототип функции printf, гаран-
тирует проведение надлежащего контроля.
Возвращаемое значение:
Специфицирует значение, возвращаемое функцией. Во многих
случаях возвращаемое значение информирует об успехе или неу-
даче. Хотя не всегда необходимо контролировать возвращаемое
значение, такой контроль ошибок поможет гарантировать над-
лежащее исполнение Вашей программы.
Рекомендация:
Отсылает к другим аналогичным или вспомогательным функ-
циям.
abort СБРОСИТЬ ВЫПОЛНЕНИЕ ПРОГРАММЫ
Использование:
#include
void abort (void); /* ANSI */
Описание:
Прекращает выполнение текущей программы. Аналогична
вызову функции _exit с ненулевым значением статуса.
Пример:
#include
#include
main ()
{
FILE * fp;
fp=fopen("file.dat", "r");
if (fp==NULL)
{
fprintf(stderr, "Не могу открыть file.dat\n");
abort();
}
printf("Файл открыт\n");
}
Возвращаемое значение:
Нет возвращаемого значения.
Рекомендация:
Смотрите также exit, _exit, raise
abs АБСОЛЮТНОЕ ЗНАЧЕНИЕ ЦЕЛОГО
Использование:
#include
int abs(int i); /* ANSI */
Описание:
Вычисляет абсолютное значение целого аргумента.
Пример:
#include
#include
main ()
{
int numbr, absval;
numbr = -3;
absval= abs(numbr);
printf("abs от (%d) равно %d\n",
numbr,absval);
}
Возвращаемое значение:
Возвращает абсолютное значение целого аргумента.
Рекомендация:
Смотрите labs.
acos АРККОСИНУС
Использование:
#include
double acos(double x);
Описание:
Вычисляет arccos (x) в диапазоне [0, пи]. Аргумент
x должен быть в диапазоне [-1, 1].
Пример:
#include
#include
main ()
{
double x, y;
x = .94;
y = acos(x);
printf("Арккосинус от %f равен %f\n",x,y);
}
Возвращаемое значение:
Возвращает значение arccos от входного аргумента.
Если величина x меньше -1 или больше 1, устанавли-
вает еrrno в EDOM, в stderr печатает сообщение об
ошибке DOMAIN и возвращает значение 0. Обработку
ошибки можно модифицировать посредством функции
matherr.
Рекомендация:
Смотрите также asin, atan, atan2.
asctime ДАТЬ ВРЕМЯ
Использование:
#include
char * asctime(struct tm * ntime); /* ANSI */
Описание:
Преобразует аргумент, являющийся указателем на
структуру tm, в ASCII строку из 26 литер, включая за-
вершающий 0:
DDD MMM dd hh:mm:ss YYYY\n\0
где:
DDD - день недели
MMM - месяц
dd - день месяца
hh:mm:ss - часы:минуты:секунды
YYYY - год
Значение ntime может быть получено обращением к
localtime(), возвращающей указатель на структуру tm,
определенную в time.h.
Пример:
#include
#include
main ()
{
time_t tclock;
time(& tclock);
printf("Текущие дата и время: %s\n",
asctime(localtime(& tclock)));
}
Возвращаемое значение:
Возвращает указатель на строку литер, содержащую дату
и время. Строка имеет статический класс и перезаписы-
вается при каждом обращении к asctime.
Рекомендация:
Смотрите также clock, ctime, difftime, localtime.
asin АРКСИНУС
Использование:
#include
double asin(double x); /* ANSI */
Описание:
Вычисляет значение arcsin(x) в диапазоне
[-пи/2, пи/2]. Значение аргумента x должно быть в
диапазоне [-1, 1].
Пример:
#include
#include
main ()
{
double x, y;
x = .94;
y = asin(x);
printf("Арксинус от %f равен %f\n", x, y);
}
Возвращаемое значение:
Возвращает значение arcsin от входного аргумента.
Если значение меньше -1 или больше 1, устанавливает
errno в EDOM, печатает DOMAIN сообщение об ошибке в
stderr и возвращает 0. Обработку ошибки можно моди-
фицировать посредством функции matherr.
Рекомендация:
Смотрите также atan, atan2, acos.
assert ПРОВЕРИТЬ УТВЕРЖДЕНИЕ
Использование:
#include
void assert(expression); /* ANSI */
Описание:
Макрос assert oсуществляет внутренний контроль в
программе. Он проверяет аргумент expression (выраже-
ния) и в случае, если оно равно 0 (т. е. ложно), то
прекращает исполнение программы; перед этим печатает
на стандартном устройстве вывода ошибок сообщение:
Assertion failure: 'expression' on line ?? in file '???'
(Ошибка утверждения: 'выражение' в строке ?? в файле '???')
Пример:
#include
#include
char * string= ""; /* пустая строка*/
int value=1;
main ()
{
assert(value>0);
printf("Прошли assert(value>0)\n");
assert(*string != '0');
}
Возвращаемое значение:
Нет возвращаемого значения.
atan, atan2 АРКТАНГЕНС
Использование:
#include
double atan(double x); /* ANSI */
double atan2(double x, double y); /* ANSI */
Описание:
atan вычисляет значение arctg(x) в диапазоне
[-пи/2, пи/2]. atan2 вычисляет значение arctg(y/x)
в диапазоне [-пи, пи]. atan2 использует знаки x, y
для определения квадранта, к которому принадлежит
результат.
Пример:
#include
#include
main ()
{
double x, y;
x = 1.0;
y = atan(x);
printf("Арктангенс от %f равен %f\n", x, y);
}
Возвращаемое значение:
Обе функции возвращают значение arctg от входного
аргумента (аргументов). Если x и y оба 0, atan2 уста-
навливает errno в EDOM, печатает сообщение DOMAIN об
ошибке в stderr и возвращает 0. Обработку ошибки можно
модифицировать посредством функции matherr.
Рекомендация:
Смотрите также acos, asin.
atof, atoi, atol ПРЕОБРАЗОВАТЬ В ПЛАВАЮЩЕЕ
ПРЕОБРАЗОВАТЬ В ЦЕЛОЕ
ПРЕОБРАЗОВАТЬ В ДЛИННОЕ
Использование:
#include
double atof(char* nptr) /* ANSI */
int atoi(char *nptr) /* ANSI */
long atol(char *nptr) /* ANSI */
Описание:
Преобразует строку по указателю nptr в целое (atoi),
удвоенной точности (atof) или длинное (atol) значе-
ние. Строка может иметь ведущие пробелы, символы
табуляции, знаки + или -. Преобразование заканчива-
ется на первой подходящей литере. Если первая же ли-
тера не подходит, результатом является 0.
Пример:
#include
#include
#include
main ()
{
printf("atof function=%e\n", atof("123.5e15"));
printf("atoi function=%d\n", atoi("153"));
printf("atol function=%ld\n",atol("1234 string"));
}
Возвращаемое значение:
Возвращаются значения: целое, удвоенной точности,
длинное, получаемые преобразованием строки. Возвра-
щается 0, если во входной строке нет подходящих ли-
тер.
Рекомендация:
Смотрите также ecvt, fcvt, strtod, strtol, scanf.
bdos, bdosx ВЫЗВАТЬ ФУНКЦИЮ DOS
Использование:
#include
int bdos(int func, unsigned DX, unsigned AL);
int bdosx(int func, char *ptr);
Описание:
Вызывают функцию MSDOS (прерывание 21h). func есть
номер функции, DX и AL являются значениями, загру-
женными в регистры DX и AL перед вызовом функции.
bdosx отличается от bdos лишь тем что вместо AL и DX
в пару регистров DS:DX загружается аргумент по ptr.
Пример:
#include
main ()
{
bdos(2, 'c') /* высветить букву c */
}
Возвращаемое значение:
После вызова системы обе функции возвращают значе-
ние в регистре AX.
Рекомендация:
Смотрите также intdos, intdosx, int86, int86x.
bioskey, _bios_keybrd РАБОТА С КЛАВИАТУРОЙ
Использование:
#include
int bioskey(int flag);
int _bios_keybrd (int flag);
Описание:
Оба имени обозначают одну функцию. Два произношения
нужны для совместимости с разными компиляторами.
bioskey передает флаг для BIOS_прерывания 0x14 -
- прерывание от клавиатуры. Значения flag:
0 - чтение значения ввода с клавиатуры из буфера
ввода. Ждет ввода, если буфер пуст.
1 - определение наличия значений нажатых клавиш
в буфере ввода от клавиатуры.
2 - чтение состояния клавиш типа 'shift'.
Возвращаемое значение:
Если flag=0, то возвращаемое значение является рас-
ширенным кодом клавиши. ASCII код клавиши находится
при этом в младшем байте, а скан-код ее - в старшем
байте. Если младший байт нулевой, то это не ASCII
код (это может быть стрелка или функциональная кла-
виша). Если flag=1, то 0 возвращается при отсутствии
ввода от клавиатуры в буфере ввода; в противном слу-
чае возвращается расширенный код клавиши. При этом,
код клавиши остается в буфере ввода и еще доступен
для чтения. Если flag=2, то возвращаемое значение ин-
формирует о состоянии 'shift' клавиш:
0x01 - нажата правая shift клавиша
0x02 - нажата левая shift клавиша
0x04 - нажата клавиша Ctrl
0x08 - нажата клавиша Alt
0x10 - включен ключ Scrolllock
0x20 - включен ключ Numlock
0x40 - включен ключ Capslock
0x80 - включен ключ Ins
Пример:
#include
#include
main ()
{
int key, shift;
int lastshift = 0;
while (1)
{
shift=bioskey(2);
if(shift!=lastshift)
/* Если изменился shift статус*/
printf("shift = 0x%02x\n", shift);
/* Если клавиша нажата*/
if (bioskey(1))
{ /* Читаем клавишу*/
Key=bioskey(0);
if ((Key & 0xFF)== 'q') break;
printf("Клавиша = 0x%04x\n", Key);
}
lastshift=shift;
}
}
bsearch ДВОИЧНЫЙ ПОИСК В МАССИВЕ
Использование:
#include
void *bsearch(const void *key, const void *base,
size_t num, size_t width,
int(*cmp)(const void *elem1,const void *elem2));
/* ANSI */
Описание:
Выполняет двоичный поиск в упорядоченном массиве из
num элементов по указателю base элемента, равного
key. Каждый элемент массива имеет размер width бай-
тов. Алгоритм поиска реализует функция *cmp, опреде-
ленная пользователем. Она должна использовать два
аргумента, являющихся указателями на элементы, и во-
звращать одно из значений:
<0 - elem1 меньше elem2
0 - elem1 совпадает с elem2
>0 - elem1 больше elem2
Пример:
#include
#include
#include
#define SIZE(arr)(sizeof(arr)/sizeof(arr[0]))
int array[]={1254,3427,1111,3901,6677,0101};
int intcmp(int *p1, int *p2)
{
return(*p1 - *p2);
}
main()
{
int * pointer;
int Key = 3901;
pointer = (int *) bsearch(& Key, array,
SIZE(array), sizeof(int), intcmp);
if(pointer)
{
printf("[ %d] имеется в массиве\n", Key);
}
else
{
printf("[ %d] отсутствует в массиве\n", Key);
}
}
Возвращаемое значение:
Возвращается указатель на соответствующий элемент
массива base или NULL, если таковой не найден.
calloc ДАТЬ ПАМЯТЬ
Использование:
#include
void * calloc(unsigned numelems, size_t sizelem);
/* ANSI */
Описание:
Выделяет блок памяти под numelems элементов и разме-
ром sizelem байтов каждый. Память обнуляется и возв-
ращается указатель на нее. В случае ошибки(например,
недостаточно памяти) возвратится NULL. Если numelems
или sizelem равен 0,возвращается NULL. Размер запра-
шиваемой памяти не должен превышать 64 Кбайта.
Возвращаемое значение:
В случае успеха возвращается указатель на выделен-
ную память; в противном случае - NULL.
Рекомендация:
Смотрите также free, malloc, realloc, farcalloc.
Пример:
/* компилировать в C или L модели*/
#include
#include
#include
#define num 50
main()
{
long * buffer;
unsigned int segment, offset;
buffer = calloc(num, sizeof(long));
if(! buffer)
{
fprint(stderr, "Calloc не сработала\n");
abort();
}
segment = FP_SEG(buffer);
offset = FP_OFF(buffer);
printf("Память размещена в сегменте
%x смещение: %x\n", segment, offset);
free(buffer);
}
ceil ЦЕЛАЯ ВЕРХНЯЯ ГРАНЬ
Использование:
#include
double ceil(double x); /* ANSI */
Описание:
Вычисляет значение удвоенной точности, представляю-
щее наименьшее целое, которое больше или равно x.
Пример:
#include
#include
main()
{
double x = 5.3, result;
result = ceil(x);
printf("The ceil of %f is %f \n", x, result);
}
Возвращаемое значение:
Возвращает значение удвоенной точности, равное наи-
меньшему целому, превышающему x.
Рекомендация:
Смотрите также floor, fmod.
chdir СМЕНИТЬ ТЕКУЩИЙ КАТАЛОГ
Использование:
#include
int chdir(char * path);
Описание:
Это системный вызов, который делает текущим каталог
(directory) по специфицированному аргументом марш-
руту (path). Последний должен приводить к существу-
ющему каталогу.
Пример:
#include
#include
char * path = "\\temp";
main()
{
int result;
result = chdir(path);
if(result != 0)
printf("Не могу перейти к каталогу %s\n",
path);
else
printf("Текущим стал каталог %s\n", path);
}
Возвращаемое значение:
Возвращается 0 в случае успеха и -1 в противном
случае с установлением errno.
Рекомендация:
Смотрите также mKdir, rmdir.
_chkstack ПРОВЕРИТЬ СТЕК
Использование:
#include
size_t _chkstack(void);
Описание:
Определяет переполнение стека, прекращает программу
с сообщением об этом. Эта функция могла бы вызывать-
ся из рекурсивных и прочих функций, которые исполь-
зуют большую часть стека. Контроль переполнения сте-
ка может выполняться автоматически установкой ключа
-s для ZTC2.
Пример:
/* do_tree - рекурсивная функция */
do_tree(t)
struct tree * t;
{
#ifdef _ZTC_ /* определен, если Zortech C\C++ */
_chkstack();
#endif
.
.
do_tree(t Д> left);
do_tree(t Д> right);
}
Возвращаемое значение:
Возвращает число свободных байтов, оставшихся в сте-
ке, если стек еще не переполнен.
clearerr СБРОСИТЬ ФЛАГ ОШИБКИ
Использование:
#include
void clearerr(FILE * fp); /* ANSI */
Описание:
Сбрасывает ошибку и флаг EOF, связанные с пото-
ком fp.
Пример:
#include
main()
{
FILE *stream;
char * string = "пример данных";
stream = fopen("file.dat", "r");
fprintf(stream, "%s\n", string);
if(ferror(stream))
{
fprintf(stderr,"Ошибка записи в file.dat\n");
clearerr(stream);
}
printf"При записи в файл ошибок не было\n");
fclose(stream);
}
Возвращаемое значение:
Нет.
Рекомендация:
Смотрите также feof, ferror.
clock ОПРЕДЕЛИТЬ ПРОЦЕССОРНОЕ ВРЕМЯ
Использование:
#include
clock_t clock(void); /* ANSI */
Описание:
Определяет процессорное время, использованное вы-
зывающим процессом в момент обращения к clock. IBM
PC имеет дискретность 1/18 сек. Другие компьютеры
под управлением MS DOS имеют дискретность в 1 сек,
хотя возвращаемое в качестве результата время выра-
жается в сотых долях секунды.
Пример:
#include
#include
main()
{
clock_t process;
process = clock()/CLK_TCK;
printf("Процессорное время в секундах =%d\n",
process);
}
Возвращаемое значение:
Возвращает время, апроксимирующее использованное
вызывающей программой процессорное время. Деля воз-
вращаемое clock() значение на величину, определяе-
мую макросом CLK_TCK, получите время в секундах.
Рекомендация:
Смотрите также asctime, ctime, difftime, localtime.
close ЗАКРЫТЬ ФАЙЛ
Использование:
#include
int close(int fd);
Описание:
Закрывает файл, ассоциированный с дескриптором fd.
Пример:
#include
#include
#include
main()
{
int fd, result;
fd = open("CON", O_RDONLY);
if(fd<0)
{
fprintf(stderr, "Не могу открыть CON\n");
abort();
}
result = close(fd);
printf("Результат от close %d\n", result);
}
Возвращаемое значение:
Возвращает 0 в случае успеха и -1 с установкой
errno в противном случае.
Рекомендация:
Смотрите также open, unlink.
cos, cosh КОСИНУС, КОСИНУС ГИПЕРБОЛИЧЕСКИЙ
Использование:
#include
double cos(double x); /* ANSI */
double cosh(double x); /* ANSI */
Описание:
Возвращают значение косинуса (cos) или гиперболиче-
ского косинуса (cosh) от x, где x - в радианах.
Пример:
#include
#include
main()
{
double value = 2.5556, result, hycos;
result = cos(value);
printf("The cosine of %f is %f\n", value, result);
hycos = cosh(value);
printf("The hyperbolic cosine of %f is %f\n",
value, hycos);
}
Возвращаемое значение:
Возвращаются значения cos(x) или ch(x) соответстве-
нно. В случае ошибки возвращается 0.
creat СОЗДАТЬ ФАЙЛ
Использование:
#include
#include
int creat(char * name, int pmode);
Описание:
Системный вызов creat() либо создает новый файл,
либо открывает и чистит существующий. Pmode задает
режимы чтения-записи файла в дальнейшем, после пер-
вого закрытия. Pmode принимает одно (или оба) из
следующих значений, определенных в stat.h :
#define S_IREAD 0000400 /* read permission, owner */
#define S_IWRITE 0000200 /* write permission, owner */
Когда требуются обе константы, их следует соединить
логической операцией (или) OR. Под управлением
MS DOS нет возможности дать разрешение только на
запись. В настоящее время значение pmode игнориру-
ется.
Пример:
#include
#include
main()
{
int fp;
fp = creat("file.dat",S_READ|S_WRITE);
IF(FP==-1)
printf("Не могу создать (creat) file.dat\n");
}
Возвращаемое значение:
Если возникает ошибка, возвращается -1 и устанавли-
вается errno в одно из значений:
ENOENT - Нет такого файла или каталога.
EMFILE - Слишком много открытых файлов.
EACCES - Разрешение не выдано.
Аналогично используемым в chdir(), close() и т.д.
Если файл создан, creat возвращает дескриптор управ-
ления файлом в MS DOS.
Рекомендация:
Смотрите также dos_creat, close, fopen, open.
ctime ДАТЬ КАЛЕНДАРНОЕ ВРЕМЯ
Использование:
#include
char *ctime(time_t *ntime); /* ANSI */
Описание:
Преобразует календарную дату и время, заданную
ntime, ко времени в форме ASCII строки литер.
Пример:
#include
#include
time_t ntime;
main()
{
time(&ntime);
printf("Текущее время %s\n", ctime(&ntime));
}
Возвращаемое значение:
Возвращает указатель на статическую строку из 26
ASCII литер в виде:
DDD MMM dd hh:mm:ss YYYY\n\0
где:
DDD - день недели
MMM - месяц
dd - день месяца
hh:mm:ss - часы:минуты:секунды
YYY - год
Строка перезаписывается при каждом вызове ctime().
Рекомендация:
Смотрите также asctime, clock, difftime, localtime,
time.
difftime ОПРЕДЕЛИТЬ ОТРЕЗОК ВРЕМЕНИ
Использование:
#include
double difftime(time_t time2, time_t time1);
/* ANSI */
Описание:
Вычитает time1 из time2.
Пример:
#include
#include
main()
{
register int delay; /* Задержка */
time_t start, finish;
time(&start);
for (delay = 0; delay<1000; delay++)
printf("%d\n", delay);
time(&finish);
printf("Задержка длилась %f секунд",
difftime(start, finish));
}
Возвращаемое значение:
Возвращает разницу time1 и time2 в секундах.
Рекомендация:
Смотрите также asctime, clock, ctime, localtime, time
Display Package Пакет отображения
Использование:
#include
void disp_close(void);
Выталкивает вывод и завершает использование пакета
отображения.
void disp_box(int type, int attr, unsigned row,
unsigned col, unsigned brow, unsigned rcol);
Рисует рамку с бордюром type и атрибутом attr. На-
чиная с левого верхнего угла в row,col и кончая в
нижнем правом угле в brow,rcol.
Значения type определяют:
0 - двойную бордюрную линию
1 - одинарную бордюрную линию
2 - толстый бордюр.
void disp_eeol(void);
Чистит остаток текущей строки, включая литеру под
курсором.
void disp_eeop(void);
Чистит экран, начиная с текущей позиции курсора.
void disp_endstand(void);
Выключает инверсный режим отображения. Должна вызы-
ваться после disp_startstand.
void disp_flush(void);
Выталкивает вывод на экран. Бывает необходима для
подготовки экрана к ожидаемому вводу пользователя.
int disp_getmode(void);
Возвращает текущий режим отображения (Смотрите
disp_setmode).
void disp_move(int row, int col);
Сдвигает курсор к позиции row.col. Позиция 0,0
есть верхний левый угол дисплея.
void disp_open(void);
Инициализирует дисплейный пакет. В процессе обраще-
ния определяются тип дисплея и адресация экранной
памяти. Инициализируются все глобалы.
unsigned disp_peekw(int row, int col);
Считывает атрибут литеры в заданной позиции дис-
плея.
unsigned disp_peekbox(unsigned * save, unsigned row,
unsigned col, unsigned brow, unsigned rcol);
Запоминает прямоугольную область экрана, определен-
ную верхним левым углом (row,col) и нижним правым
(brow,rcol), в буфере save.
void disp_pokebox(unsigned * save, unsigned row,
unsigned col, unsigned brow, unsigned rcol);
Восстанавливает прямоугольную область экрана, опре-
деленную верхним левым углом (row, col) и нижним
правым (brow, rcol), из буфера save.
void disp_pokew(int row, int col, int attr,charc);
Записывает литеру с указанным атрибутом в специфи-
цированную позицию.
void disp_printf(char *format, ...);
Осуществляет непосредственный форматный вывод на
экран (Смотрите описание функции printf).
void disp_putc(int c);
Записывает литеру c в текущую позицию экрана, ис-
пользуя атрибут литеры, установленный посредством
disp_setattr(). Отрабатывает табуляцию, перевод
строки, возврат каретки, backspace и т.д. корректно.
void disp_reset43(void);
Сбрасывает текстовый режим 80х43 EGA назад в ре-
жим 80х25.
void disp_scroll(int lines, unsigned ulrow,
unsigned ulcol, unsigned lrrow, unsigned lrcol,
unsigned attr);
Прокручивает содержимое экрана вверх:
lines - количество строк прокрутки
ulrow - верхний ряд двигаемой области
ulcol - верхний левый столбец
lrrow - нижний ряд двигаемой области
lrcol - нижний правый столбец
attr - видеоатрибут для остальных областей
(частей экрана).
void disp_set43(void);
Устанавливает текстовый режим отображения 80х43 EGA.
Не должна использоваться, пока дисплейный пакет
открыт. Эта функция требует наличия адаптеров EGA
или VGA. Действительное количество строк на экране
записывает в disp_numrows.
void disp_setattr(int attr);
Устанавливает атрибут литер, записываемых посред-
ством disp_putc() и disp_printf(). Ниже приведен
список атрибутов, описанных в файле disp.h :
DISP_REVERSEVIDEO ИНВЕРСНЫЙ
DISP_NORMAL НОРМАЛЬНЫЙ
DISP_UNDERLINE ПОДЧЕРКИВАНИЕ
DISP_NONDISPLAY НЕ ВЫСВЕЧИВАЕМЫЙ
Следующие атрибутные биты могут быть добавлены опе-
рацией OR:
DISP_INTENSITY ИНТЕНСИВНЫЙ
DISP_BLINK МИГАНИЕ
void disp_setcursortype(int startline*256+endline);
Устанавливает размер курсора. По умолчанию, DOS ис-
пользует:
начало конец использование
Monochrome 11 12 11*256+12
Color 6 7 6*256+7
void disp_setmode(unsigned char mode);
Устанавливает режим отображения. Если потребуется
не текущий режим отображения, вызов функции должен
предшествовать обращению к disp_open(). Ниже приве-
дены номера режимов:
0 - 40х25 черно-белый алфавитно-цифровой EGA
адаптер
1 - 40х25 цветной алфавитно-цифровой EGA
адаптер
2 - 80х25 черно-белый алфавитно-цифровой EGA
адаптер
3 - 80х25 цветной алфавитно-цифровой EGA
адаптер
4 - 320х200 4-цветный графический EGA адаптер
5 - 320х200 черно-белая графика на цветном
EGA адаптере
6 - 640х200 черно-белая графика на цветном
EGA адаптере
7 - 80х25 черно-белый алфавитно-цифровой на
монохромном EGA адаптере
D - 320х200 16-цветная графика на EGA адаптере
E - 640х200 16-цветная графика на EGA адаптере
F - 640х350 4-цветная графика на монохромном
EGA адаптере
10 - 640х350 16-цветная графика на EGA адаптере
void disp_startstand(void);
Устанавливает инверсный режим отображения для всех
последующих выводимых литер. Инверсный режим ото-
бражения снимается обращением к disp_endstand().
void disp_usebios(void);
Устанавливает режим записи литер на экран через
BIOS, а не непосредственно в видео память дисплея.
Это улучшает переносимость программы при снижении
скорости работы. Вызов должен следовать за обраще-
нием к disp_open().
Описание:
Дисплейный пакет обеспечивает быстрый ввод/вывод на
экран PC и надежную совместимость. Процедуры пакета
пишут непосредственно в видео память, выигрывая на
скорости. Эти процедуры не пойдут на компьютерах,
не являюшщихся совместимыми с IBM PC по принципам
отображения или в части BIOS. Ниже приведены глоба-
лы, которые инициализируются при вызове disp_open().
Эти глобалы следует только читать:
unsigned char disp_mono - 0 для цветного и 1 для
монохромного адаптера
unsigned char disp_snowycga - отличен от 0 для
"снежного" IBM CGA
unsigned char disp_mode - текущий режим отобра-
жения (Смотрите disp_setmode()).
unsigned char disp_inited - отличен от 0, если
дисплейный пакет инициализирован.
unsigned char disp_ega - отличен от 0 для IBM
EGA или VGA адаптеров.
unsigned disp_base - адрес сегмента видео памяти
(MDA = 0B000)(CGA = 0B800).
int disp_numrows - количество отображаемых строк
int disp_numcols - количество отображаемых столб-
цов
int disp_cursorrow - номер строки, в которой пози-
ционирован курсор
int disp_cursorcol - номер столбца, задающего по-
зицию курсора.
Возвращаемое значение:
disp_getmode возвращает текущий режим отображения.
Рекомендация:
Смотрите также printf, putc.
Пример:
#include
#include
char *string="Пример мигающей строки";
int cursor=((6*256)+11);
main()
{
char ch;
disp_open();
disp_startstand();
disp_printf("Строка выведена после обращения к
disp_startstand\n");
disp_endstand();
disp_setattr(DISP_BLINK | DISP_NORMAL);
disp_printf("%s\n", string);
disp setattr(DISP_INTENSITY | DISP_NORMAL);
disp_printf("Установлен атрибут высокой яркости\n");
disp setattr(DISP_NORMAL);
disp_usebios();
disp_printf("Строка высвечена при помощи BIOS\N");
disp_printf("Меняем размер курсора");
disp_setcursortype(cursor);
disp_flush();
ch = getch();
disp_close();
}
div ДЕЛИТЬ
Использование:
#include
div_t div(int numerator, int denominator); /* ANSI */
Описание:
Делит делимое на делитель, возвращая частное и остаток
Пример:
#include
main()
{
div_t answ;
int ina, inb;
puts("Введите два целых:");
scanf("%d %d", &ina, &inb);
answ = div(ina, inb);
printf("Частное=%d, и остаток=%d\n",
answ.quot, answ.rem);
}
Возвращаемое значение:
Возвращает структуру типа div_t.
Рекомендация:
Смотрите также ldiv.
DOS Package Пакет функций DOS
Использование:
#include
int dos_abs_disk_read(int drive, int num_sec,
int start_sec, char *buffer);
int dos_abs_disk_write(int drive, int num_sec,
int start_sec, char *buffer);
int dos_creat(char *name, unsigned attribute);
int dos_get_cntl_break(void);
long dos_getdiskfreespace(int drive);
int dos_get_verify(void);
void dos_set_verify(int on_off);
void dos_set_cntl_break(int on_off);
Описание:
dos_abs_disk_read, dos_abs_disk_write
Передают управление функциям DOS для выполнения
чтения или записи диска соответственно. Номера уст-
ройств (drive): 0 для устройства A, 1 - для B и т.д.
до 25. Количество секторов для чтения и записи спе-
цифицируется num_sec. Start_sec определяет первый
сектор чтения или записи. Buffer является источни-
ком или приемником данных.
dos_creat
Создает файл в DOS окружении. Байт атрибутов соот-
ветствует описанию в DOS Technical Reference
Manual. Описание атрибутов содержится в dos.h файле:
FA_RDONLY - 0x01 - только чтение
FA_HIDDEN - 0x02 - скрытый файл
FA_SYSTEM - 0x04 - системный файл
FA_LABEL - 0x08 - метка тома
FA_DIREC - 0x10 - каталог
FA_ARCH - 0x20 - архивный бит
dos_get_verify
Возвращает статус верификации DOS. Это отличное от
нуля значение, если VERIFY (проверка записи) вклю-
чена, и 0 в противном случае (Смотрите команду
VERIFY в DOS Technical Reference Manual).
dos_get_cntl_break
Возвращает статус break управления DOS. Это от-
личное от нуля значение, если реакция на прерывание
break включена и 0 в противном случае (Смотрите
BREAK команду в DOS Reference Manual).
dos_getdiskfreespace
Возвращает значение объема незанятого пространства
на диске. Drive определяет устройство: 0 - умолча-
ние (текущее устройство), 1 - A, 2 - B и т.д.
dos_set_verify
Устанавливает режим верификации записи (считывание
после записи). Эта функция имеет тот же эффект, что
и команды MS DOS VERIFY ON или VERIFY OFF.
dos_set_cntl_break
Включает или выключает режим реакции на break. Зна-
чение аргумента ненулевое включает режим break, и
0 - выключает. Эта функция имеет тот же эффект, как
и команда BREAK для командного процессора DOS.
Пример:
#include
#include
char buffer [512];
main()
{
char *offset;
long result;
int drive = 0;
result = dos_getdiskfreespace(drive);
printf("Default drive=%ld bytes free\n", result);
dos_abs_disk_read(0,1,0,buffer);
offset = &buffer[3];
printf("Boot record OEM=%s\n", offset);
}
Возвращаемое значение:
dos_creat
Возвращает DOS дескриптор файла , если файл создан,
в противном случае возвращает -1 и устанавливает
errno.
dos_get_cntl_break, dos_get_verify
Возвращают отличное от нуля значение, если статус
включен, и 0 в противном случае.
dos_getdiskfreespace
Возврашщает объем доступного дискового пространства
в байтах в формате long int.
dos_set_verify, dos_set_cntl_break
Не возвращают значение.
dos_abs_disk_read, dos_abs_disk_write
Возвращают 0 в случае успеха. Ненулевое значение
указывает на ошибку. Младший байт содержит код
ошибки DOS. Старший байт содержит спецификацию
ошибки BIOS(Смотрите DOS Technical Reference Manual)
ecvt ПРЕОБРАЗОВАТЬ ЧИСЛО В СТРОКУ
Использование:
#include
char * ecvt(double val, int ndig, int *pdecpt,
int *psign);
Описание:
Преобразует значение удвоенной точности в строку и
возвращает указатель на строку. Число создаваемых
цифр задает ndig. Число соответственно округляется.
Позиция десятичной точки относительно первой (левой)
цифры строки запоминается в *pdecpt. Если *pdecpt
отрицательно, точка находится на соответствующее ко-
личество позиций левее начала строки. В *psign за-
поминается 0, если val>0, и отличное от 0 значение
в противном случае. Строка записывается в статичес-
ки выделенную память, которая используется совмест-
но с ecvt() и обновляется при каждом обращении.
Пример:
#include
#include
char *buffer;
int dec, sign;
main()
{
buffer = ecvt(98.69138432, 5, &dec, &sign);
printf("buffer = \"%s\", decimal = %d,
sign = %d\n", buffer, dec, sign);
}
Возвращаемое значение:
Возвращает указатель на строку.
Рекомендация:
Смотрите также fcvt, sprintf.
execl - execvp ЗАПУСТИТЬ ПРОЦЕСС
Использование:
#include
#include /* Только для контроля ошибок */
int execl(char * name, char *arg0, *arg1,..., *argn,
NULL);
int execv(char * name, char *argv[]);
int execlp(char * name, char *arg0, *arg1,..., *argn,
NULL);
int execvp(char * name, char *argv[]);
Описание:
exec - функции создают и выполняют новый порожденный
процесс. Успешное выполнение exec вызывает замену в
памяти родительского процесса на порожденный процесс,
для которого должно быть достаточно памяти. Exec пере-
записывает новую программу на место текущей и начинает
исполнение. Name специфицирует эту программу. Если эта
спецификация не содержит описания пути доступа к фай-
лу программы и файл не содержится в текущем каталоге,
то в случае execvp и execlp для поиска файла использу-
ется переменная окружения PATH. Параметры обращения к
подпроцессу образуются из строк литер, заданных в об-
ращении к exec. Они образуют список аргументов, сово-
купная длина которых, исключая arg0, не должна превы-
шать 128 символов. Аргумент arg0 игнорируется. Он вклю-
чен по соображениям совместимости. Аргумент argv, ис-
пользуемый в execv и execvp, является массивом указа-
телей на строки. Последний указатель в argv должен
быть NULL.
Возвращаемое значение:
В случае успешного обращения exec не возвращает управ-
ления. В случае ошибки возвращает значение -1. Внешняя
переменная errno будет установлена в значение, иденти-
фицирующее ошибку. Эти значения декларированы в файле
errno.h:
E2BIG - Список аргументов превышает 128 байт.
ENOENT - Не найден файл.
Рекомендация:
Смотрите также abort, exit, spawn, system.
Пример:
#include
#include
#include
main(int argc, char * argv[])
{
char *args[4];
int result;
arg[0] = "arg0";
arg[1] = "arg1";
arg[2] = "arg2";
arg[3] = "arg3";
switch (argv[1][0])
{
case `1':
execl("myprog.exe", "arg0", "arg1", "arg2",
"arg3",NULL);
break;
case `2':
execlp("myprog.exe", "arg0", "arg1", "arg2",
"arg3", NULL);
break;
case `3':
execv("myprog.exe", "args");
break;
case `4':
execvp("myprog.exe", "args");
break;
default:
printf("Введите число между 1 и 4 в командной
строке\n");
exit(1);
}
printf("Процесс myprog.exe не исполнен.\n");
}
exit, _exit ЗАВЕРШИТЬ ВЫПОЛНЕНИЕ ПРОГРАММЫ
Использование:
#include
void exit(int exitstatus);
void _exit(int exitstatus); /* ANSI */
Описание:
exit вызывает все статические деструкторы (для C++ про-
грамм), выталкивает буфера вывода, закрывает выходные
файлы и возвращает управление MS DOS со статусом выхо-
да exitstatus.
_exit не вызывает статические деструкторы и не освобож-
дает буфера, а немедленно возвращает управление в
MS DOS. exit предпочтительно использовать в C++ прог-
раммах. exitstatus обычно 0 для указания на нормальное
завершение программы. Значение, отличное от нуля, ин-
дицирует ошибку. Только младший байт exitstatus посту-
пает к родительскому процессу. Статус выхода может
быть использован посредством имени ERRORLEVEL в команд-
ных (batch) файлах.
Возвращаемое значение:
Не возвращает значения.
Рекомендация:
Смотрите abort.
Пример:
#include
#include
main(int argc, char * argv[])
{
FILE *fp;
if(argc>1)
{
fp = fopen(argv[1],"r");
if(fp == NULL)
{
fprintf(stderr, "Не могу открыть файл
\"%s\"\n", argv[1]);
exit(1);
}
}
else
{
fprintf(stderr, "Файл не задан \n");
exit(1);
}
}
exp ЭКСПОНЕНТА
Использование
#include
double exp(double x); /* ANSI */
Описание:
Вычисляет экспоненту аргумента x.
Пример:
#include
main()
{
double dnum, xpnt;
dnum:=3.1415926;
xpnt = exp(dnum);
printf("The exp(%f) = %f\n", dnum, xpnt);
}
Возвращаемое значение:
Возвращает значение экспоненты аргумента x. В случае
переполнения (оverflow) устанавливает errno в ERANGE.
В случае потери значимости (underflow) возвращает 0
и не устанавливает errno.
Рекомендация:
Смотрите также log, pow, sqrt.
fabs АБСОЛЮТНОЕ ЗНАЧЕНИЕ ВЕЩЕСТВЕННОГО
Использование:
#include
double fabs(double x); /* ANSI */
Описание:
Возвращает абсолютное значение числа x, заданного с
удвоенной точностью.
Пример:
#include
#include
main()
{
double numbr, absval;
numbr = -1.0;
absval = fabs(numbr);
printf("fabs от (%f) равно %f\n", numbr, absval);
}
Возвращаемое значение:
Возвращает абсолютное значение аргумента.
Рекомендация:
Смотрите также abs, labs.
farcalloc - farrealloc РАБОТА С ДАЛЬНЕЙ КУЧЕЙ
Использование:
#include
void far *farmalloc(unsigned long size);
void far *farcalloc(unsigned long number, unsigned
long size);
long farcoreleft(void);
void farfree(void far *memblock);
void far *farrealloc(void far *memblock, unsigned long
newsize);
Описание:
farmalloc - Отводит память размером size в дальней
куче.
farcalloc - Отводит память под массив длиной number
элементов, каждый из которых длиной size
байтов, в дальней куче.
farcoreleft - Возвращает величину памяти в дальней ку-
че.
farfree - Освобождает блок памяти memblock, выде-
ленный прежде в дальней куче.
farrealloc - Переопределяет размер ранее загруженного
блока памяти memblock значением newsize.
Заметим, что вся доступная память (RAM) может быть
задействована; может быть выделен блок памяти более
64 Кб и для доступа к блокам памяти используются
дальние указатели.
Эти функции непосредственно обращаются к MS DOS. Они бо-
лее медленны, чем, например, malloc. Они могут также предотв-
ратить переполнение кучи в S, M, T моделях памяти (и полезны
прежде всего для ее расширения). Указатели на загруженную па-
мять должны быть освобождены прежде, чем завершится програм-
ма, в противном случае память останется занятой до перезаг-
рузки компьютера.
Пример:
#include
#include
main()
{
char far *memblock;
long allocate = 65000;
printf("%lu байтов памяти свободны\n",farcoreleft());
memblock = farmalloc(allocate);
if (memblock == NULL)
{
printf("не смогли разместить блок памяти\n");
exit(1);
}
printf("%lu байтов отведено", allocate);
printf("%lu байтов памяти свободно\n",farcoreleft());
allocate/=2;
memblock = farrealloc(memblock, allocate);
printf("память переразмещается до %lu байтов",
allocate);
printf("%lu байтов памяти свободно\n",farcoreleft());
farfree(memblock);
printf("блок памяти освобожден");
printf("%lu байтов памяти свободно\n",farcoreleft());
}
Возвращаемое значение:
farmalloc - возвращает дальний указатель на размещен-
ный блок памяти или NULL, если нет доста-
точного количества памяти.
farcalloc - возвращает дальний указатель на загружен-
ный блок памяти или NULL, если нет доста-
точного количества памяти.
farcoreleft - возвращает величину памяти в дальней ку-
че.
farfree - ничего не возвращает.
farrealloc - возвращает адрес перезагруженного блока,
который может быть отличен от исходного.
Рекомендация:
Смотрите также calloc, free, malloc, realloc.
_farptr_norm НОРМАЛИЗОВАТЬ ДАЛЬНИЙ УКАЗАТЕЛЬ
_farptr_fromlong ДАЛЬНИЙ УКАЗАТЕЛЬ ИЗ ДЛИННОГО
_farptr_tolong ДАЛЬНИЙ УКАЗАТЕЛЬ В ДЛИННОЕ
Использование:
#include
void far *_farptr_norm(void far *ptr);
void far *_farptr_fromlong(long value);
long _farptr_tolong(void far *ptr);
Описание:
_farptr_norm нормализует дальний указатель таким обра-
зом, что смещение становится менее 16. _farptr_fromlong
преобразует long к нормализованному дальнему указателю.
Параметр задает линейный адрес от 0. _farptr_tolong
преобразует дальний указатель к линейному адресу типа
long, представленному данным указателем.
Возвращаемое значение:
_farptr_norm возвращает нормализованный дальний указа-
тель. _farptr_fromlong возвращает нормализованный даль-
ний указатель. _farptr_tolong возвращает значение типа
long.
Пример:
#include
#include
main()
{
void far * pin, far * pout;
long value;
pin = MK_FP(0x1100, 0x2678);
pout = _farptr_norm(pin);
printf("%lp после нормализации должен стать"
"1367:0008, а фактически=%lp\n",
pin, pout);
value = 0xB7543;
pout = _farptr_fromlong(value);
printf("Преобразование 0x%lX в дальний указатель"
"должно быть B754:0003, \n фактически=%lp\n",
value, pout);
pin = MK_FP(0xbB754, 0x0013>);
value = _farptr_tolong(pin);
printf("Преобразование %lp в long должно быть"
"0xB7553, \n it actually is 0x%lX\n", pin,
value);
}
fclose ЗАКРЫТЬ ФАЙЛ
Использование:
#include
int fclose(FILE *fp); /* ANSI */
Описание:
Закрывает файл, ассоциированный с fp. Буфер вывода,
связанный с fp, перед закрытием выталкивается.
Пример:
#include
main()
{
FILE *fp;
fp = fopen("file.dat", "r");
if (fp==NULL)
printf("Файл данных не открыт\n");
else
{
fclose(fp);
printf("Файл file.dat закрыт при помощи
fclose\n");
}
}
Возвращаемое значение:
Возвращает 0, если поток успешно закрыт, и -1 в про-
тивном случае.
Рекомендация:
Смотрите также close, fopen, freopen.
fcvt ПРЕОБРАЗОВАТЬ DOUBLE В СТРОКУ С ФИКСИРОВАННОЙ ТОЧКОЙ
Использование:
#include
char *fcvt(double val, int nfrac, int *pdecpt,
int *psign);
Описание:
То же, что и ecvt(), за исключением того, что nfrac
специфицирует здесь количество цифр, которое должно
быть после десятичной точки.
Пример:
#include
#include
main()
{
char *buffer;
int dec, sign;
buffer = fcvt(98.69138432, 5, &dec, &sign);
printf("buffer=\"%s\", decimal = %d, sign = %d\n",
buffer, dec, sign);
}
Возвращаемое значение:
Возвращает указатель на статическую строку цифр, пере-
записываемую при каждом обращении к ecvt или fcvt.
Рекомендация:
Смотрите также ecvt, sprintf.
feof ПРОВЕРКА ПРИЗНАКА КОНЦА ФАЙЛА
Использование:
#include
int feof (FILE *fp); /* ANSI */
Описание:
Определяет, находится ли поток fp в конце файла.
Пример:
#include
#define BUFSIZE 128
char buffer [BUFSIZE];
main()
{
FILE *fp;
fp = fopen("file.dat", "r");
{
while(!feof(fp))
fgets(buffer, BUFSIZE, fp);
}
printf("Файл прочитан, встретился EOF \n", buffer);
}
Возвращаемое значение:
Ненулевое значение, если текущая позиция является кон-
цом(т.е. установлен флаг `eof'). После установки флага
не разрешены операции чтения. Флаг опускается при опе-
рациях rewind, fseek, и при закрытии потока. Возвраща-
ет 0, если флаг не установлен.
Рекомендация:
Смотрите также clearerr, ferror.
ferror ПРОВЕРКА ПРИЗНАКА ОШИБКИ В ФАЙЛЕ
Использование:
#include
int ferror (FILE * fp); /* ANSI */
Описание:
Контролирует флаг `error' в потоке fp. Этот флаг опус-
кается по rewind, clearerr, fseek или при закрытии по-
тока.
Пример:
#include
main()
{
int c;
if ((c=fgetc(stdin))==EOF)
if (ferror(stdin))
{
fprintf(stderr, "Ошибка чтения\n");
clearerr(stdin);
}
printf("Без ошибок\n");
}
Возвращаемое значение:
Ненулевое значение, если установлен флаг ошибки, 0 в
противном случае.
Рекомендация:
Смотрите также clearerr, feof.
fflush ВЫТОЛКНУТЬ БУФЕР ФАЙЛА
Использование:
#include
int fflush(FILE *fp); /* ANSI */
Описание:
Выталкивает буфер, связанный с потоком fp. Если файл
открыт по записи, буфер сбрасывается на файл. Если
файл открыт по чтению, буфер чистится.
Пример:
#include
FILE *fp;
main()
{
if (!(fp = fopen("file.dat", "w")))
return;
fflush(fp); /* выталкиваем буфер на диск для */
/* защиты данных перед выполнением */
/* операции, могущей сломать систему */
}
Возвращаемое значение:
Возвращает 0, если буфер вытолкнут успешно, в против-
ном случае возвращает EOF.
Рекомендация:
Смотрите также fclose, flushall.
fgetc ВЗЯТЬ БАЙТ ИЗ ФАЙЛА
Использование:
#include
int fgetc(FILE *fp); /* ANSI */
Описание:
Читает и возвращает следующий байт из потока fp.
Пример:
#include
main()
{
int ch;
fputs("Вводите данные, в конце - ctrl-Z: ", stdout);
while((ch = fgetc(stdin))!=EOF)
fputc(ch, stdout);
}
Возвращаемое значение:
Возвращает байт при успешном чтении или EOF, если
встретится конец файла или ошибка чтения.
Рекомендация:
Смотрите также fputc, putchar, getc, getchar, getche,
getch.
fgets ВЗЯТЬ СТРОКУ ИЗ ФАЙЛА
Использование:
#include
char *fgets(char *str, int n, FILE *fp); /* ANSI */
Описание:
Считывает литеры из потока fp в строку по указателю
str. Чтение заканчивается, когда встречается литера
`\n' (новая строка), конец файла, возникает ошибка чте-
ния или число прочитанных литер достигает n-1. Строка
завершается 0. Литера '\n' (новая строка) включается в
строку (перед 0).
Пример:
#include
main()
{
char buffer[225];
int buflen;
char *result;
buflen=255;
fputs("Введите строку данных\n", stdout);
result=fgets(buffer, buflen, stdin);
if (!result)
printf("\n конец файла (EOF) или ошибка
(ERROR)\n");
else fputs(buffer, stdout);
}
Возвращаемое значение:
Возвращает строку str в случае успеха. Если не было
прочитано ни одной литеры и произошла ошибка чтения
или встречен EOF, возвращает NULL, а строка str оста-
ется без изменения. Если возникла ошибка при чтении,
возвращает NULL, а в строке возможен мусор.
Рекомендация:
Смотрите также fputs, gets, puts.
fileno ДАТЬ ДЕСКРИПТОР ФАЙЛА
Использование:
#include
int fileno(FILE *fp);
Описание:
Возвращает дескриптор файла, ассоциированного с пото-
ком fp (`file handle'в MS DOS).
Пример:
#include
main()
{
int fd,
fd = fileno(stderr);
printf("Дескриптор файла stderr равен %d\n", fd);
fd = fileno(stdaux);
printf("Дескриптор файла stdaux равен %d\n", fd);
fd = fileno(stdprn);
printf("Дескриптор файла stdprn равен %d\n", fd);
}
Возвращаемое значение:
Возвращает дескриптор файла. Об ошибках не сообщается.
Рекомендация:
Смотрите также fopen, freopen.
filesize ДАТЬ РАЗМЕР ФАЙЛА
Использование:
#include
long filesize(char *filename);
Описание:
Определяет размер файла в байтах. Имя файла должно
быть именем существующего файла, закрытого в данный
момент.
Пример:
#include
main()
{
long size;
size = filesize("file.dat);
printf("Размер файла file.dat равен %d\n", size);
}
Возвращаемое значение:
Возвращает длину файла в байтах в случае успеха, в
противном случае возвращает -1L и устанавливает errno.
Рекомендация:
Смотрите также stat, fstat.
findfirst, findnext ПОИСК ФАЙЛОВ ПО ШАБЛОНУ
Использование:
#include
struct FIND *findfirst(char*partname, int attribute);
struct FIND *findnext(void);
Описание:
Системные вызовы findfirst и findnext используются для
поиска файлов, соответствующих шаблону, который может
охватывать целое множество файлов посредством исполь-
зования символов `*' или `?' в имени файла или его
расширении (но не в описании пути доступа к файлу).
Аргумент `attribute' является атрибутом искомого файла.
В обращении к findfirst может быть задано более одного
атрибутного бита. Соответствующие описания атрибутных
битов находятся в dos.h файле:
АТРИБУТ ТИП ФАЙЛА
FA_RDONLY 0x01
FA_HIDDEN 0x02
FA_SYSTEM 0x04
FA_LABEL 0x08
FA_DIREC 0x10
FA_ARCH 0x20
В случае нулевого значения `attribute' отыскиваются
все обычные файлы. Указатель на возвращаемую структу-
ру является статическим, так что, если эта информация
нужна, она должна быть скопирована в другой буфер.
Обращение к findnext дает следующий файл, подходящий
по шаблону, заданному в предшествующем обращении к
findfirst. Поэтому вызовы findnext должны следовать за
вызовом findfirst.
Пример:
#include
#include
main()
{
struct FIND *p;
printf("Вывод каталога *.*\n");
p = findfirst("*.*", 0);
while (p)
{
printf("%s\n", p->name);
p = findnext();
}
}
Возвращаемое значение:
В случае успеха возвращает указатель на статическую
структуру FIND, определенную в dos.h файле, или NULL
для индикации конца поиска или ошибки.
floor ЦЕЛАЯ ЧАСТЬ
Использование:
#include
double floor(double x); /* ANSI */
Описание:
Возвращает наибольшее целое (в виде числа с удвоенной
точностью), не превышающее x.
Пример:
#include
#include
main()
{
double d;
d=floor(4.8);
printf("floor от 4.8 равен %f\n", d);
d=floor(-4.8);
printf("floor от -4.8 равен %f\n", d);
}
Возвращаемое значение:
Возвращает результат типа double.
Рекомендация:
Смотрите также ceil, fmod.
flushall ВЫТОЛКНУТЬ БУФЕРА ВСЕХ ОТКРЫТЫХ ФАЙЛОВ
Использование:
#include
int flushall(void);
Описание:
Функция flushall выталкивает буфера ввода/вывода всех
открытых потоков. Все потоки после работы flushall oc-
таются открытыми. Любая операция чтения читает в буфе-
ра новые данные.
Пример:
#include
main ()
{ int totalflushed;
totalflushed = flushall();
}
Возвращаемое значение:
Возвращает число открытых потоков.
Рекомендация:
Смотрите также fflush
fmod ОСТАТОК ОТ ДЕЛЕНИЯ ДВУХ ЧИСЕЛ
Использование:
#include
double f mod (double x, double y);
Описание:
fmod выдает в плавающем формате остаток от деления од-
ного числа на другое. Она возвращает x, если он ноль,
либо число F с тем же знаком, что у x, - такое, что
x = L*y + F для некоторого целого L и |F| < |y|.
Пример:
#include
#include
main ()
{
double x, y, d;
x = 5.0; y = 3.0;
d = fmod (x,y);
printf("fmod(%.2f, %.2f) = %f\n,x,y,d);
}
Возвращаемое значение:
fmode возвращает остаток в формате с плавающей точкой.
Рекомендация:
Смотрите также ceil, floor, modf
fopen ОТКРЫТЬ ФАЙЛ
Использование:
#include
FILE *fopen(char *name, char *mode); /* ANSI */
Описание:
Открывает файл, заданный именем name. Mode есть строка
символов, указывающая режим доступа к файлу. Возможные
значения mode:
`r' - для чтения
`w' - для записи (если файл существует, он обреза-
ется по началу)
`a' - для добавления (если файл существует, то
открывается для записи в конец файла, иначе
он создается)
`r+' - для чтения и записи
`w+' - для чтения и записи (если файл существует,
он обрезается, иначе он создается)
`a+' - для чтения и записи (если файл существует,
производится позиционирование в конец файла,
иначе он создается)
Дополнительно в строку mode может быть добавлен символ
`b' для открытия файла в двоичном режиме (умолчание за-
дает текстовый режим). Если файл открыт и для чтения и
для записи, только чтение или только запись может вы-
полняться. Чтобы переключиться от чтения к записи или
наоборот, необходимо вызвать fseek() применительно к
данному потоку, если только при чтении (вводе) не был
встречен признак EOF (Еnd Of File) конца файла.
Пример:
#include
main()
{
FILE *fp;
fp = fopen("file.dat", "r");
printf("Открыли текстовый файл\n");
if (fp) fclose(fp);
fp = fopen("CON", "wb");
printf("Звуковой сигнал\n");
fputc(0x07, fp);
if (fp) fclose(fp);
fp = fopen("CON", "rb");
printf("Введите строку\n");
if (fp && fgetc(fp)==3);
printf("\n Введено Ctrl-C\n");
if (fp) fclose(fp);
fp = fopen("PRN", "w");
printf("Пишем на принтер\n");
if (fp) fclose(fp);
fp = fopen("file.dat", "a+");
printf("Обновляем файл в коде ASCII\n");
if (fp) fclose(fp);
}
Возвращаемое значение:
Возвращает указатель на FILE для открытого файла.
Значение NULL указывает на наличие ошибки.
Рекомендация:
Смотрите также fclose, freopen, open
FP_OFF, FP_SEG СЕГМЕНТ, СМЕЩЕНИЕ
Использование:
#include
unsigned FP_OFF(int far *long_pointer);
unsigned FP_SEG(void far *long_pointer);
Описание:
FP_OFF и FP_SEG используются для извлечения из даль-
него указателя сегмента и смещения. Эти функции реали-
зованы как макросы.
Пример:
#include
#include
main()
{
char far *p;
unsigned int segment, offset;
p = MK_FP(0xb000, 0);
segment = FP_SEG(p);
offset = FP_OFF(p);
printf("Сегмент для моновидео:
сегмент:смещение = %04x:%04\n", segment, offset);
}
Возвращаемое значение:
FP_SEG возвращает 16-битовое значение, являющееся сег-
ментной частью дальнего указателя.
FP_OFF возвращает 16-битовое значение, являющееся
смещением в границах сегмента дальнего указателя.
Рекомендация: Смотрите также MK_FP.
fprintf ФОРМАТНЫЙ ВЫВОД В ФАЙЛ
Использование:
#include
int fprintf(FILE *stream, const char * format,...);
/* ANSI */
Описание:
Осуществляет форматированный вывод в специфицированный
поток. Описание format совпадает с аналогичным описа-
нием для printf.
Пример:
#include
main()
{
fprintf(stdout, "Это пример\n");
}
Возвращаемое значение:
Возвращает количество записанных литер либо отрицате-
льное значение в случае ошибки.
Рекомендация:
Смотрите также printf, sprintf, vfprintf.
fputc ЗАПИСЬ БАЙТА В ФАЙЛ
Использование:
#include
int fputc (int c, FILE *fp); /* ANSI */
Описание:
Записывает байт `c' в поток fp.
Пример:
#include
FILE * fp;
main()
{
char * line = "Это пример";
fp = stdout;
while (*line)
fputc (*line++, fp);
}
Возвращаемое значение:
Возвращает байт, записанный в поток. В случае ошибки
возвращает EOF.
Рекомендация:
Смотрите также fgetc, getc, getchar.
fputs ЗАПИСЬ СТРОКИ В ФАЙЛ
Использование:
#include
int fputs(char *s, FILE *fp); /* ANSI */
Описание:
Записывает строку 's', исключая завершающую литеру О,
в поток fp
Пример:
#include
main()
{
if (fputs("Hello World\n", stdout)==-1)
fprintf(stderr, "Ошибка вывода\n");
}
Возвращаемое значение:
Возвращает 0 в случае успеха и не 0 при ошибке записи.
Рекомендация:
Смотрите также fgets, gets, puts.
fread ЧИТАТЬ ИЗ ФАЙЛА
Использование:
#include
int fread(void * p, unsigned sizelem, unsigned n,
FILE *fp); /* ANSI */
Описание:
Читает n элементов из потока fp в массив по указателю
p; sizelem - размер элемента массива в байтах.
Пример:
#include
main()
{
char *dest;
int size=1;
int number=256, numread;
FILE *fp;
if ((fp=fopen("file.dat", "r"))==NULL)
return;
dest=calloc(256,1);
numread=fread(dest, size, number, fp);
printf("Всего прочитано %d\n", numread);
fprintf(stdout, "Прочитанные данные\n, %s", dest);
free(dest);
}
Возвращаемое значение:
Возвращает количество полностью прочитанных элементов.
В случае ошибки или встречи конца файла возвращаемое
значение будет меньше n.
Рекомендация:
Смотрите также fwrite, read
free ОСВОБОДИТЬ ПАМЯТЬ
Использование:
#include
int free(void *p); /* ANSI */
Описание:
Освобождает память по указателю p. Эта память должна
быть выделена ранее с использованием функций calloc,
malloc или realloc. Если p = NULL, free бездействует.
Если был использован флаг компилятора строгой ANSI со-
вместимости, то free возвращает void (т. е. не возвра-
щает значения).
Предостережение: не освобождайте данные более одного раза,
не работайте с освобожденными данными.
Пример:
#include
#include
main()
{
char * p:
if ((p = malloc(1000))==NULL)
printf("Не могу отвести память\n");
if (free(p) == -1)
abort(); /* Что-то ужасно плохо */
}
Возвращаемое значение:
Возвращает 0 в случае успеха или -1, если испорчен
механизм управления памятью или p ошибочно. Значе-
ние -1 указывает на наличие серьезной ошибки в прог-
рамме. free игнорирует несуразные указатели.
Рекомендация:
Смотрите также calloc, malloc, realloc.
freopen ОТКРЫТЬ ФАЙЛ ПОВТОРНО
Использование:
#include
FILE *freopen(char *name, char *mode, FILE *fp); /* ANSI */
Описание:
Закрывает файл fp. Ошибки при закрытии файла игнориру-
ются. Открывает новый файл и связывает с ним поток fp.
Name и mode имеют тот же смысл, что определен в fopen.
Пример:
#include
main()
{
fp = freopen("file.dat", "w+", stdout);
if (fp == NULL)
fprintf(stderr, "Ошибки при freopen\n");
else
fprintf(fp, "Эти данные пойдут в file.dat\n");
}
Возвращаемое значение:
В случае успеха возвращает fp, иначе NULL.
Рекомендация:
Смотрите также fclose, fopen, open.
frexp ЭКСПОНЕНЦИАЛЬНОЕ ПРЕДСТАВЛЕНИЕ
Использоваение:
#include
double frexp(double value, int *eptr); /* ANSI */
Описание:
Представляет значение двойной точности value в виде
мантиссы x и показателя e, так что value==x*2**e,
x>.5 и x<=1.0. e запоминается по eptr, а значение x
возвращается как результат.
Пример:
#include
#include
main()
{
double d1,d2;
int i;
d2=15.3;
d1=frexp(d2,&i);
printf("d1=%f i=%d\n", d1, i);
}
Возвращаемое значение:
Возвращает мантиссу экспоненциального представления (x).
Рекомендация:
Смотрите также ldexp, modt.
fscanf ФОРМАТНЫЙ ВВОД ИЗ ФАЙЛА
Использование:
#include
int fscanf(FILE *fp, char *format,...) /* ANSI */
Описание:
Читает литеры из входного потока fp. Считанные литеры
преобразуются в соответствии со строкой формата. Пре-
образованные литеры запоминаются по указанным аргумен-
там-указателям. Отметим, что аргументы должны быть ука-
зателями, по которым fscanf запишет введенные значения
Пример:
#include
char fst[10], *lst=" ";
int ttl;
main()
{
int rt;
rt = fscanf(stdin, "%s %s %d",fst,lst,&ttl);
return rt=3;
}
Возвращаемое значение:
Возвращает количество успешно проведенных преобразо-
ваний. Процесс заканчивается при встрече первой не-
подходящей литеры или признака конца файла (EOF).
Ноль на выходе означает, что не обработано ни одного
поля.
Рекомендация: Смотрите также scanf.
fseek ПОЗИЦИОНИРОВАТЬ ФАЙЛ
Использование:
#include
#include
int fseek(FILE *fp,long offset,int origin); /* ANSI */
Описание:
Устанавливает позицию в файле, связаннном с потоком fp.
Смещение в байтах является величиной со знаком и берет-
ся относительно origin. Значения origin определены в
io.h файле:
SEEK_SET - начало файла
SEEK_CUR - текущая позиция
SEEK_END - конец файла
Если файл открыт в текстовом режиме, смещение может
быть только значением, возвращенным ftell, а origin
должно быть 0, или offset должно быть 0. Если непос-
редственно перед вызовом fseek работала ungetc, ее
результаты теряются. Если файл был открыт в режиме
чтения/записи, следом за fseek можно выполнить чтение
или запись.
Пример:
#include
#include
main()
{
FILE *fp;
fp = fopen("file.dat", "r+");
fseek(fp, 0L, SEEK_END); /* Перейти в конец файла */
fseek(fp, 0L, SEEK_SET); /* Перейти в начало файла */
fseek(fp, 20L, SEEK_SET); /* Перейти на смещение 200 */
}
Возвращаемое значение:
Возвращает 0 в случае успеха и ненулевое значение в
случае ошибки.
Рекомендация:
Смотрите также ftell, lseek.
fstat ВЗЯТЬ СТАТУС ФАЙЛА
Использование:
#include
int fstat(int fd, struct stat *buf);
Описание:
Извлекает информацию относительно открытого файла fd и
запоминает ее в структуре stat по указателю buf. Струк-
тура содержит следующие поля:
st_dev - номер дискового устройства с файлом fd
или значение fd, если fd является уст-
ройством
st_mode - битовая маска, содержащая информацию
об открытии файла:
S_IFCHR - если fd является устройством
S_IFREG - если fd - обычный файл
S_IREAD - если файл открыт по чтению
S_IWRITE - если файл открыт по записи
st_nlink - всегда 1
st_rdev - то же, что и st_dev
st_size - размер файла в байтах
st_atime - время последней модификации
st_ctime - то же, что и st_atime
st_mtime - то же, что и st_atime
Три не упомянутых выше поля: st_ino, st_vid, st_did, -
не имеют смысла в DOS. Они установлены в 0 и обеспечи-
вают совместимость с UNIX.
Замечание: fstat не может быть вызван из C++ программы
Пример:
#include
#include
#include
#include
#include
#include
struct stat buf;
int fh, result;
main()
{
fh=open("file.dat", O_RDONLY);
result=fstat("fh, &buf");
if (result !=0)
printf("Плох дескриптор файла\n");
else
{
printf("Размер файла: %ld\n", buf.st_size);
printf("Номер устройства: %d\n", buf.st_dev);
printf("Время модификации: %s",
ctime(&buf.st_atime));
}
}
Возвращаемое значение:
Возвращает 0, если информация успешно извлечена, и -1,
если плох дескриптор файла, с установкой errno в EBADF.
Рекомендация:
Смотрите также stat, findfirst, findnext, isatty.
ftell ДАТЬ ПОЗИЦИЮ В ФАЙЛЕ
Использование:
#include
long ftell(FILE *fp); /* ANSI */
Описание:
Возвращает текущую позицию в файле, связанном с пото-
ком fp. Если файл открыт в текстовом режиме, возвраща-
емое значение может не отражать точного количества
действительно считанных или записанных байтов.
Пример:
#include
long position;
FILE *fp;
main()
{
fp=fopen("file.dat", "a");
fprintf(fp, "Пример строки данных\n");
position=ftell(fp); /* берем позицию в файле */
printf("Текущая позиция в файле: %ld\n", position);
fclose(fp);
}
Возвращаемое значение:
Возвращает текущую позицию в файле или -1, если встре-
тилась ошибка, с установлением errno.
Рекомендация:
Смотрите также fseek, isatty.
fwrite ПИСАТЬ В ФАЙЛ
Использование:
#include
int fwrite(void *buffer, unsigned sizelem, unsigned n,
FILE *fp); /* ANSI */
Описание:
Записывает n элементов размером sizelem байтов каждый
из buffer в поток fp.
Пример:
#include
#include
main()
{
char *buffer;
unsigned sizelem, n;
FILE *fp;
int wrtn;
buffer=calloc(255,1);
sizelem=1;
n=255;
fp=fopen("file.dat", "a");
strcpy(buffer, "\n Пример данных\n");
wrtn=fwrite(buffer, sizelem, n, fp);
free(buffer);
}
Возвращаемое значение:
Возвращает количество полностью записанных элементов,
которое может быть меньше n, если имела место ошибка.
Рекомендация:
Смотрите также fread, write
getc, getchar, getche, getch ВЗЯТЬ БАЙТ ИЗ ФАЙЛА
Использование:
#include /* getc(), getchar() */
#include /* getche(), getch() */
int getc(FILE *fp); /* ANSI */
int getchar(void); /* ANSI */
int getche(void);
int getch(void);
Описание:
getc извлекает один байт из потока fp.
getchar извлекает один байт из потока stdin.
getche извлекает один байт из потока stdin и выдает
эхо, т.е. выводит байт в stdout. Эта процедура возвра-
щает значение, как только байт введен, не ожидая нажа-
тия клавиши .
getch, в отличие от getche, не обеспечивает эхо-вывода
в stdout.
getche и getch обращаются непосредственно к MS DOS.
Они обходятся без нормальной буферизации, используемой
getchar и getc.
ЗАМЕЧАНИЕ: ungetc нельзя использовать совместно с getch
и getche.
Пример:
#include
#include
main()
{
int c;
printf("Введите литеру и затем нажмите RETURN:");
c=getchar();
printf("То был пример с getchar\n");
getc(stdin);
printf("Введите литеру: ");
c=getche();
printf("То был пример с getche\n");
printf("Hажмите на функц. клавишу и потом на литеру");
c=getch();
printf("\n Литера [%c] - пример с getch",c);
}
Возвращаемое значение:
Каждая из функций возвращает прочитанный байт. getc и
getchar возвращают EOF в случае ошибки. getch и getche
игнорируют ошибки.
Рекомендация:
Смотрите также fgetc, putc, putchar, ungetc.
getcwd ДАТЬ ТЕКУЩИЙ КАТАЛОГ
Использование:
#include
char *getcwd(char *buffer, int length);
Описание:
Возвращает имя устройства и описание пути к текущему
каталогу в заданном буфере. Если buffer равен NULL, то
getcwd вызывает malloc() с заявкой на память размером
length байтов. Length является длиной buffer, который
должен быть достаточно большим, чтобы включить информа-
цию вместе с заключительным 0.
Пример:
#include
#include
main()
{
char buff[66];
if (getcwd(buff, sizeof(buff))==NULL)
perror("ошибка getcwd");
else
printf("%s", buff);
}
Возвращаемое значение:
Возвщает buffer в случае успеха и NULL в случае ошибки,
c устанавлением errno в одно из значений:
ENOMEM - исчерпание памяти
ERANGE - описание пути доступа длиннее, чем
length-1.
Рекомендация:
Смотрите также chdir, mkdir, rmdir.
getDS ВЗЯТЬ ЗНАЧЕНИЕ РЕГИСТРА DS
Использование:
#include
int getDS(void);
Описание:
Возвращает значение регистра DS (Data segment - сегмент
данных).
Пример:
#include
#include
main()
{
unsigned int data_seg;
data_seg = getDS();
printf("Текущее содержимое DS равно %x\n", data_seg);
}
Возвращаемое значение:
Возвращает текущее значение регистра DS.
Рекомендация: Смотрите также segread.
getenv ДАТЬ ОКРУЖЕНИЕ
Использование:
char getenv(char *name); /* ANSI */
Описание:
Отыскивает в списке переменных окружения строку вида
= и возвращает указатель на строку value,
если NAME найдена. Строка должна быть набрана
заглавными буквами.
Пример:
#include
#include
main()
{
char *path;
path = getenv("PATH");
printf("PATH = %s\n", path);
}
Возвращаемое значение:
Возвращает указатель на строку значения переменной
окружения. В случае, если окружение не содержит ука-
занного имени, возвращает NULL.
gets ВВОД СТРОКИ
Использование:
#include
char *gets(char *str); /* ANSI */
Описание:
Считывает байты из потока stdin в строку str до тех
пор, пока не встретит признак новой строки или конца
файла. Признак "новая строка"(newline) не записывается
в строку. Строка завершается 0. Строка должна быть до-
статочно большой, чтобы вместить результат.
Пример:
#include
main()
{
char buffer[125];
printf("Наберите строку:");
gets(buffer);
printf("Была введена строка: %s\n", buffer);
}
Возвращаемое значение:
Возвращает str. В случае ошибки чтения или при встрече
конца файла в начале чтения возвращает NULL.
Рекомендация:
Смотрите также fgets, puts.
hypot ГИПОТЕНУЗА
Использование:
#include
double hypot(double x, double y);
Описание:
Вычисляет длину гипотенузы прямоугольного треугольника
со сторонами x, y. Гипотенуза является значением,
полученным вычислением квадратного корня из (x*x+y*y).
Пример:
#include
#include
main()
{
double x, y;
printf("Введите плавающее x:");
scanf("lf", &x);
printf("Введите плавающее y:");
scanf("lf", &y);
printf("Гипотенуза на катетах [%f, %f] равна [%f]\n",
x, y, hypot(x,y));
}
Возвращаемое значение:
Длина гипотенузы, построенной на катетах x, y.
index НАЙТИ ЛИТЕРУ В СТРОКЕ
Использование:
char *index(char *s, int c);
Описание:
Отыскивает первое вхождение литеры `c' в строку `s'.
Эта функция идентична strchr.
Пример:
#include
#include
char string2[50] = "2 пример строки";
main()
{
printf("\n Пример на index %s \n",
index(string2, 'и'));
}
Возвращаемое значение:
Возвращает указатель на `c', если `c' найдена в строке
`s', и NULL в противном случае.
Рекомендация:
Смотрите также strchr, strcpy, strcmp, strrchr.
inp, inpw ВВОД ИЗ ПОРТА
Использование:
#include
int inp(int port_address);
int inpw(int port_address);
Описание:
Обеспечивают интерфейс С с аппаратными портами 8086,
реализуя команды 8086 in и out обмена с портами.
inp: считывает байт из указанного порта.
inpw: считывает слово из указанного порта.
Компилятор генерирует в код соответствующие команды.
Можно использовать вместо этого "настоящие" обраще-
ния к функциям,если поместить в головной файл после
#include отмену макроподстановок:
#undef inp и #undef inpw.
Возвращаемое значение:
Возвращает значение, считанное из данного порта.
Рекомендация:
Смотрите также : outp, outpw.
Пример:
/* Эта функция выключит MDA курсор */
#include
int porta, portb, bytea, byteb;
main()
{
char result;
porta = 0x3b4;
portb = 0x3b5;
bytea = 10;
byteb = 32;
result = inpw(porta);
printf("Значение,приняеое из порта bp %x равно
%x шестн.\n",porta, result);
outp(porta, bytea);
outp(portb, byteb);
}
/* Эта функция включит MDA курсор */
#include
int porta, portb, bytea, byteb;
main()
{
porta = 0x3b4;
portf = 0x3b5;
bytea = 10;
byteb = 11;
outp(porta, bytea);
outp(portb, byteb);
}
Interrupt Package Пакет работы с прерываниями
Использование:
#include
void int_getvector(unsigned vector, unsigned *poffset,
unsigned *psegment);
int int_intercept(unsigned vector, int (*funcptr)
(struct INT_DATA *pd), unsigned stacksize);
void int_off(void);
void int_on(void);
int int_restore(unsigned vector);
void int_setvector(unsigned vector, unsigned offset,
unsigned segment);
Описание:
Пакет работы с прерываниями спроектирован как общецеле-
вой пакет по управлению прерываниями 8086. Для каждого
вектора прерываний можно определить новую реакцию.
C функция, обрабатывающая прерывание, определяет, свя-
зано ли прерывание с прежним вектором прерывания или
нет.
int_intercept связывает стандартную C - функцию
(*funcptr) с вектором прерывания для обработки данного
прерывания при его появлении. Параметр vector опре-
деляет вектор прерывания 8086 (0...255), с которым свя-
зывается функция. Аргумент stacksize определяет количе-
ство байтов памяти, отводимой под стек для функции об-
работки. Размер стека должен быть не менее 256 байтов.
Если функция обработки прерывания (*funcptr)() возв-
ратит нулевое значение, то будет вызвана прежняя функ-
ция обработки прерывания, cвязанная с этим вектором,
иначе выполнится возврат из прерывания.
Значения из регистров могут быть считаны или записаны
через указатель (*pd) на структуру INT_DATA, который
поступает к (*funcptr)(). Существует несколько правил,
которым необходимо следовать, занимаясь обработкой пре-
рываний на C:
1). Ни MS DOS, ни BIOS не могут быть вызваны в про-
цессе обработки прерывания, если при этом может
произойти прерывание. Это объясняется тем, что
MS DOS и BIOS не являются повторно входимыми.
2). Нельзя при обработке прерывания или в вызванной
отсюда функции использовать в стеке памяти боль-
ше, чем отведено под стек.
3). Не обращайтесь к какой-либо функции, не являю-
щейся повторно входимой. (Результат будет
непредсказуем).
4). Непозволительно выполнение операций ввода/вы-
вода в обработке прерывания.
5). Когда используются переменные, изменяемые
при обработке прерывания, объявляйте их как
`volatile'.
6). Отключите для функции обработки прерывания конт-
роль переполнения стека.
int_off выключает прерывания 8086 командой CLI (clear
interrupt flag).
int_on включает прерывание 8086 командой STI
(set interrupt flag).
Функция int_restore является обратной к int_intercept.
int_restore отключает первоначальный обработчик преры-
ваний, который был подцеплен к указанному вектору пос-
редством int_intercept. Поэтому int_restore не должна
вызываться до обращения к int_intercept, связывающего
(новую) реакцию с этим вектором прерываний.
int_getvector получает содержимое указанного вектора
прерываний, разлагает его на сегмент и смещение и запо-
минает их в переменных psegment и poffset.
int_setvector устанавливает адрес пользовательской
процедуры, используя offset и segment, в указанном
векторе прерываний.
Пример:
#include
volatile int ctrl_c_count = 0;
int do_ctrl_c();
main()
{
int_intercept(0х23, do_ctrl_c, 256);
/* установили реакцию */
while(ctrl_c_count<3)
printf("Число Ctrl C равно %d/n", ctrl_c_count);
int_restore(0х23); /* восстановили старую */
}
do_ctrl_c()
{
++ctrl_c_count;
return 1;
}
Возвращаемое значение:
Значение, возвращаемое int_intercept и int_restore,
индицирует успех или неудачу. 0 возвращается в случае
успеха и -1 в противном случае.
ПРЕДУПРЕЖДЕНИЕ: Переопределение прерывания является
тонкой процедурой, требующей хоро-
шего понимания MS DOS и семейства
IBM PC для успешного применения.
int86, int86x ПРОГРАММНОЕ ПРЕРЫВАНИЕ
Использование:
#include /* структуры регистров */
int int86(int intnum, union REGS *regsin,
union REGS *regsout);
int int86x(intnum, union REGS *regsin,
union REGS *regsout, struct SREGS *segregs);
Описание:
Эти функции выполняют программное прерывание 8086.
intnum является номером прерывания (0...255).
regsin является указателем на структуру, содержащую
значения регистров AX,BX,CX,DX,SI и DI, поступающих с
прерыванием.
segregs является значением сегментных регистров, пос-
тупающих с прерыванием.
regsout является указателем на структуру, в которую за-
писываются возвращаемые значения регистров.
Структуры REGS и SREGS определены в dos.h файле. Отсы-
лаем Вас к руководствам по аппаратуре и программному
обеспечению для знакомства с номерами прерываний и со-
ответствующими функциями на Вашей машине.
Пример:
/* Эта функция воспринимает ввод с клавиатуры и пишет
строку на экран посредством BIOS */
#include
#include
#define MAXKEY 19
#define BEEP printf("\007")
void print(void);
void biosprt(void);
char buf [MAXKEY], *ptr;
int colm = 30, i;
union REGS r;
main()
{
system("cls");
printf("Введите строку из 20 литер\n\n");
gets(buf);
if (strlen(buf) > 20)
printf("Строка длинна, обрезаем\n");
print();
}
void print()
{
r.h.ah = 0х02;
r.h.bh = 0;
r.h.dh = 12;
r.h.d1 = colm;
int86 (0х10, &r, &r);
for (ptr=buf,i=0; i<=MAXKEY; (biosprt()),i++,ptr++);
}
void biosprt()
{
r.h.ah = 0х09;
r.h.al = *ptr;
r.x.cx = 1;
r.h.bl = 0х0f;
r.h.bh = 0;
int86(0x10, &r, &r);
r.h.ah = 0x02;
r.h.bh = 0;
r.h.dh = 12;
r.h.dl = ++colm;
int86 (0х10, &r, &r);
}
Возвращаемое значение:
Возвращают значение регистра AX в 8086 по завершению
прерывания. Состояние флага 'carry' можно получить из
x.cflag в regsout. Не пользуйтесь int86 и int86x для
прерываний 0x25 или 0x26. Используйте для этих целей
abs_disk_read/ write.
Рекомендация:
Смотрите также intdos, bdos.
intdos, intdosx СИСТЕМНЫЙ ВЫЗОВ ФУНКЦИИ DOS
Использование:
#include /* структуры регистров */
int intdos(union REGS *regsin, union REGS *regsout);
int intdosx(union REGS *regsin, union REGS *regsout,
struct SREGS *segregs);
Описание:
Эти функции выполняют системный вызов DOS (прерывание
0x21). Отсылаем Вас к руководству по DOS за деталями
обращения и выполнения функций.
regsin является указателем на структуру, содержащую
значения регистров AX, BX, CX, DX, SI и DI, поступаю-
щие с прерыванием.
regsout является указателем на структуру, в которую
будут записаны возвращаемые значения регистров.
segregs является указателем на структуру, содержащую
сегментные регистры, поступающие с прерыванием для
intdosx. Объединение REGS и структура SREGS определены
в dos.h файле.
Пример:
#include
union REGS inregs, outregs;
struct SREGS segregs;
main()
{
char far *string = "Печать этой строки $";
inregs.h.ah = 9;
inregs.x.dx = FP_OFF(string);
segregs.ds = FP_SEG(string);
intdosx(&inregs, &outregs, &segregs);
}
Возвращаемое значение:
Значение, которое было в AX на конец прерывания.
Рекомендация:
Смотрите также int86, int86x, bdos.
isatty ОПРЕДЕЛИТЬ ТИП ПОТОКА
Использование:
#include
int isatty (int fd);
Описание:
Определяет, связан ли дескриптор fd с терминалом,
принтером или последовательным портом.
Пример:
#include
#include
main()
{
if (isatty (fileno(stdin)))
printf("stdin связан с клавиатурой\n");
else
printf("stdin связан с файлом\n");
}
Возвращаемое значение:
Возвращает ненулевое значение, если устройство явля-
ется терминалом, консолью и т.д., и 0, если с чем-то
подобным дисковому файлу.
Рекомендация: Смотрите также fstat.
is package Пакет классификации литер
Использование:
#include
int isalnum(int c); /* ANSI */
int isalpha(int c); /* ANSI */
int isascii(int c);
int iscntrl(int c); /* ANSI */
int isdigit(int c); /* ANSI */
int isgraph(int c); /* ANSI */
int islower(int c); /* ANSI */
int isprint(int c); /* ANSI */
int ispunct(int c); /* ANSI */
int isspace(int c); /* ANSI */
int isupper(int c); /* ANSI */
int isxdigit(int c); /* ANSI */
Описание:
Эти макросы классифицируют литеры по заданному приз-
наку. Каждый возвращает ненулевое значение в качестве
истинности утверждения и ноль в противном случае.
isascii возвращает ненулевое значение для всех ASCII
значений 0...127. Все другие макросы используют целое,
лежащее в диапазоне - 1...255. Все значения, лежащие
вне этого диапазона, приводят к ошибочным ответам. Эти
макросы реализованы также и как библиотечные функции.
Пример:
#include
#include
main()
{
printf("Isalnum(%c)=%d\n", '$', isalnum('$'));
printf("Isalpha(%c)=%d\n", 'f', isalpha('f'));
printf("Isascii(%c)=%d\n", 0xe4, isascii(0xe4));
printf("Iscntrl(%c)=%d\n", 0x09, iscntrl(0x09));
printf("Isdigit(%c)=%d\n", 0x32, isdigit(0x32));
printf("Isgraph(%c)=%d\n", 0x0ea, isgraph(0x0ea));
printf("Islower(%c)=%d\n", 'A', islower('A'));
printf("Isprint(%c)=%d\n", 0x40, isprint(0x40));
printf("Ispunct(%c)=%d\n", ',', ispunct(','));
printf("Isspace(%c)=%d\n", ' ', isspace(' '));
printf("Isupper(%c)=%d\n", 'd', isupper('d'));
printf("Isxdigit(%c)=%d\n", 0x0d, isxdigit(0x0d));
}
Возвращаемое значение:
isalnum возвращает не ноль, если 'c' есть буква или
цифра.
ialpha возвращает не ноль, если 'c' есть буква.
isascii возвращает не ноль, если 'c' в диапазоне
0..127.
iscntrl возвращает не ноль, если 'c' является управ-
ляющим символом (из диапазона (0, 0x1F) или c==0x7F).
isdigit возвращает не ноль в случае цифры 0...9.
isgraph возвращает не ноль, если 'c' является печатае-
мым символом (исключая пробел).
islower возвращает не ноль, если 'c' есть один из сим-
волов нижнего регистра.
isprint возвращает не ноль, если 'c' является печатае-
мым символом (включая пробел).
ispunct возвращает не ноль, если 'c' есть символ пунк-
туации.
isspace возвращает не ноль в случае символа табуляции,
новой строки, вертикальной табуляции, возврата каретки,
пробела и перевода формата (form feed).
isupper возвращает не ноль, если 'c' является одним из
символов верхнего регистра.
isxdigit возвращает не ноль, если 'c' является одним
из символов 0..9, A..F или a..f.
Рекомендация:
Смотрите также toascii.
itoa ПРЕДСТАВЛЕНИЕ ЦЕЛОГО
Использование:
#include
char * itoa(int value, char * str, int radix);
Описание:
Преобразует value в строку, заканчивающуюся нулем,
используя radix. Radix задает основание системы исчис-
ления и должен быть в диапазоне 2...36. Если value от-
рицательно и radix равен 10, первой литерой str будет
'-'. Результат записывается в строку str, которая долж-
на быть достаточно велика, чтобы результат поместился.
Возвращаемое значение:
Возвращает str. Ошибки не возвращаются.
Пример:
#include
#include
main()
{
char buffer[10];
int value = 67;
char *ptr;
ptr = itoa(value, buffer, 2);
printf("Число %d как двоичное=\"%s\"\n",value,
buffer);
ptr=itoa(value, buffer, 8);
printf("Число %d как восьмеричное=\"%s\"\n",value,
buffer);
ptr=itoa(value, buffer, 16);
printf("Число %d как 16-ричное=\"%s\"\n",value,
buffer);
}
kbhit ПРОВЕРКА ВВОДА С КЛАВИАТУРЫ
Использование:
#include
int kbhit(void);
Описание:
Проверяет наличие ввода с клавиатуры (нажатие клавиши).
Пример:
#include
#include
main()
{
printf("Приготовившись, нажмите любую клавишу\n");
while(!kbhit());
printf("\n Была нажата клавиша (%c)\n", getch());
}
Возвращаемое значение:
Возвращает не ноль в случае нажатия клавиши клавиатуры
и ноль в противном случае.
labs АБСОЛЮТНОЕ ЗНАЧЕНИЕ ДЛИННОГО
Использование:
#include
long labs(long i); /* ANSI */
Описание:
Вычисляет абсолютное значение длинного целого.
Пример:
#include
#include
main()
{
long lng, result;
lng = -314159L;
result = labs(lng);
printf("Абсолютное значение от (%ld) равно (%ld)\n",
lng, result);
}
Возвращаемое значение:
Возвращает абсолютное значение длинного целого.
Рекомендация:
Смотрите также abs.
ldexp ЭКСПОНЕНТА
Использование:
#include
double ldexp(double x, int exp); /* ANSI */
Описание:
Вычисляет значение x*(2**exp).
Пример:
#include
#include
main()
{
double x,y;
int exp;
x = 1.5;
exp = 5;
y = ldexp(x,exp);
printf("The ldexp(%f exp %d)=\n", x, exp, y);
}
Возвращаемое значение:
Возвращает вычисленное значение x*(2**exp).
Рекомендация:
Смотрите также exp, frexp, log, log10, modf.
ldiv ДЕЛЕНИЕ ЧИСЕЛ ТИПА long
Использование:
#include /* ANSI */
ldiv_t ldiv(long int numerator, long int denominator);
Описание:
Делит numerator на denominator, возвращая частное и
остаток. Если делитель ноль, программа завершается с
сообщением об ошибке. Аргументы и возвращаемые значе-
ния имеют тип long.
Возвращаемое значение:
Возвращает структуру ldiv_t, содержащую частное и ос-
таток.
Рекомендация:
Смотрите также div.
Пример:
#include
#include
main()
{
long numer, denom;
ldiv_t result;
numer = 3;
denom = 2;
printf("Делимое = %ld и делитель = is %ld\n", numer,
denom);
result = ldiv(numer, denom);
printf("Частное = %ld\n", result.quot);
printf("Остаток = %ld\n", result.rem);
}
localtime ДАТЬ МЕСТНОЕ ВРЕМЯ
Использование:
#include
struct tm *localtime(time_t *time); /* ANSI */
Описание:
Преобразует время, записанное в формате time_t, в
структуру tm. time_t выражается в секундах с 1 января
1970 года. Оно может быть получено с помощью функции
time. Localtime производит коррекцию, учитывающую вре-
менной пояс и, возможно, поправку на сдвиг, связанную
с экономией дневного времени. Поля структуры tm:
struct tm {
tm_sec, /* секунды 0..59 */
tm_min, /* минуты 0..59 */
tm_hour, /* час дня 0..23 */
tm_mday, /* день месяца 1..31 */
tm_mon, /* месяц 0..11 */
tm_year, /* год после 1900 */
tm_wday, /* день недели, 0..6 (Sun..Sat) */
tm_yday, /* день года, 0..365 */
tm_isdst; /* >0, если есть поправка на сдвиг,
=0, если нет поправки,
<0, если неизвестно */
}
Возвращаемое значение:
Возвращает указатель на статическую структуру tm,
которая обновляется при каждом вызове функции.
Пример:
#include
#include
main()
{
struct tm *t;
time_t ltime;
time(<ime);
t = localtime(<ime);
printf("Дата: %d-%d-%d\n", t-> tm_mday,
t->tm_mon+1, t->tm_year);
}
Рекомендация:
Смотрите также time, asctime, ctime, mktime.
log, log10 ЛОГАРИФМ
Использование:
#include
double log(double x); /* ANSI */
double log10(double x); /* ANSI */
Описание:
Log вычисляет натуральный логарифм x. Значение x дол-
жно быть больше 0. Log10 вычисляет десятичный логарифм
x (x должен быть больше 0).
Пример:
#include
#include
main(int argc, char **argv)
{
double d, result;
d = atof(argv[1]);
result = log(d);
printf("The log of %.2f is %f\n", d, result);
result = log10(d);
printf("The log10 of %.2f is %f\n", d, result);
}
Возвращаемое значение:
Возвращают вычисленное значение или ошибку, связанную
с областью определения, если x <= 0.
Рекомендация:
Смотрите также exp, pow, sqrt.
longjmp ДЛИННЫЙ ПЕРЕХОД
Использование:
#include
void longjmp (jmp_buf env, int value); /* ANSI */
int setjmp (jmp_buf env); /* ANSI */
Описание:
Эти функции позволяют осуществлять переходы между
функциями. Они могут быть полезны при обработке ошибок
или прерываний, происшедших в низкоуровневых процеду-
рах программы.
setjmp сохраняет окружение стека в переменной env для
дальнейшего использования в longjmp.
longjmp восстанавливает окружение, сохраненное ранее
посредством setjmp в буфере env. value, возвращаемое в
окружение, как бы поставляет setjmp.
ЗАМЕЧАНИЕ: Окружение должно быть зафиксировано с ис-
пользованием setjmp, вызываемой из той же
функции, которая содержит обращение к фу-
нкции longjmp, или из "родительской", т.е.
функции, содержащей обращение к той, что
вызывает longjmp.
После завершения longjmp выполнение программы продол-
жается, как если бы соответствующее обращение к setjmp
возвратило value. value никогда не будет 0. Если value
передано как 0, будет возвращено значение 1.
Возвращаемое значение:
setjmp возвращает 0. longjmp не имеет возвращаемого
значения.
Пример:
#include
#include
void doscall(void);
jmp_buf environment;
int error_val = -1;
main()
{
int error code;
error_code = setjmp(environment);
if (error_code !=0)
{
printf("Вызван longjmp\n");
exit(1);
}
printf("Вызван setjmp\n");
doscall();
}
doscall()
{
longjmp(environment, error_val);
}
lseek ИЗМЕНИТЬ ПОЗИЦИЮ В ФАЙЛЕ
Использование:
#include
long lseek(int fd, long offset, int mode);
Описание:
Изменяет текущую позицию чтения/записи в файле, задан-
ном дескриптором fd. Параметр mode может принимать одно
из следующих значений:
SEEK_SET - Указатель сдвигается на offset байтов от
начала файла.
SEEK_CUR - Сдвиг на offset байтов относительно теку-
щей позиции.
SEEK_END - Сдвиг на offset байтов от конца файла.
Возвращаемое значение:
Возвращает смещение в байтах новой позиции относитель-
но начала файла. В случае ошибки возвращает -1 и уста-
навливает errno.
Рекомендация:
Смотрите также fseek.
Пример:
#include
#include
#include
main()
{
int fp;
long offset, lpos;
fp = open("file.dat", O_RDWR);
if (fp<0)
return;
offset = 0L;
lpos = lseek(fp, offset, SEEK_SET)
printf("Текущая позиция=%ld\n", lpos);
offset = 10L;
lpos = lseek(fp, offset, SEEK_CUR);
printf("Текущая позиция=%ld\n", lpos);
offset = 50L;
lpos = lseek(fp, offset, SEEK_END);
printf("Текущая позиция=%ld\n", lpos);
close(fp);
}
malloc ОТВЕСТИ ПАМЯТЬ
Использование:
#include
void *malloc(unsigned numbytes); /* ANSI */
Описание:
Размещает блок памяти объемом numbytes байтов. Если
numbytes равен 0, то возвращает NULL.
Пример:
#include
#include
#define NUM_INTS 7623
int *memblock;
main()
{
memblock = malloc(NUM_INTS*sizeof(int));
if (memblock==NULL)
printf("Нехватка памяти\n");
else
printf("Память отведена\n");
free(memblock);
}
Возвращаемое значение:
Возвращает указатель на размещенный блок памяти. Либо
возвращает NULL при недостатке памяти или в случае
numbytes==0.
Рекомендация:
Смотрите также calloc, free, realloc, farmalloc.
matherr ОБРАБОТКА ОШИБКИ МАТЕМАТИЧЕСКОЙ ФУНКЦИИ
Использование:
#include
int matherr(struct exception *e);
Описание:
matherr вызывается при обнаружении ошибки функциями
math библиотеки. Пользователь может использовать биб-
лиотечный вариант этой функции или определить собстве-
нную одноименную процедуру в своей программе. Указа-
тель на структуру exception должен поступать в проце-
дуру пользователя, берущую обработку ошибки на себя.
Возвращаемое значение:
Возвращение 0 означает, что ошибка обработана правиль-
но, 1 означает, что ошибка не может быть обработана.
Пример:
#include
#include
#include
main()
{
printf("log(-1) = %e\n", log(-1));
}
int matherr(x)
struct exception *x;
{
if (x -> type == DOMAIN)
{
if (strcmp(x -> name, "log")==0)
{
x -> retval = log(-(x -> arg1));
return(1);
}
}
return(0);
}
memchr - memset РАБОТА С БАЙТАМИ В МАССИВАХ
Использование: /* все ANSI */
#include
void *memchr(void *buf, int c, unsigned count);
int memcmp(void *buf1, void *buf2, unsigned count);
void *memcpy(void *buf1, void *buf2, unsigned count);
void *memmove(void *buf1, void *buf2, unsigned count);
void *memset(void *buf, int val, unsigned count);
Описание:
memchr отыскивает в буфере buf байт со значением 'c'.
Поиск продолжается среди count количества байтов или
до встречи значения 'c'.
memcmp последовательно сравнивает байты буферов buf1 и
buf2 и продолжает это, пока они совпадают, либо пока
не выполнит заданное количество сравнений count. memcmp
возвращает целое, меньшее, равное или большее 0 в зави-
симости от результата сравнения последней пары байтов.
memcpy и memmove копируют count байтов из buf2 в buf1.
memcpy работает быстрее, но не работает, если buf1 и
buf2 перекрываются (имеют общую часть).Возвращают buf1.
memset устанавливает первые count байтов в buf равными
val. Возвращает buf.
Возвращаемое значение:
memchr возвращает указатель на позицию найденной литеры
'c' в буфере, либо NULL.
memcpy и memmove возвращают buf1.
memset возвращает buf.
memcmp возвращает значения:
<0 buf1 < buf2
=0 buf1 = buf2
>0 buf1 > buf2
Пример:
#include
#include
char buffer[50];
char buffer2[50]="Пример строки\n";
char srccpy[]="Пример 2 строки\n";
char * result;
int reslt;
main()
{
printf("Работает функция memcpy\n");
memcpy(buffer, buffer2, 15);
printf("Работает функция memchr\n");
result = memchr(buffer, 'т', 50);
if (result != NULL)
printf("Литера(т) найдена в (%d)\n",
result-buffer+1);
else
printf("Ошибка-(т) не найдена\n");
printf("Работает функция memcmp\n");
reslt = memcmp(buffer, buffer2, 50);
printf("Результат memcmp: %s\n", reslt;
printf("Buffer before memmove : %s", buffer);
result = memmove(buffer, srccpy, sizeof(srccpy));
printf("Буфер после memmove : %s", buffer);
printf("Буфер до memset : %s", buffer);
result = memset(buffer, 'x', 6);
printf("Буфер после memset : %s", buffer);
}
Рекомендация:
Смотрите также strcmp, strcat, strset, strchr.
mkdir СОЗДАТЬ КАТАЛОГ
Использование:
#include
int mkdir(char * pathname);
Описание:
Создает новый каталог, заданный параметром pathname.
Если pathname содержит более одной компоненты, только
последняя компонента должна быть новой, а все пред-
шествующие должны быть существующими каталогами.
Пример:
#include
#include
main()
{
int result;
result = mkdir("\\temp");
if (result==0)
printf("Каталог \\temp создан\n");
else
printf("Не могу создать каталог \\temp\n");
}
Возвращаемое значение:
Возвращает 0 в случае успеха и -1 в случае неудачи с
устанавкой errno.
Рекомендация:
Смотрите также rmdir, chdir.
MK_FP СОЗДАТЬ ДАЛЬНИЙ УКАЗАТЕЛЬ
Использование:
#include |