
\chapter{Стандартная библиотека}
\label{apx:stdlib}

\index{библиотечная функция}%
Настоящее приложение представляет собой краткое изложение библиотеки,
утверждённой в качестве ANSI-стандарта. Сама по себе библиотека не является
частью языка, однако заложенный в ней набор деклараций функций, а также
определений типов и макросов составляет системную среду, поддерживающую стандарт
Си. Мы не приводим несколько функций с ограниченной областью применения -- те,
которые легко синтезируются из других функций, а также всё то, что касается
многобайтовых литер и специфики, обусловленной языком, национальностью и
культурой.

Функции, типы и макросы декларируются в следующих \emph{головных файлах}:

\smallskip
\index{таблица!стандартных головных файлов}%
\index{файл!головной!<locale.h>@\texttt{<locale.h>}}%
\index{файл!головной!<stddef.h>@\texttt{<stddef.h>}}%
{\setlength{\LTleft}{\codeIndent-\tabcolsep}%
\SetLenVarWithVal{\Fifthlen}{(\linewidth-\LTleft-11.5\tabcolsep)/5}%
\noindent\hspace{\LTleft}\begin{tabular}
{p{\Fifthlen}p{\Fifthlen}p{\Fifthlen}p{\Fifthlen}p{\Fifthlen}}
\verb|<assert.h>|&\verb|<float.h>|&\verb|<math.h>|&
\verb|<stdarg.h>|&\verb|<stdlib.h>|\\
\verb|<ctype.h>|&\verb|<limits.h>|&\verb|<setjmp.h>|&
\verb|<stddef.h>|&\verb|<string.h>|\\
\verb|<errno.h>|&\verb|<locale.h>|&\verb|<signal.h>|&
\verb|<stdio.h>|&\verb|<time.h>|
\end{tabular}}
\smallskip

\noindent Доступ к головному файлу осуществляется при помощи строки
препроцессора

\begin{ShortCodeParWithCC}{\\\{\}}
#include <\textit{головной-файл}>
\end{ShortCodeParWithCC}

\noindent Головные файлы можно включать в любом порядке и сколько угодно раз.
Строка \verb|#include| не должна быть внутри внешней декларации или определения
и должна встретиться раньше, чем что-нибудь будет востребовано из включаемого
головного файла. В конкретной реализации головной файл может и не быть исходным
файлом.

\index{литера!подчёркивания \texttt{\_}}%
Для использования в библиотеке зарезервированы внешние идентификаторы,
начинающиеся со знака подчёркивания, а также все другие идентификаторы,
начинающиеся с двух знаков подчёркивания или с подчёркивания и заглавной буквы.

\section{Ввод-вывод:
\texorpdfstring{\protect\Verb|<stdio.h>|}{<stdio.h>}}
\label{apx:stdlib:sec:input-output-stdio.h}

\index{файл!головной!<stdio.h>@\texttt{<stdio.h>}}%
\index{stdio.h@\texttt{<stdio.h>}}%
Определённые в \verb|<stdio.h>| функции ввода-вывода, а также типы и макросы
составляют приблизительно треть библиотеки.

\index{поток!бинарный|(}%
\emph{Поток} -- это источник или получатель данных; его можно связать с диском
или с каким-то другим внешним устройством.
\index{поток!текстовый}%
\index{текстовый поток}%
Библиотека поддерживает два вида потоков: текстовый и бинарный, хотя на
некоторых системах, в частности в UNIXе, они не различаются.
\index{литера!новая-строка \texttt{\textbackslash n}}%
\index{n@\texttt{\textbackslash n}}%
Текстовый поток -- это последовательность строк; каждая строка имеет нуль или
более литер и заканчивается литерой\verb|'\n'|. Операционная среда может
потребовать коррекции текстового потока (например, перевода \verb|'\n'| в литеры
возврат-каретки и перевод-строки).

\index{бинарный поток}%
Бинарный поток -- это последовательность непреобразуемых байтов, представляющих
собой некоторые промежуточные данные, которые обладают тем свойством, что, если
их записать, а затем прочесть той же системой ввода-вывода‚ то мы получим
информацию, совпадающую с исходной.
%
% вообще тут ошибка переводчика
% в английском оригинале
% "последовательность непреобразуемых байтов"
% это "sequence of unprocessed bytes"
% что правильно перевести как
% "последовательность необработанных байтов"
%

\index{указатель!файла}%
\index{файл!указатель}%
Поток соединяется с файлом или устройством посредством его \emph{открытия};
указанная связь разрывается путём \emph{закрытия} потока.
\index{FILE a@\texttt{FILE}}%
Открытие файла возвращает указатель на объект типа \verb|FILE|, который содержит
всю информацию, необходимую для управления этим потоком. Если не возникает
двусмысленности, мы будем пользоваться терминами <<файловый указатель>> и
\index{бинарный поток}%
<<поток>> как равнозначными.

\index{stderr@\texttt{stderr}}%
\index{stdin@\texttt{stdin}}%
\index{stdout@\texttt{stdout}}%
Когда программа начинает работу, уже открыты три потока: \verb|stdin|,
\verb|stdout| и \verb|stderr|.
\index{поток!бинарный|)}%


\subsection{Операции над файлами}

\index{файл!добавляемый}%
\index{файл!доступ к}%
\index{size{\_}t@\texttt{size{\_}t}}%
Ниже перечислены функции, оперирующие с файлами. Тип \verb|size_t| --
беззнаковый целочисленный тип, используемый для описания результата оператора
\verb|sizeof|.

\begin{ApxDescript}
\index{библиотечная функция!fopen@\texttt{fopen}}%
\verb|FILE *fopen(const char *filename, const char *mode)|\\
\verb|fopen| открывает файл с заданным именем и возвращает поток или
\verb|NULL|, если попытка открытия оказалась неудачной.
\index{файл!режим доступа}%
Режим \verb|mode| допускает следующие значения:


\begin{LongRtAlTab2cols}{\codeIndent+\parindent}{0pt}{\Verb|qr+q|}
\verb|"r"|&текстовый файл открывается для чтения (от read (англ.) -- читать)\\
\verb|"w"|&текстовый файл создаётся для записи; старое содержимое (если оно
было) выбрасывается (от write (англ.) -- писать)\\
\verb|"a"|&текстовый файл открывается или создаётся для записи в конец файла (от
append (англ.) -- добавлять)\\
\verb|"r+"|&текстовый файл открывается для исправления (т.е. для чтения и для
записи)\\
\verb|"w+"|&текстовый файл создаётся для исправления; старое содержимое (если
оно было) выбрасывается\\
\verb|"a+"|&текстовый файл открывается или создаётся для исправления уже
существующей информации и добавления новой в конец файла
\end{LongRtAlTab2cols}

\noindent Режим <<исправления>> позволяет читать и писать в один и тот же файл;
при переходах от операций чтения к операциям записи и обратно должны
осуществляться обращения к \verb|fflush| или к функции позиционирования файла.
Если указатель режима дополнить буквой \verb|b| (например, \verb|"rb"| или
\verb|"w+b"|)‚ то это будет означать, что файл бинарный.
\index{FILENAME{\_}MAX@\texttt{FILENAME{\_}MAX}}%
Ограничение на длину имени файла задано константой \verb|FILENAME_MAX|.
\index{FOPEN{\_}MAX@\texttt{FOPEN{\_}MAX}}%
\verb|FOPEN_MAX| ограничивает число одновременно открытых файлов.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!freopen@\texttt{freopen}}%
\verb|FILE *freopen(const char *filename, const char *mode, |

\verb|                       FILE *stream)|\\
\verb|freopen| открывает файл с указанным режимом и связывает его с потоком
\verb|stream|. Она возвращает \verb|stream| или, в случае ошибки, \verb|NULL|.
Обычно \verb|freopen| используется для замены файлов, связанных с \verb|stdin|,
\verb|stdout| или \verb|stderr|, другими файлами.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fflush@\texttt{fflush}}%
\verb|int fflush(FILE *stream)|\\
Применяемая к потоку вывода \verb|fflush| производит дозапись всех оставшихся на
буфере (ещё не записанных) данных; для потока ввода эта функция не определена.
\index{EOF@\texttt{EOF}}%
Возвращает \verb|EOF| в случае возникшей при записи ошибки или нуль в противном
случае. Обращение вида \verb|fflush(NULL)| выполняет указанные операции для всех
потоков вывода.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fclose@\texttt{fclose}}%
\verb|int fclose(FILE *stream)|\\
\verb|fclose| производит дозапись ещё незаписанных буферизованных данных,
сбрасывает нечитанный буферизованный ввод, освобождает все автоматически
запрошенные буфера, после чего закрывает поток. Возвращает \verb|EOF| в случае
ошибки и нуль в противном случае.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!remove@\texttt{remove}}%
\verb|int remove(const char *filename)|\\
\verb|remove| удаляет файл с указанным именем; последующая попытка открыть файл
с этим именем вызовет ошибку. Возвращает ненулевое значение в случае неудачной
попытки.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!rename@\texttt{rename}}%
\verb|int rename(const char *oldname, const char *newname)|\\
\verb|rename| заменяет имя файла; возвращает ненулевое значение в случае, если
попытка изменить имя оказалась неудачной. Первый параметр задаёт старое имя,
второй -- новое.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!tmpfile@\texttt{tmpfile}}%
\verb|FILE *tmpfile(void)|\\
\verb|tmpfile| создаёт временный файл с режимом доступа \verb|"wb+"|, который
автоматически удаляется при его закрытии или обычном завершении программой своей
работы. Эта функция возвращает поток или, если она не смогла создать файл,
\verb|NULL|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!tmpnam@\texttt{tmpnam}}%
\verb|char *tmpnam(char s[L_tmpnam])|\\
\verb|tmpnam(NULL)| создаёт стринг, который не совпадает ни с одним из имён
существующих файлов, и возвращает указатель на внутренний статический массив.
\verb|tmpnam[s]| запоминает стринг в \verb|s| и возвращает его в качестве
значения функции; длина \verb|s| должна быть не менее \verb|L_tmpnam|. При
каждом вызове \verb|tmpnam| генерируется новое имя;
\index{TMP{\_}MAX@\texttt{TMP{\_}MAX}}%
при этом гарантируется не более \verb|TMP_MAX| различных имён за один сеанс
работы программы. Заметим, что \verb|tmpnam| создаёт имя, но не файл.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!setvbuf@\texttt{setvbuf}}%
\verb|int setvbuf(FILE *stream, char *buf, int mode, size_t size)|\\
\verb|setvbuf| управляет буферизацией потока; к ней следует обращаться прежде,
чем будет выполняться чтение, запись или какая-либо другая операция. Режим
\verb|mode| 
\index{IOFBF, IOLBF, IONBF@\texttt{{\_}IOFBF}, \texttt{{\_}IOLBF}, \texttt{{\_}IONBF}}%
со значением \verb|_IOFBF| вызывает полную буферизацию, с
\verb|_IOLBF| -- <<построчную>> буферизацию текстового файла, а режим
\verb|_IONBF| отменяет всякую буферизацию. Если параметр \verb|buf| не есть
\verb|NULL|, то его значение -- указатель на буфер, в противном случае под буфер
будет запрашиваться память. Параметр \verb|size| задаёт размер буфера. Функция
\verb|setvbuf| в случае ошибки выдаёт ненулевое значение.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!setbuf@\texttt{setbuf}}%
\verb|void setbuf(FILE *stream, char *buf)|\\
Если \verb|buf| есть \verb|NULL|, то для потока \verb|stream| буферизация
выключается.
\index{BUFSIZ@\texttt{BUFSIZ}}%
В противном случае вызов \verb|setbuf| приведёт к тем же действиям,
что и вызов \verb|(void) setvbuf(stream, buf, _IOFBF, BUFSIZ)|.
\end{ApxDescript}
%
% в оригинале в левом нижнем углу страницы надпись ``9. Заказ № 13''
%

\subsection{Форматный вывод}

Функции \verb|printf| осуществляют вывод информации по формату.

\begin{ApxDescript}
\index{библиотечная функция!fprintf@\texttt{fprintf}}%
\verb|int fprintf(FILE *stream, const char *format, ...)|
\end{ApxDescript}

\verb|fprintf| преобразует и пишет вывод в поток \verb|stream| под управлением
\verb|format|. Возвращаемое значение -- число записанных литер или, в случае
ошибки, отрицательное значение.

Форматный стринг содержит два вида объектов: обычные литеры, копируемые в
выводной поток, и спецификации преобразования, которые вызывают преобразование и
печать остальных аргументов в том порядке, как они перечислены. Каждая
спецификация преобразования начинается с \verb|%| и заканчивается
литерой-спецификатором преобразования. Между \verb|%| и литерой-спецификатором в
порядке, в котором они здесь перечислены, могут быть расположены следующие
элементы информации:

\begin{itemize}
 \item Флаги (в любом порядке), модифицирующие спецификацию:
\begin{LongRtAlTab2cols}{\codeIndent+\parindent}{0pt}{\textit{\Verb|пробел|}}
\verb|-|&указывает на то, что преобразованный аргумент должен быть прижат к
левому краю поля.\\
\verb|+|&предписывает печатать число всегда со знаком.\\
\textit{\Verb|пробел|}&если первая литера -- не знак, то числу должен
предшествовать пробел.\\
\verb|0|&указывает, что числа должны дополняться ведущими нулями до всей ширины
поля.\\
\verb|#|&указывает на одну из следующих форм вывода: для \verb|o| первой цифрой
должен быть $0$; для \verb|x| или \verb|X| ненулевому результату должны
предшествовать \verb|0x| или \verb|0X|; для \verb|e|, \verb|E|, \verb|f|,
\verb|g| и \verb|G| вывод должен всегда содержать десятичную точку; для \verb|g|
и \verb|G| хвостовые нули не отбрасываются.
\end{LongRtAlTab2cols}
 \item Число, специфицирующее минимальную ширину поля. Преобразованный аргумент
 будет напечатан в поле, размер которого не меньше указанной ширины, а если
 потребуется, в поле большего размера. Если число литер преобразованного
 аргумента меньше ширины поля, то поле будет дополнено слева (или справа, если
 число прижимается к левому краю). Обычно поле дополняется пробелами (или
 нулями, если присутствует флаг дополнения нулями).
 \item Точка, отделяющая указатель ширины поля от указателя точности.
 \item Число, задающее точность, которое специфицирует максимальное количество
 литер, печатаемых из стринга, или количество цифр после десятичной точки в
 преобразованиях \verb|e|, \verb|E| или \verb|f|, или количество значащих цифр
 для \verb|g| или \verb|G|-преобразования, или минимальное количество цифр при
 печати целого (до необходимой ширины поля число дополняется ведущими нулями).
 \item Модификаторы \verb|h|, \verb|l| (буква эль) или \verb|L|. <<\verb|h|>>
 указывает, что соответствующий аргумент должен печататься как \verb|short| или
 \verb|unsigned short|; <<\verb|l|>> сообщает, что аргумент имеет тип
 \verb|long| или \verb|unsigned long|; <<\verb|L|>> информирует, что аргумент
 принадлежит типу \verb|long double|.
\end{itemize}

\noindent Ширина, или точность, или обе характеристики могут быть
специфицированы при помощи \verb|*|; в этом случае необходимое число
<<извлекается>> из следующего аргумента, который должен иметь тип \verb|int| (в
случае двух звёздочек используются два аргумента).

\begin{table}[t!]
\captionsetup{name=ТАБЛИЦА,labelsep=period,justification=centering}
\renewcommand\thetable{B.1}
\caption{ПРЕОБРАЗОВАНИЯ PRINTF}
\label{tab:printf_apxB}
\index{таблица!преобразований в \texttt{printf}}%
\begin{tabular*}{\linewidth}
{p{0.1118012\linewidth-4\tabcolsep}|p{0.8881988\linewidth-4\tabcolsep}}
\hline\hline
\multicolumn{1}{c|}{\rule{0pt}{3ex}ЛИТЕРА\rule[-1.5ex]{0pt}{0pt}}&
\multicolumn{1}{|c}{ТИП АРГУМЕНТА; ВИД ПЕЧАТИ} \\
\hline
\rule{0pt}{3ex}\verb| d, i| &\verb|int|; знаковая десятичная запись. \\
\verb|  o| &\verb|int|; беззнаковая восьмеричная запись (без ведущего $0$). \\
\verb| x, X| &\verb|int|;  беззнаковая шестнадцатеричная запись (без ведущих
\verb|0x| и \verb|0X|),  в качестве цифр от $10$ до $15$ используются
\verb|abcdef| для \verb|x| и \verb|ABCDEF| для \verb|X|. \\
\verb|  u| &\verb|int|; беззнаковое десятичное целое. \\
\verb|  c| &\verb|int|; единичная литера после преобразования в
\verb|unsigned char|. \\
\verb|  s| &\verb|char *|; литеры стринга печатаются, пока не встретится
\verb|'\0'| или не исчерпается количество литер, указанное точностью. \\
\verb|  f| &\verb|double|; десятичная запись вида
\verb|[-]|\textit{\Verb|mmm|}\verb|.|\textit{\Verb|ddd|}, где количество
\textit{d} специфицируется точностью. По умолчанию точность равна 6; нулевая
точность подавляет печать десятичной точки. \\
\verb| e, E| &\verb|double|; десятичная запись вида
\verb|[-]|\textit{\Verb|m|}\verb|.|\textit{\Verb|dddddd|}\texttt{e\textpm}\textit{\Verb|xx|}
или запись вида
\verb|[-]|\textit{\Verb|m|}\verb|.|\textit{\Verb|dddddd|}\texttt{E\textpm}\textit{\Verb|xx|},
где количество \textit{d} специфицируется точностью. По умолчанию точность
равна 6; нулевая точность подавляет печать десятичной точки. \\
\verb| g, G| &\verb|double|; используется \verb|%e| или \verb|%E|, если
экспонента меньше $-4$ или больше или равна точности; в противном случае
используется \verb|%f|. Хвостовые нули и точка в конце не печатаются. \\
\verb|  p| &\verb|void *|; печатает в виде указателя (представление зависит от
реализации). \\
\verb|  n| &\verb|int *|; число литер, напечатанных к данному моменту данным
вызовом \verb|printf|, \emph{записывается} в аргумент. Никакие другие аргументы
не преобразуются. \\
\rule[-1.5ex]{0pt}{0pt}\verb|  %| & никакие аргументы не преобразуются;
печатается \verb|%|. \\
\hline
\end{tabular*}
\end{table}
%
% исправлена орфографическая ошибка
% в оригинале было ``шестнадцатиричное''
%

Литеры-спецификаторы и разъяснение их смысла приведены в
табл.~\ref{tab:printf_apxB}. Если за \verb|%| нет правильной
литеры-спецификатора, результат не определён.

\begin{ApxDescript}
\index{библиотечная функция!printf@\texttt{printf}}%
\verb|int printf(const char *format, ...)|\\
\verb|printf(...)| полностью эквивалентна \verb|fprintf(stdout, ...)|
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!sprintf@\texttt{sprintf}}%
\verb|int sprintf(char *s, const char *format, ...)|\\
\verb|sprintf| действует так же, как и \verb|printf|, только вывод осуществляет
в стринг \verb|s|, завершая его литерой \verb|'\0'|. Стринг \verb|s| должен быть
достаточно большим, чтобы вмещать результат вывода. Возвращает количество
записанных литер, в число которых литера \verb|'\0'| не входит.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!vfprintf@\texttt{vfprintf}}%
\index{библиотечная функция!vprintf@\texttt{vprintf}}%
\index{библиотечная функция!vsprintf@\texttt{vsprintf}}%
\index{va{\_}list, va{\_}start, va{\_}arg, va{\_}end@\texttt{va{\_}list}, \texttt{va{\_}start}, \texttt{va{\_}arg}, \texttt{va{\_}end}}%
\verb|vprintf(const char *format, va_list arg)|

\verb|vfprintf(FILE *stream, const char *format, va_list arg)|

\verb|vsprintf(char *s, const char *format, va_list arg)|\\
Функции \verb|vprintf|, \verb|vfprintf| и \verb|vsprintf| эквивалентны
соответствующим \verb|printf|-функциям с той лишь разницей, что переменный
список аргументов представлен параметром \verb|arg|, инициализированным макросом
\verb|va_start| и, возможно, вызовами \verb|va_arg|. (См. в~\ref{apx:sec:variable_argument_lists-stdarg.h} описание \verb|<stdarg.h>|.)
\end{ApxDescript}

\subsection{Форматный ввод}

Функции \verb|scanf| имеют дело с форматным преобразованием при вводе.

\begin{ApxDescript}
\index{библиотечная функция!fscanf@\texttt{fscanf}}%
\verb|int fscanf(FILE *stream, const char *format, ...)|
\end{ApxDescript}

\verb|fscanf| читает данные из потока \verb|stream| под управлением
\verb|format| и преобразованные величины присваивает по порядку аргументам,
\emph{каждый из которых должен быть указателем}. Завершает работу, если
исчерпался формат. Выдаёт \verb|EOF| по исчерпании файла или перед любым
преобразованием, если возникла ошибка; в остальных случаях она возвращает
количество преобразованных и введённых элементов.

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

\begin{itemize}
 \item Пробелы и табуляции, которые игнорируются.
 \item Обычные литеры (но не \verb|%|), которые ожидаются в потоке ввода среди
 литер, отличных от пробельных.
 \item Спецификации преобразования, состоящие из \verb|%|; необязательного знака
 \verb|*|, подавляющего присваивание; необязательного числа, специфицирующего
 максимальную ширину поля; необязательных \verb|h|, \verb|l| или \verb|L|,
 указывающих размер присваиваемого значения, и литеры-спецификатора
 преобразования.
\end{itemize}

Спецификация преобразования определяет преобразование следующего поля ввода.
Обычно результат размещается в переменной, на которую указывает соответствующий
аргумент.
\index{присваивание!подавленное, \texttt{scanf}}%
\index{scanf, подавление присваивания в@\texttt{scanf}, подавление присваивания в}%
Однако если присваивание подавляется при помощи \verb|*|, как,
например, в \verb|%*s|, то поле ввода просто пропускается, и никакого
присваивания не происходит. Поле ввода определяется как стринг непробельных
литер; при этом ввод стринга прекращается при выполнении любого из двух условий:
если встретилась пробельная литера или если ширина поля (в случае, когда она
указана) исчерпана. Из этого следует, что при переходе к следующему полю
\verb|scanf| может <<перешагивать>> через границы строк, поскольку литера
новая-строка является пробельной.
\index{литеры!пробельные}%
\index{пробельные литеры}%
(Под пробельными понимаются литеры пробела, табуляции, новой-строки,
возврата-каретки, вертикальной-табуляции и смены-страницы.)

Литера-спецификатор указывает на способ интерпретации поля ввода.
Соответствующий аргумент должен быть указателем. Список допустимых
литер-спецификаторов приводится в табл.~\ref{tab:scanf_apxB}.

Литерам-спецификаторам \verb|d|, \verb|i|, \verb|n|, \verb|o|, \verb|u| и
\verb|x| может предшествовать \verb|h|, если аргумент есть указатель на
\verb|short| (а не \verb|int|) или \verb|l| (буква эль), если аргумент есть
указатель на \verb|long|. Литерам-спецификаторам \verb|e|, \verb|f| и \verb|g|
может предшествовать \verb|l|, если аргумент -- указатель на \verb|double| (а не
\verb|float|), или \verb|L|, если аргумент -- указатель на \verb|long double|.

\begin{ApxDescript}
\index{библиотечная функция!scanf@\texttt{scanf}}%
\verb|int scanf(const char *format, ...)|\\
\verb|scanf(...)| делает то же, что и \verb|fscanf(stdin, ...)|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!sscanf@\texttt{sscanf}}%
\verb|int sscanf(char *s, const char *format, ...)|\\
\verb|sscanf(s,...)| делает то же, что и \verb|scanf(...)|, только ввод литер
осуществляет из стринга \verb|s|.
\end{ApxDescript}

\begin{table}[t!]
\centering
\captionsetup{name=ТАБЛИЦА,labelsep=period,justification=centering}
\renewcommand\thetable{B.2}
\caption{ПРЕОБРАЗОВАНИЯ SCANF}
\label{tab:scanf_apxB}
\index{таблица!преобразований в \texttt{scanf}}%
\begin{tabular*}{\linewidth}
{p{0.1118012\linewidth-4\tabcolsep}|p{0.8881988\linewidth-4\tabcolsep}}
\hline\hline
\multicolumn{1}{c|}{\rule{0pt}{3ex}ЛИТЕРА\rule[-1.5ex]{0pt}{0pt}} &
\multicolumn{1}{|c}{ДАННЫЕ НА ВВОДЕ; ТИП АРГУМЕНТА}
\\
\hline
\rule{0pt}{3ex}\verb|   d| &десятичное целое; \verb|int *|. \\
\verb|   i| &целое; \verb|int *|. Целое может быть восьмеричным (с ведущим нулём) или шестнадцатеричным (с ведущими \verb|0x| или \verb|0X|). \\
\verb|   o| &восьмеричное целое (с ведущим нулём или без него); \verb|int *|. \\
\verb|   u| &беззнаковое десятичное целое; \verb|unsigned int *|. \\
\verb|   x| &шестнадцатеричное целое (с ведущими \verb|0x| или \verb|0X| или
без); \verb|int *|. \\
\verb|   c| &литеры; \verb|char *|. Литеры ввода размещаются в указанном массиве
в количестве, заданном шириной поля; по умолчанию это количество равно 1. Литера
\verb|'\0'| не добавляется. Пробельные литеры здесь рассматриваются как обычные
литеры и поступают в аргумент. Чтобы прочесть следующую непробельную литеру,
используйте \verb|%1s|. \\
\verb|   s| &стринг непробельных литер (записывается без кавычек);
\verb|char *|, указывающий на массив размера достаточного, чтобы вместить стринг
и добавляемую к нему литеру \verb|'\0'|. \\
\verb| e,f,g| &число с плавающей точкой; \verb|float *|.  Формат ввода для
\verb|float| состоит из необязательного знака, стринга цифр, возможно, с
десятичной точкой и необязательной экспоненты, состоящей из \verb|E| или
\verb|e| и целого, возможно, со знаком.  \\
\verb|   p| &значение указателя в виде, в котором \verb|printf("%p")| его
напечатает; \verb|void *|. \\
\verb|   n| &записывает в аргумент число литер, прочитанных к этому моменту в
этом вызове; \verb|int *|. Никакого чтения ввода не происходит. Счётчик числа
введённых элементов не увеличивается. \\
\verb| [...]| &выбирает из ввода самый длинный непустой стринг, состоящий из
литер, заданных в квадратных скобках; \verb|char *|. В конец стринга добавляется
\verb|'\0'|. Спецификатор вида \verb|[]...]| включает \verb|]| в задаваемое
множество литер. \\
\verb|[^...]| &выбирает из ввода самый длинный непустой стринг, состоящий из
литер, \emph{не входящих} в заданное в скобках множество. В конец добавляется
\verb|'\0'|. Спецификатор вида \verb|[^]...]| включает \verb|]| в задаваемое
множество литер. \\
\rule[-1.5ex]{0pt}{0pt}\verb|   %| &обычная литера \verb|%|; присваивание не
делается. \\
\hline
\end{tabular*}
\end{table}
%
% исправлена орфографические ошибки
% в оригинале было ``шестнадцатиричным'' и ``шестнадцатиричное''
%

\subsection{Функции ввода-вывода литер}

\begin{ApxDescript}
\index{библиотечная функция!fgetc@\texttt{fgetc}}%
\verb|int fgetc(FILE *stream)|\\
\verb|fgetc| возвращает следующую литеру из потока \verb|stream| в виде
\verb|unsigned char| (переведённую в \verb|int|) или \verb|EOF|, если исчерпан
файл или обнаружена ошибка.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fgets@\texttt{fgets}}%
\verb|char *fgets(char *s, int n, FILE *stream)|\\
\verb|fgets| читает не более \verb|n-1| литер в массив \verb|s|, прекращая
чтение, если встретилась литера новая-строка, которая включается в массив; кроме
того, записывает в массив \verb|'\0'|. \verb|fgets| возвращает \verb|s| или,
если исчерпан файл или обнаружена ошибка, \verb|NULL|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fputc@\texttt{fputc}}%
\verb|int fputc(int c, FILE *stream)|\\
\verb|fputc| пишет литеру \verb|c| (переведённую в \verb|unsigned char|) в
\verb|stream|. Возвращает записанную литеру или \verb|EOF| в случае ошибки.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fputs@\texttt{fputs}}%
\verb|int fputs(const char *s, FILE *stream)|\\
\verb|fputs| пишет стринг \verb|s| (который может не иметь \verb|'\n'|) в
\verb|stream|; возвращает неотрицательное целое или \verb|EOF| в случае ошибки.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!getc@\texttt{getc}}%
\verb|int getc(FILE *stream)|\\
\verb|getc| делает то же, что и \verb|fgetc|, но в отличие от последней, если
она -- макрос, \verb|stream| может быть вычислен более одного раза.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!getchar@\texttt{getchar}}%
\verb|int getchar(void)|\\
\verb|getchar()| делает то же, что \verb|getc(stdin)|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!gets@\texttt{gets}}%
\verb|char *gets(char *s)|\\
\verb|gets| читает следующую строку ввода в массив \verb|s|, заменяя литеру
новая-строка на \verb|'\0'|. Возвращает \verb|s| или, если исчерпан файл или
обнаружена ошибка, \verb|NULL|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!putc@\texttt{putc}}%
\verb|int putc(int c, FILE *stream)|\\
\verb|putc| делает то же, что и \verb|fputc|, но в отличие от последней, если
она -- макрос, \verb|stream| может быть вычислен более одного раза.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!putchar@\texttt{putchar}}%
\verb|int putchar(int c)|\\
\verb|putchar(c)| делает то же, что \verb|putc(c, stdout)|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!puts@\texttt{puts}}%
\verb|int puts(const char *s)|\\
\verb|puts| пишет стринг \verb|s| и литеру новая-строка в \verb|stdout|.
Возвращает \verb|EOF|, в случае ошибки, или неотрицательное значение, если
запись прошла нормально.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!ungetc@\texttt{ungetc}}%
\verb|int ungetc(int c, FILE *stream)|\\
\verb|ungetc| отправляет литеру \verb|c| (переведённую в \verb|unsigned char|)
обратно в \verb|stream|; при следующем чтении из \verb|stream| она будет
получена снова. Для каждого потока вернуть можно не более одной литеры. Нельзя
возвращать \verb|EOF|. В качестве результата \verb|ungetc| выдаёт отправленную
назад литеру или, в случае ошибки, \verb|EOF|.
\end{ApxDescript}

\subsection{Функции прямого ввода-вывода}

\begin{ApxDescript}
\index{библиотечная функция!fread@\texttt{fread}}%
\verb|size_t fread(void *ptr, size_t size, size_t nobj, FILE *stream)|\\
\verb|fread| читает из потока \verb|stream| в массив \verb|ptr| не более
\verb|nobj| объектов размера \verb|size|. Она возвращает количество прочитанных
объектов, которое может быть меньше заявленного. Для индикации состояния после
чтения следует использовать \verb|feof| и \verb|ferror|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fwrite@\texttt{fwrite}}%
\verb|size_t fwrite(const void *ptr, size_t size, size_t nobj,|

\verb|                       FILE *stream)|\\
\verb|fwrite| пишет из массива \verb|ptr| в \verb|stream| \verb|nobj| объектов
размера \verb|size|; возвращает число записанных объектов, которое в случае
ошибки меньше \verb|nobj|.
\end{ApxDescript}

\subsection{Функции позиционирования файла}

\begin{ApxDescript}
\index{библиотечная функция!fseek@\texttt{fseek}}%
\index{SEEK{\_}CUR, SEEK{\_}END, SEEK{\_}SET@\texttt{SEEK{\_}CUR}, \texttt{SEEK{\_}END}, \texttt{SEEK{\_}SET}}%
\verb|int fseek(FILE *stream, long offset, int origin)|\\
\verb|fseek| устанавливает позицию для \verb|stream|; последующее чтение или
запись будет производиться с этой позиции. В случае бинарного файла позиция
устанавливается со смещением \verb|offset| -- относительно начала, если
\verb|origin| равен \verb|SEEK_SET|; относительно текущей позиции, если
\verb|origin| равен \verb|SEEK_CUR|; и относительно конца файла, если
\verb|origin| равен \verb|SEEK_END|. Для текстового файла \verb|offset| должен
быть нулём или значением, полученным при помощи вызова функции \verb|ftell|. При
работе с текстовым файлом \verb|origin| всегда должен быть равен
\verb|SEEK_SET|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!ftell@\texttt{ftell}}%
\verb|long ftell(FILE *stream)|\\
\verb|ftell| возвращает текущую позицию потока \verb|stream| или \verb|-1L|‚ в
случае ошибки.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!rewind@\texttt{rewind}}%
\verb|void rewind(FILE *stream)|\\
\verb|rewind(fp)| делает то же, что и \verb|fseek(fp, 0L, SEEK_SET);|
\verb|clearerr(fp)|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fgetpos@\texttt{fgetpos}}%
\verb|int fgetpos(FILE *stream, fpos_t *ptr)|\\
\verb|fgetpos| записывает текущую позицию потока \verb|stream| в \verb|*ptr| для
последующего использования её в \verb|fsetpos|.
\index{fpos{\_}t@\texttt{fpos{\_}t}}%
Тип \verb|fpos_t| позволяет хранить такого рода значения. В случае ошибки
\verb|fgetpos| возвращает
ненулевое значение.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!fsetpos@\texttt{fsetpos}}%
\verb|int fsetpos(FILE *stream, const fpos_t *ptr)|\\
\verb|fsetpos| устанавливает позицию в \verb|stream|, читая её из \verb|*ptr|,
куда она была записана ранее при помощи \verb|fgetpos|. В случае ошибки
\verb|fsetpos| возвращает ненулевое значение.
\end{ApxDescript}

\subsection{Функции обработки ошибок}

\index{файл!головной!<errno.h>@\texttt{<errno.h>}}%
Многие функции библиотеки в случае ошибки или конца файла устанавливают
индикаторы состояния. Эти индикаторы можно проверять и изменять.
\index{errno@\texttt{errno}}%
Кроме того, целое выражение \verb|errno| (декларированное в \verb|<errno.h>|)
может содержать номер ошибки, который даёт дополнительную информацию о последней
из обнаруженных ошибок.

\begin{ApxDescript}
\index{библиотечная функция!clearerr@\texttt{clearerr}}%
\verb|void clearerr(FILE *stream)|\\
\verb|clearerr| очищает индикаторы конца файла и ошибки потока \verb|stream|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!feof@\texttt{feof}}%
\verb|int feof(FILE *stream)|\\
\verb|feof| возвращает ненулевое значение, если для потока \verb|stream|
установлен индикатор конца файла.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!ferror@\texttt{ferror}}%
\verb|int ferror(FILE *stream)|\\
\verb|ferror| возвращает ненулевое значение, если для потока \verb|stream|
установлен индикатор ошибки.
\end{ApxDescript}

\begin{ApxDescript}
\index{ввод-вывод!ошибки}%
\index{библиотечная функция!perror@\texttt{perror}}%
\verb|void perror(const char *s)|\\
\verb|perror(s)| печатает \verb|s| и реализационно-зависимое сообщение об
ошибке, соответствующее целому значению в \verb|errno|, т.е. делает то же, что и
обращение к функции \verb|fprintf| вида\\
\verb|      fprintf(stderr, "%s: %s\n", s, "|\textit{\Verb|сообщение об ошибке|}\verb|")|\\
См. \verb|strerror| в разд.~\ref{apx:sec:string_functions-string.h}.
\end{ApxDescript}

\section{Проверки класса литеры:
\texorpdfstring{\protect\Verb|<ctype.h>|}{<ctype.h>}}

\index{файл!головной!<ctype.h>@\texttt{<ctype.h>}}%
\index{функции проверки литер}%
Головной файл \verb|<ctype.h>| декларирует функции, предназначенные для проверок
литер. Аргумент каждой из них имеет тип \verb|int| и должен либо представлять
собой \verb|EOF|, либо быть значением \verb|unsigned char|, приведённым к
\verb|int|; возвращаемое значение тоже имеет тип \verb|int|. Функции возвращают
ненулевое значение (<<истина>>), когда аргумент \verb|c| удовлетворяет
описанному условию или принадлежит указанному классу литер, и нуль в противном
случае.

\begin{LongRtAlTab2cols}{\codeIndent}{0pt}{\Verb|isxdigit(c)|}
\verb|isalnum(c)|%
\index{библиотечная функция!isalnum@\texttt{isalnum}}%
&\verb|isalpha(c)| или \verb|isdigit(c)| есть истина\\
\verb|isalpha(c)|%
\index{библиотечная функция!isalpha@\texttt{isalpha}}%
&\verb|isupper(c)| или \verb|islower(c)| есть истина\\
\verb|iscntrl(c)|%
\index{библиотечная функция!iscntrl@\texttt{iscntrl}}%
&управляющая литера\\
\verb|isdigit(c)|%
\index{библиотечная функция!isdigit@\texttt{isdigit}}%
&десятичная цифра\\
\verb|isgraph(c)|%
\index{библиотечная функция!isgraph@\texttt{isgraph}}%
\index{литеры!печатаемые}%
&печатаемая литера кроме пробела\\
\verb|islower(c)|%
\index{библиотечная функция!islower@\texttt{islower}}%
&буква нижнего регистра\\
\verb|isprint(c)|%
\index{библиотечная функция!isprint@\texttt{isprint}}%
\index{литеры!печатаемые}%
&печатаемая литера, включая пробел\\
\verb|ispunct(c)|%
\index{библиотечная функция!ispunct@\texttt{ispunct}}%
&печатаемая литера кроме пробела, буквы или цифры\\
\verb|isspace(c)|%
\index{библиотечная функция!isspace@\texttt{isspace}}%
\index{литеры!пробельные}%
\index{пробельные литеры}%
&пробел, смена-страницы, новая-строка, возврат-каретки,
табуляция, вертикальная-табуляция\\
\verb|isupper(c)|%
\index{библиотечная функция!isupper@\texttt{isupper}}%
&буква верхнего регистра\\
\verb|isxdigit(c)|%
\index{библиотечная функция!isxdigit@\texttt{isxdigit}}%
&шестнадцатеричная цифра
\end{LongRtAlTab2cols}
%
% осправлена орфографическая ошибка
% в оригинале ``шестнадцатиричная''
%

\noindent%
\index{литеры!набор!ASCII}%
\index{литеры!печатаемые}%
\index{ASCII}%
В наборе семибитовых ASCII-литер печатаемые литеры находятся в диапазоне от
\verb|0x20| (\verb|' '|) до \verb|0x7E| (\verb|'~'|);
\index{управляющая!литера}%
управляющие литеры -- от \verb|0| (\verb|NUL|) до \verb|0x1F| (\verb|US|) и
\verb|0x7F| (\verb|DEL|).

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

\begin{LongRtAlTab2cols}{\codeIndent}{0pt}{\Verb|int tolower(int c) |}
\verb|int tolower(int c) |%
\index{библиотечная функция!tolower@\texttt{tolower}}%
&переводит \verb|c| на нижний регистр\\
\verb|int toupper(int c) |%
\index{библиотечная функция!toupper@\texttt{toupper}}%
&переводит \verb|c| на верхний регистр\\
\end{LongRtAlTab2cols}

\noindent Если \verb|c| -- буква на верхнем регистре, то \verb|tolower(c)|
выдаст эту букву на нижнем регистре; в противном случае она вернёт \verb|c|.
Если \verb|c| -- буква на нижнем регистре, то \verb|toupper(c)| выдаст эту букву
на верхнем регистре; в противном случае она вернёт \verb|c|.

\section{Функции, оперирующие со стрингами:
\texorpdfstring{\protect\Verb|<string.h>|}{<string.h>}}
\label{apx:sec:string_functions-string.h}

\index{файл!головной!<string.h>@\texttt{<string.h>}}%
Имеются две группы функций, оперирующих со стрингами. Они определены в головном
файле \verb|<string.h>|. Имена функций первой группы начинаются с \verb|str|,
второй -- с \verb|mem|. Если копирование имеет дело с объектами,
перекрывающимися по памяти, то, за исключением \verb|memmove|, поведение функций
не определено. Функции сравнения рассматривают аргументы как массивы элементов
типа \verb|unsigned char|.

В следующей таблице переменные \verb|s| и \verb|t| принадлежат типу
\verb|char *|, \verb|cs| и \verb|ct| -- типу \verb|const char *|, \verb|n| --
типу \verb|size_t|, а \verb|c| -- значение типа \verb|int|, приведённое к типу
\verb|char|.

\begin{LongRtAlTab2cols}{0pt}{0pt}{\Verb|char *strncpy(s,ct,n)|}
\verb|char *strcpy(s,ct)|%
\index{библиотечная функция!strcpy@\texttt{strcpy}}%
&копирует стринг \verb|ct| в стринг \verb|s|, включая \verb|'\0'|; возвращает
\verb|s|. \\
\verb|char *strncpy(s,ct,n)|%
\index{библиотечная функция!strncpy@\texttt{strncpy}}%
&копирует не более \verb|n| литер стринга \verb|ct| в \verb|s|; возвращает
\verb|s|. Дополняет результат литерами \verb|'\0'|‚ если литер в \verb|ct|
меньше \verb|n|. \\
\verb|char *strcat(s,ct)|%
\index{библиотечная функция!strcat@\texttt{strcat}}%
&конкатенирует \verb|ct| к \verb|s|; возвращает \verb|s|. \\
\verb|char *strncat(s,ct,n)|%
\index{библиотечная функция!strncat@\texttt{strncat}}%
&конкатенирует не более \verb|n| литер \verb|ct| к \verb|s|, завершая \verb|s|
литерой \verb|'\0'|; возвращает \verb|s|. \\
\verb|int strcmp(cs,ct)|%
\index{библиотечная функция!strcmp@\texttt{strcmp}}%
&сравнивает \verb|cs| с \verb|ct|; возвращает $<0$, если \verb|cs<ct|, $0$, если
\verb|cs==ct|, и $>0$, если \verb|cs>ct|. \\
\verb|int strncmp(cs,ct,n)|%
\index{библиотечная функция!strncmp@\texttt{strncmp}}%
&сравнивает не более \verb|n| литер \verb|cs| и \verb|ct|; возвращает $<0$, если
\verb|cs<ct|, $0$, если \verb|cs==ct|‚ и $>0$, если \verb|cs>ct|. \\
\verb|char *strchr(cs,c)|%
\index{библиотечная функция!strchr@\texttt{strchr}}%
&возвращает указатель на первое вхождение \verb|c| в \verb|cs| или, если
такового не оказалось, \verb|NULL|. \\
\verb|char *strrchr(cs,c)|%
\index{библиотечная функция!strrchr@\texttt{strrchr}}%
&возвращает указатель на последнее вхождение \verb|c| в \verb|cs| или, если
такового не оказалось, \verb|NULL|. \\
\verb|size_t strspn(cs,ct)|%
\index{библиотечная функция!strspn@\texttt{strspn}}%
&возвращает длину начала \verb|cs|, состоящего из литер, входящих в стринг
\verb|ct|. \\
\verb|size_t strcspn(cs,ct)|%
\index{библиотечная функция!strcspn@\texttt{strcspn}}%
&возвращает длину начала \verb|cs|, состоящего из литер, \emph{не} входящих в
стринг \verb|ct|. \\
\verb|char *strpbrk(cs,ct)|%
\index{библиотечная функция!strpbrk@\texttt{strpbrk}}%
&возвращает указатель в \verb|cs| на первую литеру, которая совпала с одной из
литер, входящих в \verb|ct|, или, если такой не оказалось, \verb|NULL|. \\
\verb|char *strstr(cs,ct)|%
\index{библиотечная функция!strstr@\texttt{strstr}}%
&возвращает указатель на первое вхождение \verb|ct| в \verb|cs| или, если
такового не оказалось, \verb|NULL|. \\
\verb|size_t strlen(cs)|%
\index{библиотечная функция!strlen@\texttt{strlen}}%
\index{стринг!длина}%
&возвращает длину \verb|cs|. \\
\verb|char *strerror(n)|%
\index{библиотечная функция!strerror@\texttt{strerror}}%
&возвращает указатель на реализационно-зависимый стринг, соответствующий номеру
ошибки \verb|n|. \\
\verb|char *strtok(s,ct)|%
\index{библиотечная функция!strtok@\texttt{strtok}}%
&\verb|strtok| ищет в \verb|s| лексему, ограниченную литерами из \verb|ct|;
(более подробное описание этой функции см. ниже).
\end{LongRtAlTab2cols}
%
% исправлены опечатки
% в оригинале "char strcmp(cs,ct)"
% и "char strncmp(cs,ct)"
%

Последовательные вызовы \verb|strtok| разбивают стринг \verb|s| на лексемы.
Ограничителем лексемы может быть любая литера из числа входящих в \verb|ct|. В
первом вызове указатель \verb|s| не есть \verb|NULL|. Функция находит в стринге
\verb|s| первую лексему, состоящую из литер, не входящих в \verb|ct|; её работа
заканчивается тем, что поверх следующей литеры пишется \verb|'\0'| и
возвращается указатель на лексему. Каждый последующий вызов, в котором указатель
\verb|s| равен \verb|NULL|, выдаёт указатель на следующую лексему, которую
функция будет искать сразу за концом предыдущей. Функция \verb|strtok|
возвращает \verb|NULL|, если далее никакой лексемы не обнаружено. Параметр
\verb|ct| от вызова к вызову может варьироваться.

Функции \verb|mem...| предназначены для манипулирования с объектами как с
массивами литер; их назначение -- получить интерфейсы к эффективным программам.
В приведённой ниже таблице \verb|s| и \verb|t| принадлежат типу \verb|void *|;
\verb|cs| и \verb|ct| -- \verb|const void *|; \verb|n| -- \verb|size_t|; а
\verb|c| -- значение типа \verb|int|, приведённое к типу \verb|char|.

\begin{LongRtAlTab2cols}{0pt}{0pt}{\Verb|void *memmove(s,ct,n)|}
\verb|void *memcpy(s,ct,n)|%
\index{библиотечная функция!memcpy@\texttt{memcpy}}%
&копирует \verb|n| литер из \verb|ct| в \verb|s| и возвращает \verb|s|. \\
\verb|void *memmove(s,ct,n)|%
\index{библиотечная функция!memmove@\texttt{memmove}}%
&делает то же самое, что и \verb|memcpy|, но работает и в случае
<<перекрывающихся>> объектов. \\
\verb|int memcmp(cs,ct,n)|%
\index{библиотечная функция!memcmp@\texttt{memcmp}}%
&сравнивает первые \verb|n| литер \verb|cs| и \verb|ct|; выдаёт тот же
результат, что и функция \verb|strcmp|. \\
\verb|void *memchr(cs,c,n)|%
\index{библиотечная функция!memchr@\texttt{memchr}}%
&возвращает указатель на первое вхождение литеры \verb|c| в \verb|cs| или, если
среди первых \verb|n| литер \verb|c| не встретилась, \verb|NULL|. \\
\verb|void *memset(s,c,n)|%
\index{библиотечная функция!memset@\texttt{memset}}%
&размещает литеру \verb|c| в первых \verb|n| позициях стринга \verb|s| и
возвращает \verb|s|.
\end{LongRtAlTab2cols}

\section{Математические функции:
\texorpdfstring{\protect\Verb|<math.h>|}{<math.h>}}
\label{apx:sect:math_h}

\index{файл!головной!<math.h>@\texttt{<math.h>}}%
В головном файле \verb|<math.h>| описываются математические функции и
определяются макросы.

\index{переполнение}%
\index{EDOM@\texttt{EDOM}}%
\index{ERANGE@\texttt{ERANGE}}%
Макросы \verb|EDOM| и \verb|ERANGE| (находящиеся в \verb|<errno.h>|) задают
отличные от нуля целочисленные константы, используемые для фиксации ошибки
области и ошибки диапазона;
\index{HUGE{\_}VAL@\texttt{HUGE{\_}VAL}}%
\verb|HUGE_VAL| определена как положительное
\verb|double|-значение. \emph{Ошибка области} возникает, если аргумент выходит
за область значений, для которой определена функция. Фиксация ошибки области
осуществляется установкой \verb|EDOM| в \verb|errno|; возвращаемое значение
зависит от реализации. \emph{Ошибка диапазона} возникает в том случае, когда
результат функции не может быть представлен в виде \verb|double|. В случае
переполнения функция возвращает \verb|HUGE_VAL| с правильным знаком и
\index{errno@\texttt{errno}}%
в \verb|errno| устанавливает \verb|ERANGE|.
\index{исчезновение порядка}%
При исчезновении порядка функция возвращает нуль, а устанавливается ли в этом
случае в \verb|errno| \verb|ERANGE|, зависит от реализации.

Далее \verb|x| и \verb|y| имеют тип \verb|double|‚ \verb|n| -- тип \verb|int|, и
все функции возвращают значения типа \verb|double|. Углы в тригонометрических
функциях задаются в радианах.

\begin{LongRtAlTab2cols}{\codeIndent}{0pt}
{\Verb|atan2(|\textit{\Verb|y|}\Verb|,|\textit{\Verb|x|}\Verb|)|}
\verb|sin(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!sin@\texttt{sin}}%
&синус $x$ \\
\verb|cos(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!cos@\texttt{cos}}%
&косинус $x$ \\
\verb|tan(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!tan@\texttt{tan}}%
&тангенс $x$ \\
\verb|asin(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!asin@\texttt{asin}}%
&арксинус $x$ в диапазоне $[-\pi/2, \pi/2],\;x\in[-1,1]$ \\
\verb|acos(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!acos@\texttt{acos}}%
&арккосинус $x$ в диапазоне $[0,\pi],\;x\in[-1,1]$ \\
\verb|atan(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!atan, atan2@\texttt{atan}, \texttt{atan2}}%
&арктангенс $x$ в диапазоне $[-\pi/2, \pi/2]$ \\
\verb|atan2(|\textit{\Verb|y|}\verb|,|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!atan, atan2@\texttt{atan}, \texttt{atan2}}%
&арктангенс $y/x$ в диапазоне $[-\pi, \pi]$ \\
\verb|sinh(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!sinh@\texttt{sinh}}%
&гиперболический синус $x$ \\
\verb|cosh(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!cosh@\texttt{cosh}}%
&гиперболический косинус $x$ \\
\verb|tanh(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!tanh@\texttt{tanh}}%
&гиперболический тангенс $x$ \\
\verb|exp(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!exp@\texttt{exp}}%
\index{экспоненциальная функция}%
&экспоненциальная функция $\mathrm{e}^x$ \\
\verb|log(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!log, log10@\texttt{log}, \texttt{log10}}%
&натуральный логарифм $\ln(x),\;x>0$ \\
\verb|log10(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!log, log10@\texttt{log}, \texttt{log10}}%
&десятичный логарифм $\log_{10}(x),\; x>0$ \\
\verb|pow(|\textit{\Verb|x|}\verb|,|\textit{\Verb|y|}\verb|)|%
\index{библиотечная функция!pow@\texttt{pow}}%
&$x^y$. Ошибка области, если $x=0$ и $y\leqslant 0$ или $x<0$ и $y$ -- не
целое \\
\verb|sqrt(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!sqrt@\texttt{sqrt}}%
&$\sqrt{x},\;x\geqslant 0$ \\
\verb|ceil(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!ceil@\texttt{ceil}}%
&наименьшее целое в виде \verb|double|, которое $\geqslant x$ \\
\verb|floor(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!floor@\texttt{floor}}%
&наибольшее целое в виде \verb|double|, которое $\leqslant x$ \\
\verb|fabs(|\textit{\Verb|x|}\verb|)|%
\index{библиотечная функция!fabs@\texttt{fabs}}%
&абсолютное значение $|x|$ \\
\verb|ldexp(|\textit{\Verb|x|}\verb|,|\textit{\Verb|n|}\verb|)|%
\index{библиотечная функция!ldexp@\texttt{ldexp}}%
&$x\cdot2^n$ \\
\multicolumn{2}{l}{\Verb|frexp(|\textit{\Verb|x|}\Verb|, int *|\textit{\Verb|exp|}\Verb|)|%
\index{библиотечная функция!frexp@\texttt{frexp}}%
}\\*
&разбивает $x$ на два сомножителя, первый из которых -- нормализованная дробь в
интервале $[1/2,1)$, которая возвращается, а второй -- степень двойки,
показатель которой запоминается в \verb|*|\textit{\Verb|exp|}. Если $x$ -- нуль,
то обе части
результата равны нулю.\\
\multicolumn{2}{l}{\Verb|modf(|\textit{\Verb|x|}\Verb|, double *|\textit{\Verb|ip|}\Verb|)|%
\index{библиотечная функция!modf@\texttt{modf}}%
}\\*
&$x$ разбивается на целую и дробную части, обе имеют тот же знак, что и $x$.
Целая часть запоминается в \verb|*|\textit{\Verb|ip|}, дробная часть выдаётся
как результат. \\
\verb|fmod(|\textit{\Verb|x|}\verb|,|\textit{\Verb|y|}\verb|)|%
\index{библиотечная функция!fmod@\texttt{fmod}}%
&остаток от деления $x$ на $y$ в виде числа с плавающей точкой.
Знак результата совпадает со знаком $x$. При $y=0$, результат зависит от
реализации.
\end{LongRtAlTab2cols}

\section{Функции общего назначения:
\texorpdfstring{\protect\Verb|<stdlib.h>|}{<stdlib.h>}}
\label{apx:sect:general_puporse_functions_stdlib}

\index{файл!головной!<stdlib.h>@\texttt{<stdlib.h>}}%
Головной файл \verb|<stdlib.h>| декларирует функции, предназначенные для
преобразования чисел, запроса памяти и других задач.

\begin{ApxDescript}
\index{библиотечная функция!atof@\texttt{atof}}%
\verb|double atof(const char *s)|\\
\verb|atof| переводит \verb|s| в \verb|double|; эквивалентна
\verb|strtod(s, (char**)NULL)|.
\end{ApxDescript}

\begin{ApxDescript}
\verb|int atoi(const char *s)|\\
\index{библиотечная функция!atoi@\texttt{atoi}}%
переводит \verb|s| в \verb|int|; эквивалентна
\verb|(int)strtol(s, (char**)NULL, 10)|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!atol@\texttt{atol}}%
\verb|int atol(const char *s)|\\
переводит \verb|s| в \verb|long|; эквивалентна
\verb|strtol(s, (char**)NULL, 10)|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!strtod@\texttt{strtod}}%
\verb|double strtod(const char *s, char **endp)|\\
\verb|strtod| преобразует первые литеры \verb|s| в \verb|double|, игнорируя
начальные пробельные литеры; запоминает указатель на непреобразованный конец в
\verb|*endp| (если \verb|endp| не \verb|NULL|). В случае переполнения она выдаёт
\verb|HUGE_VAL| с соответствующим знаком, в случае исчезновения порядка -- $0$;
в обоих случаях в \verb|errno| устанавливается \verb|ERANGE|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!strtol@\texttt{strtol}}%
\verb|long strtol(const char *s, char **endp, int base)|\\
\verb|strtol| преобразует первые литеры \verb|s| в \verb|long|, игнорируя
начальные пробельные литеры; запоминает указатель на непреобразованный конец в
\verb|*endp| (если \verb|endp| не \verb|NULL|). Если \verb|base| находится в
диапазоне от $2$ до $36$, то преобразование делается в предположении, что на
входе -- запись числа по основанию \verb|base|. Если \verb|base| равен нулю, то
основанием числа считается $8$, $10$ или $16$; число, начинающееся с цифры
\verb|0|, считается восьмеричным, а с \verb|0x| или \verb|0X| --
шестнадцатеричным. Цифры от \verb|10| до \verb|base-1| записываются начальными
буквами латинского алфавита в любом регистре. В случае основания $16$ в начале
числа разрешается помещать \verb|0x| или \verb|0X|.
\index{LONG{\_}MAX, LONG{\_}MIN@\texttt{LONG{\_}MAX}, \texttt{LONG{\_}MIN}}%
При переполнении функция возвращает \verb|LONG_MAX| или \verb|LONG_MIN| (в
зависимости от знака), а в \verb|errno| устанавливается \verb|ERANGE|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!strtoul@\texttt{strtoul}}%
\index{ULONG{\_}MAX@\texttt{ULONG{\_}MAX}}%
\verb|unsigned long strtoul(const char *s, char **endp, int base)|\\
\verb|strtoul| работает так же, как и \verb|strtol|, с той только разницей, что
выдаёт результат типа \verb|unsigned long|, а в случае переполнения --
\verb|ULONG_MAX|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!rand@\texttt{rand}}%
\index{RAND{\_}MAX@\texttt{RAND{\_}MAX}}%
\verb|int rand(void)|\\
\verb|rand| выдаёт псевдослучайное число в диапазоне от $0$ до \verb|RAND_MAX|;
\verb|RAND_MAX| не меньше $32767$.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!srand@\texttt{srand}}%
\verb|void srand(unsigned int seed)|\\
\verb|srand| использует \verb|seed| в качестве <<затравки>> для новой
последовательности псевдослучайных чисел. Изначально параметр \verb|seed| равен
$1$.
\end{ApxDescript}

\index{память!распределитель|(}%
\begin{ApxDescript}
\index{библиотечная функция!calloc@\texttt{calloc}}%
\verb|void *calloc(size_t nobj, size_t size)|\\
\verb|calloc| возвращает указатель на место в памяти, отведённое для массива
\verb|nobj| объектов, каждый из которых размера \verb|size|, или, если памяти
запрашиваемого объёма нет, \verb|NULL|. Выделенная область памяти обнуляется.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!malloc@\texttt{malloc}}%
\verb|void *malloc(size_t size)|\\
\verb|malloc| возвращает указатель на место в памяти для объекта размера
\verb|size| или, если памяти запрашиваемого объёма нет, \verb|NULL|. Выделенная
область памяти не инициализируется.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!realloc@\texttt{realloc}}%
\verb|void *realloc(void *p, size_t size)|\\
\verb|realloc| заменяет размер объекта, на который указывает \verb|p|, на
\verb|size|. Для части, размер которой равен наименьшему из старого и нового
размеров, содержимое не изменяется. Если новый размер больше старого,
дополнительное пространство не инициализируется. \verb|realloc| возвращает
указатель на новое место памяти или, если требования не могут быть
удовлетворены, \verb|NULL| (\verb|*p| при этом не изменяется).
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!free@\texttt{free}}%
\verb|void free(void *p)|\\
\verb|free| освобождает область памяти, на которую указывает \verb|p|; эта
функция ничего не делает, если \verb|p| есть \verb|NULL|. В \verb|p| должен
стоять указатель на область памяти, ранее выделенную одной из функций:
\verb|calloc|, \verb|malloc| или \verb|realloc|.
\end{ApxDescript}
\index{память!распределитель|)}%


\begin{ApxDescript}
\index{библиотечная функция!abort@\texttt{abort}}%
\verb|void abort(void)|\\
\verb|abort| вызывает аварийное завершение программы, её действия эквивалентны
вызову \verb|raise(SIGABRT)|.
\end{ApxDescript}
%
% исправлена опечатка
% в оригинале ``void abort(void *p)''
%

\begin{ApxDescript}
\index{библиотечная функция!exit@\texttt{exit}}%
\verb|void exit(int status)|\\
\verb|exit| вызывает нормальное завершение программы. Функции,
зарегистрированные при помощи \verb|atexit|, выполняются в порядке, обратном их
регистрации. Производится выталкивание буферов открытых файлов, открытые потоки
закрываются, и управление возвращается в среду, из которой был произведён запуск
программы. Значение \verb|status|, передаваемое в среду, зависит от реализации,
однако при успешном завершении программы это всегда нуль.
\index{EXIT{\_}FAILURE, EXIT{\_}SUCCESS@\texttt{EXIT{\_}FAILURE}, \texttt{EXIT{\_}SUCCESS}}%
Можно также использовать значения \verb|EXIT_SUCCESS| (в случае успешного
завершения) и \verb|EXIT_FAILURE| (в случае ошибки).
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!atexit@\texttt{atexit}}%
\verb|int atexit(void (*fcn)(void))|\\
\verb|atexit| регистрирует \verb|fcn| в качестве функции, которая будет
вызываться при нормальном завершении программы; возвращает ненулевое значение,
если регистрация не может быть сделана.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!system@\texttt{system}}%
\verb|int system(const char *s)|\\
\verb|system| передаёт стринг \verb|s| операционной среде для выполнения. Если
\verb|s| есть \verb|NULL| и существует командный процессор, то \verb|system|
возвращает ненулевое значение. Если \verb|s| не \verb|NULL|, то возвращаемое
значение зависит от реализации.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!getenv@\texttt{getenv}}%
\verb|char *getenv(const char *name)|\\
\verb|getenv| возвращает стринг среды, связанный с \verb|name|, или, если
никакого стринга не существует, \verb|NULL|. Детали зависят от реализации.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!bsearch@\texttt{bsearch}}%
\verb|void *bsearch(const void *key, const void *base,|

\verb|      size_t n, size_t size,|

\verb|      int (*cmp)(const void *keyval, const void *datum))|\\
\verb|bsearch| среди \verb|base[0]|\ldots\verb|base[n-1]| ищет элемент с
подходящим ключом \verb|*key|. Функция \verb|cmp| сравнивает первый аргумент
(ключ поиска) со своим вторым аргументом (значением ключа в таблице) и в
зависимости от результата сравнения выдаёт отрицательное число, нуль или
положительное значение. Элементы массива \verb|base| должны быть упорядочены в
возрастающем порядке. \verb|bsearch| возвращает указатель на элемент с
подходящим ключом или, если такого не оказалось, \verb|NULL|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!qsort@\texttt{qsort}}%
\verb|void qsort(void *base, size_t n, size_t size,|

\verb|               int (*cmp)(const void *, const void *))|\\
\verb|qsort| сортирует массив \verb|base[0]|\ldots\verb|base[n-1]| объектов
размера \verb|size| в возрастающем порядке. Функция сравнения \verb|cmp| --
такая же, что и в \verb|bsearch|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!abs@\texttt{abs}}%
\verb|int abs(int n)|\\
\verb|abs| возвращает абсолютное значение \verb|int|-аргумента.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!labs@\texttt{labs}}%
\verb|long labs(long n)|\\
\verb|labs| возвращает абсолютное значение \verb|long|-аргумента.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!div@\texttt{div}}%
\index{div{\_}t@\texttt{div{\_}t}}%
\verb|div_t div(int num, int denom)|\\
\verb|div| вычисляет частное и остаток от деления \verb|num| на \verb|denom|.
Результаты запоминаются в \verb|int|-членах \verb|quot| и \verb|rem| структуры
\verb|div_t|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!ldiv@\texttt{ldiv}}%
\index{ldiv{\_}t@\texttt{ldiv{\_}t}}%
\verb|ldiv_t ldiv(long num, long denom)|\\
\verb|ldiv| вычисляет частное и остаток от деления \verb|num| на \verb|denom|.
Результаты запоминаются в \verb|long|-членах \verb|quot| и \verb|rem| структуры
\verb|ldiv_t|.
\end{ApxDescript}

\section{Диагностика:
\texorpdfstring{\protect\Verb|<assert.h>|}{<assert.h>}}

Макрос \verb|assert| используется для включения в программу диагностических
сообщений.

\begin{ShortCodeParWithCC}{\\\{\}}
void assert(int \textit{выражение})
\end{ShortCodeParWithCC}

\noindent Если \textit{выражение} есть нуль, то

\begin{ShortCodeParWithCC}{\\\{\}}
assert(\textit{выражение})
\end{ShortCodeParWithCC}

\noindent напечатает в \verb|stderr| сообщение следующего вида:

\begin{ShortCodeParWithCC}{\\\{\}}
Assertion failed: \textit{выражение}, file \textit{имя-файла},\
line \textit{nnn}
\end{ShortCodeParWithCC}

\noindent%
\index{препроцессор!заранее определённые имена!FILE@\texttt{\_\_FILE\_\_}}%
\index{препроцессор!заранее определённые имена!LINE@\texttt{\_\_LINE\_\_}}%
после чего будет вызвана функция \verb|abort|, которая завершит вычисления.
\index{FILE (имя для препроцессора)@\texttt{\_\_FILE\_\_} (имя для препроцессора)}%
\index{LINE a (имя для препроцессора)@\texttt{\_\_LINE\_\_} (имя для препроцессора)}%
Имя исходного файла и номер строки будут взяты из макросов \verb|__FILE__| и
\verb|__LINE__|.

Если в момент включения файла \verb|<assert.h>| было определено имя
\verb|NDEBUG|, то макрос \verb|assert| игнорируется.

\section{Списки аргументов переменной длины:
\texorpdfstring{\protect\Verb|<stdarg.h>|}{<stdarg.h>}}
\label{apx:sec:variable_argument_lists-stdarg.h}

\index{список!аргументов переменной длины}%
\index{файл!головной!<stdarg.h>@\texttt{<stdarg.h>}}%
\index{va{\_}list, va{\_}start, va{\_}arg, va{\_}end@\texttt{va{\_}list}, \texttt{va{\_}start}, \texttt{va{\_}arg}, \texttt{va{\_}end}}%
Головной файл \verb|<stdarg.h>| предоставляет средства для перебора аргументов
функции, количество и типы которых заранее не известны.

Пусть \textit{посларг} -- последний именованный параметр функции \verb|f| с
переменным числом аргументов. Внутри \verb|f| декларируется переменная
\verb|ap| типа \verb|va_list|‚ предназначенная для хранения указателя на
очередной аргумент:

\begin{ShortCodePar}
va_list ap;
\end{ShortCodePar}

\noindent Прежде чем будет возможен доступ к безымянным аргументам, необходимо
один раз инициализировать \verb|ap|, обратившись к макросу \verb|va_start|:

\begin{ShortCodeParWithCC}{\\\{\}}
va_start(va_list ap, \textit{посларг});
\end{ShortCodeParWithCC}

\noindent С этого момента каждое обращение к макросу:

\begin{ShortCodeParWithCC}{\\\{\}}
\textit{тип} va_arg(va_list ap, \textit{тип});
\end{ShortCodeParWithCC}

\noindent будет давать значение очередного безымянного аргумента указанного
типа, и каждое такое обращение будет вызывать автоматическое продвижение
указателя \verb|ap|, чтобы последний был готов к выдаче следующего аргумента.
Один раз после перебора аргументов, но до выхода из \verb|f| необходимо
обратиться к макросу

\begin{ShortCodePar}
void va_end(va_list ap);
\end{ShortCodePar}

\section{Далёкие переходы:
\texorpdfstring{\protect\Verb|<setjmp.h>|}{<setjmp.h>}}

\index{файл!головной!<setjmp.h>@\texttt{<setjmp.h>}}%
Декларации в \verb|<setjmp.h>| предоставляют способ отклониться от обычной
последовательности <<вызов -- возврат>>; типичная ситуация -- необходимость
вернуться из <<глубоко вложенного>> вызова функции на верхний уровень, минуя
промежуточные возвраты.

\begin{ApxDescript}
\index{библиотечная функция!setjmp@\texttt{setjmp}}%
\verb|int setjmp(jmp_buf env)|\\
Макрос \verb|setjmp| сохраняет текущую информацию о вызовах в \verb|env| для
последующего её использования в \verb|longjmp|. Возвращает нуль, если возврат
осуществляется непосредственно из \verb|setjmp|, и не нуль, если -- от
последующего вызова \verb|longjmp|. Обращение к \verb|setjmp| возможно только в
определённых контекстах; в основном это проверки в \verb|if|, \verb|switch| и
циклах, причём только в простых выражениях отношения.
\end{ApxDescript}

\begin{ShortCodePar}
if (setjmp(env) == 0)
    /* после прямого возврата */
else
    /* после возврата из longjmp */
\end{ShortCodePar}
%
% исправлена опечатка
% в оригинале
% if (setjmp() == 0)
%

\begin{ApxDescript}
\index{библиотечная функция!longjmp@\texttt{longjmp}}%
\verb|void longjmp(jmp_buf env, int val)|\\
\verb|longjmp| восстанавливает информацию, сохранённую в самом последнем вызове
\verb|setjmp|, по информации из \verb|env|; счёт возобновляется, как если бы
функция \verb|setjmp| только что отработала и вернула ненулевое значение
\verb|val|. Результат будет непредсказуемым, если в момент обращения к
\verb|longjmp| функция, содержащая вызов \verb|setjmp|, уже <<отработала>> и
осуществила возврат. Доступные ей объекты имеют те значения, которые они имели в
момент обращения к \verb|longjmp|; \verb|setjmp| не сохраняет значений.
\end{ApxDescript}

\section{Сигналы:
\texorpdfstring{\protect\Verb|<signal.h>|}{<signal.h>}}

\index{исключительные ситуации}%
\index{файл!головной!<signal.h>@\texttt{<signal.h>}}%
Головной файл \verb|<signal.h>| предоставляет средства для обработки
исключительных ситуаций, возникающих во время выполнения программы, таких, как
прерывание, вызванное внешним источником или ошибкой в вычислениях.

\begin{ApxDescript}
\index{библиотечная функция!signal@\texttt{signal}}%
\verb|void (*signal(int sig, void (*handler)(int)))(int)|
\end{ApxDescript}

\index{SIG{\_}DFL, SIG{\_}ERR, SIG{\_}IGN@\texttt{SIG{\_}DFL}, \texttt{SIG{\_}ERR}, \texttt{SIG{\_}IGN}}%
\verb|signal| устанавливает, как будут обрабатываться последующие сигналы. Если
параметр \verb|handler| имеет значение \verb|SIG_DFL|, то используется
реализационно-зависимая <<обработка по умолчанию>>; если значение
\verb|handler| равно \verb|SIG_IGN|‚ то сигнал игнорируется; в остальных
случаях будет выполнено обращение к функции, на которую указывает
\verb|handler| с типом сигнала в качестве аргумента. В число допустимых видов
сигналов входят:

\begin{LongRtAlTab2cols}{\codeIndent}{0pt}{\Verb|SIGABRT|}
\verb|SIGABRT|&аварийное завершение, например, от \verb|abort| \\
\verb|SIGFPE|&арифметическая ошибка: деление на $0$ или переполнение \\
\verb|SIGILL|&неверный код функции (недопустимая команда) \\
\verb|SIGINT|&запрос на взаимодействие, например, прерывание \\
\verb|SIGSEGV|%
\index{переполнение}%
&неверный доступ к памяти, например, выход за границы \\
\verb|SIGTERM|&требование завершения, посланное в программу
\end{LongRtAlTab2cols}

\noindent \verb|signal| возвращает предыдущее значение \verb|handler| -- в
случае специфицированного сигнала, или \verb|SIG_ERR| -- в случае возникновения
ошибки.
%%
%% исправлена опечатка
%% в оригинале было "SIGERR"
%%

Когда в дальнейшем появляется сигнал \verb|sig|, сначала восстанавливается
готовность поведения <<по умолчанию>>, после чего вызывается функция, заданная в
параметре \verb|handler|, т.е. как бы выполняется вызов \verb|(*handler)(sig)|.
Если \verb|handler|-функция вернёт назад управление, то вычисления возобновятся
с того места, в каком застал программу пришедший сигнал.

Начальное состояние сигналов зависит от реализации.

\begin{ApxDescript}
\index{библиотечная функция!raise@\texttt{raise}}%
\verb|int raise(int sig)|\\
\verb|raise| посылает сигнал \verb|sig| в программу. В случае неудачи
возвращает ненулевое значение.
\end{ApxDescript}

\section{Функции даты и времени:
\texorpdfstring{\protect\Verb|<time.h>|}{<time.h>}}

\index{файл!головной!<time.h>@\texttt{<time.h>}}%
Головной файл \verb|<time.h>| декларирует типы и функции, связанные с датой и
временем. Некоторые функции имеют дело с \emph{местным временем}, которое может
отличаться от календарного, например, в связи с зонированием времени.
\index{clock{\_}t@\texttt{clock{\_}t}}%
\index{time{\_}t@\texttt{time{\_}t}}%
Типы \verb|clock_t| и \verb|time_t| -- арифметические типы для представления
времени, а \verb|struct tm| содержит компоненты календарного времени:

\begin{LongRtAlTab2cols}{\codeIndent}{0pt}{\Verb|int tm{\_}isdst;qqqqq|}
\verb|int tm_sec;|&секунды от начала минуты (0, 61) \\
\verb|int tm_min;|&минуты от начала часа (0, 59) \\
\verb|int tm_hour;|&часы от полуночи (0, 23) \\
\verb|int tm_mday;|&число месяца (1, 31) \\
\verb|int tm_mon;|&месяцы \emph{после} января (0, 11) \\
\verb|int tm_year;|&годы после 1900 \\
\verb|int tm_wday;|&дни после воскресенья (0, 6) \\
\verb|int tm_yday;|&дни после 1 января (0, 365) \\
\verb|int tm_isdst;|&признак светлого времени
\end{LongRtAlTab2cols}

\noindent Значение \verb|tm_isdst| -- положительное, если время приходится на
светлую часть суток, нуль в противном случае и отрицательное, если информация не
доступна.

\begin{ApxDescript}
\index{библиотечная функция!clock@\texttt{clock}}%
\verb|clock_t clock(void)|\\
\verb|clock| возвращает время, фиксируемое процессором от начала счёта
программы, или $-1$‚ если оно не известно.
\index{CLOCKS{\_}PER{\_}SEC@\texttt{CLOCKS{\_}PER{\_}SEC}}%
Для выражения этого времени в секундах применяется формула
\verb|clock()/CLOCKS_PER_SEC|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!time@\texttt{time}}%
\verb|time_t time(time_t *tp)|\\
\verb|time| возвращает текущее календарное время или $-1$‚ если время не
известно. Если \verb|tp| не \verb|NULL|, то возвращаемое значение записывается и
в \verb|*tp|.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!difftime@\texttt{difftime}}%
\verb|double difftime(time_t time2, time_t time1)|\\
\verb|difftime| возвращает разность \verb|time2-time1|, выраженную в секундах.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!mktime@\texttt{mktime}}%
\verb|time_t mktime(struct tm *tp)|\\
\verb|mktime| преобразует местное время, заданное структурой \verb|*tp|, в
календарное, выдавая его в том же виде, что и функция \verb|time|. Компоненты
будут иметь значения в указанных диапазонах. Функция \verb|mktime| возвращает
календарное время или $-1$, если оно не представимо.
\end{ApxDescript}

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

\begin{ApxDescript}
\index{библиотечная функция!asctime@\texttt{asctime}}%
\verb|char *asctime(const struct tm *tp)|\\
\verb|asctime| переводит время в структуре \verb|*tp| в стринг вида
\end{ApxDescript}

\begin{ShortCodePar}
Sun Jan   3   15:14:13   1988\n\0
\end{ShortCodePar}

\begin{ApxDescript}
\index{библиотечная функция!ctime@\texttt{ctime}}%
\verb|char *ctime(const time_t *tp)|\\
\verb|ctime| переводит календарное время в местное, что эквивалентно выполнению
\end{ApxDescript}

\begin{ShortCodePar}
asctime(localtime(tp))
\end{ShortCodePar}

\begin{ApxDescript}
\index{библиотечная функция!gmtime@\texttt{gmtime}}%
\verb|struct tm *gmtime(const time_t *tp)|\\
\verb|gmtime| переводит календарное время во Всемирное координированное время
(Coordinated Universal Time -- UTC). Выдаёт \verb|NULL|, если UTC не известно.
Имя этой функции, \verb|gmtime|, происходит от Greenwich Mean Time (среднее
время по Гринвичскому меридиану).
\end{ApxDescript}
%
% забавно но в английском издании
% последнее предложение этого абзаца выглядит как
% The name gmtime has historical significance.
% То есть, в чём историческая значимость, вообще-то не указано,
% так что в переводе мы видим вольности переводчика )))
%

\begin{ApxDescript}
\index{библиотечная функция!localtime@\texttt{localtime}}%
\verb|struct tm *localtime(const time_t *tp)|\\
\verb|localtime| переводит календарное время \verb|*tp| в местное.
\end{ApxDescript}

\begin{ApxDescript}
\index{библиотечная функция!strftime@\texttt{strftime}}%
\verb|size_t strftime(char *s, size_t smax, const char *fmt,|

\verb|                   const struct tm *tp)|\\
\verb|strftime| форматирует информацию о дате и времени из \verb|*tp| в стринг
\verb|s| согласно формату \verb|fmt|, который имеет много общих черт с форматом,
задаваемым в функции \verb|printf|. Обычные литеры (включая и завершающую литеру
\verb|'\0'|) копируются в \verb|s|. Каждая пара, состоящая из \verb|%| и буквы,
заменяется, как показано ниже, с использованием значений по форме,
соответствующей локальной среде. В \verb|s| размещается не более \verb|smax|
литер. \verb|strftime| возвращает число литер без учёта \verb|'\0'| или нуль,
если число сгенерированных литер больше \verb|smax|.
\end{ApxDescript}

\begin{LongRtAlTab2cols}{\codeIndent+\parindent}{0pt}{\Verb|\%a|}
\verb|%a|&сокращённое название недели. \\
\verb|%A|&полное название недели. \\
\verb|%b|&сокращённое название месяца. \\
\verb|%B|&полное название месяца. \\
\verb|%c|&локальное представление даты и времени. \\
\verb|%d|&день месяца (01--31). \\
\verb|%H|&час (24-часовое время) (00--23). \\
\verb|%I|&час (12-часовое время) (01--12). \\
\verb|%j|&день года (001--366). \\
\verb|%m|&месяц (01--12). \\
\verb|%M|&минута (00--59). \\
\verb|%p|&локальное представление AM и PM (до и после полудня). \\
\verb|%S|&секунда (00--61). \\
\verb|%U|&неделя по счёту от начала года (воскресенье -- 1-й день недели)
(00--53). \\
\verb|%w|&день недели (0--6, номер воскресенья есть 0). \\
\verb|%W|&неделя по счёту от начала года (понедельник -- 1-й день недели)
(00--53). \\
\verb|%x|&локальное представление даты. \\
\verb|%X|&локальное представление времени. \\
\verb|%y|&год без указания века (00--99). \\
\verb|%Y|&год с указанием века. \\
\verb|%Z|&название временной зоны, если оно есть. \\
\verb|%%|&\verb|%|.
\end{LongRtAlTab2cols}

\section{Реализационно-зависимые пределы:
\texorpdfstring{\protect\Verb|<limits.h>|}{<limits.h>} и
\texorpdfstring{\protect\Verb|<float.h>|}{<float.h>}}

\index{файл!головной!<float.h>@\texttt{<float.h>}}%
\index{файл!головной!<limits.h>@\texttt{<limits.h>}}%
\index{числа!размер}%
Головной файл \verb|<limits.h>| определяет константы для размеров целочисленных
типов. Ниже перечислены минимальные приемлемые величины, но в конкретных
реализациях могут использоваться и большие значения.

\begin{LongRtAlTab3cols}{2\parindent-\codeIndent}{0pt}
{\Verb|SCHAR{\_}MAX|}{\Verb|0|\textit{ или }\Verb|SCHAR{\_}MIN|}
\verb|CHAR_BIT|&\hfill\verb|8|&бит в значении \verb|char|\\
\verb|CHAR_MAX|&\verb|UCHAR_MAX|\textit{ или}&\\
&\hfill\verb|SCHAR_MAX|&максимальное значение \verb|char|\\
\verb|CHAR_MIN|&\hfill\verb|0|\textit{ или }\verb|SCHAR_MIN|&минимальное
значение \verb|char|\\
\verb|INT_MAX|&\hfill\verb|+32767|&максимальное значение \verb|int|\\
\verb|INT_MIN|&\hfill\verb|-32767|&минимальное значение \verb|int|\\
\verb|LONG_MAX|%
\index{LONG{\_}MAX, LONG{\_}MIN@\texttt{LONG{\_}MAX}, \texttt{LONG{\_}MIN}}%
&\hfill\verb|+2147483647|&максимальное значение \verb|long|\\
\verb|LONG_MIN|%
\index{LONG{\_}MAX, LONG{\_}MIN@\texttt{LONG{\_}MAX}, \texttt{LONG{\_}MIN}}%
&\hfill\verb|-2147483647|&минимальное значение \verb|long|\\
\verb|SCHAR_MAX|&\hfill\verb|+127|&максимальное значение \verb|signed char|\\
\verb|SCHAR_MIN|&\hfill\verb|-127|&минимальное значение \verb|signed char|\\
\verb|SHRT_MAX|&\hfill\verb|+32767|&максимальное значение \verb|short|\\
\verb|SHRT_MIN|&\hfill\verb|-32767|&минимальное значение \verb|short|\\
\verb|UCHAR_MAX|&\hfill\verb|255|&максимальное значение \verb|unsigned char|\\
\verb|UINT_MAX|&\hfill\verb|65535|&максимальное значение \verb|unsigned int|\\
\verb|ULONG_MAX|%
\index{ULONG{\_}MAX@\texttt{ULONG{\_}MAX}}%
&\hfill\verb|4294967295|&максимальное значение \verb|unsigned long|\\
\verb|USHRT_MAX|&\hfill\verb|65535|&максимальное значение
\verb|unsigned short|\\
\end{LongRtAlTab3cols}

\index{числа!размер}%
Имена, приведённые в следующей таблице, взяты из \verb|<float.h>| и являются
константами, имеющими отношение к арифметике с плавающей точкой. Значения (если
они есть) представляют собой минимальные значения для соответствующих величин. В
каждой реализации устанавливаются свои значения.

\begin{LongRtAlTab3cols}{2\parindent-\codeIndent}{0pt}
{\Verb|FLT{\_}MANT{\_}DIG|}{\Verb|1E+37|}
\verb|FLT_RADIX|&\hfill\verb|2|&основание представления экспоненты: например,
$2$, $16$\\
\verb|FLT_ROUNDS|&&способ округления при сложении чисел с плавающей точкой\\
\verb|FLT_DIG|&\hfill\verb|6|&количество верных десятичных цифр\\
\verb|FLT_EPSILON|&\hfill\verb|1E-5|&минимальное $x$, такое, что
$1.0+x\neq1.0$\\
\verb|FLT_MANT_DIG|&&количество цифр по основанию \verb|FLT_RADIX| в
мантиссе\\
\verb|FLT_MAX|&\hfill\verb|1E+37|&максимальное число с плавающей точкой\\
\verb|FLT_MAX_EXP|&&максимальное $n$, такое, что \verb|FLT_RADIX|$^{n}-1$
представимо\\
\verb|FLT_MIN|&\hfill\verb|1E-37|&минимальное нормализованное число с плавающей
точкой\\
\verb|FLT_MIN_EXP|&&минимальное $n$, такое, что $10^n$ представимо в виде
нормализованного числа\\
\verb|DBL_DIG|&\hfill\verb|10|&количество верных десятичных цифр для типа
\verb|double|\\
\verb|DBL_EPSILON|&\hfill\verb|1E-9|&минимальное $x$, такое, что $1.0+x\neq1.0$,
где $x$ принадлежит типу \verb|double|\\
\verb|DBL_MANT_DIG|&&количество цифр по основанию \verb|FLT_RADIX| в мантиссе
для чисел типа \verb|double|\\
\verb|DBL_MAX|&\hfill\verb|1E+37|&максимальное число с плавающей точкой типа
\verb|double|\\
\verb|DBL_MAX_EXP|&&максимальное $n$, такое, что \verb|FLT_RADIX|$^{n}-1$
представимо в виде числа типа \verb|double|\\
\verb|DBL_MIN|&\hfill\verb|1E-37|&минимальное нормализованное число с плавающей
точкой типа \verb|double|\\
\verb|DBL_MIN_EXP|&&минимальное $n$, такое, что $10^n$ представимо в виде
нормализованного числа типа \verb|double|
\end{LongRtAlTab3cols}
