Kernighan, B. W. and Ritchie, D. M. "The 'C' Programming Language"; Chapter 7

# Ввод и вывод.

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

Мы здесь не будем пытаться описать всю библиотеку ввода/вывода; мы более заинтересованы в том, чтобы продемонстрировать сущность написания "Си"-программ, которые взаимодействуют со своей операционной средой.

#### Содержание

7.1. Обращение к стандартной библиотеке.
7.2. Стандартный ввод и вывод - функции getchar и putchar
7.3. Форматный вывод - функция printf
7.4. Форматный ввод - функция scanf.
7.5. Форматное преобразование в памяти.
7.6. Доступ к файлам.
7.7. Обработка ошибок - stderr и exit.
7.8. Ввод и вывод строк.
7.9. Несколько разнообразных функций
  7.9.1. Проверка вида символов и преобразования.
  7.9.2. Функция ungetc.
  7.9.3. Обращение к системе.
  7.9.4. Управление памятью.

## Обращение к стандартной библиотеке.

Каждый исходный файл, который обращается к функции из стандартной библиотеки, должен вблизи начала содержать строку

     #include <stdio.h>

В файле stdio.h Определяются некоторые макросы и переменные, используемые библиотекой ввода/вывода. Использование угловых скобок вместо обычных двойных кавычек - указание компилятору искать этот файл в справочнике, содержащем заголовки стандартной информации (на системе UNIX обычно lusrlinelude).

Кроме того, при загрузке программы может оказаться необходимым указать библиотеку явно; на системе pdp-11 UNIX, например, команда компиляции программы имела бы вид:

     сс исходные файлы и т.д. -ls

где -ls указывает на загрузку из стандартной библиотеки.

## Стандартный ввод и вывод - функции getchar и putchar

Самый простой механизм ввода заключается в чтении по одному символу за раз из "стандартного ввода", обычно с терминала пользователя, с помощью функции getchar. Функция getchar() при каждом к ней обращении возвращает следующий вводимый символ. В большинстве сред, которые поддерживают язык "Си", терминал может быть заменен некоторым файлом с помощью обозначения < : если некоторая программа prog использует функцию getchar то командная строка

     prog < infile

приведет к тому, что prog будет читать из файла infile, а не с терминала. Переключение ввода делается таким образом, что сама программа prog не замечает изменения; в частности строка"<infile" не включается в командную строку аргументов в argv. Переключение ввода оказывается незаметным и в том случае, когда вывод поступает из другой программы посредством поточного (pipe) механизма; командная строка

     otherprog | prog

прогоняет две программы, otherprog и prog, и организует так, что стандартным вводом для prog служит стандартный вывод otherprog.

Функция getchar возвращает значение EOF, когда она попадает на конец файла, какой бы ввод она при этом не считывала. Стандартная библиотека полагает символическую константу EOF равной -1 (посредством #define в файле stdio.h), но проверки следует писать в терминах EOF, а не -1, чтобы избежать зависимости от конкретного значения.

Вывод можно осуществлять с помощью функции putchar(c), помещающей символ 'c' в "стандартный ввод", который по умолчанию является терминалом. Вывод можно направить в некоторый файл с помощью обозначения > : если prog использует putchar, то командная строка

     prog > outfile

приведет к записи стандартного вывода в файл outfile, а не на терминал. На системе UNIX можно также использовать поточный механизм. Строка

     prog | anotherprog

помещает стандартный вывод prog в стандартный ввод anotherprog. И опять prog не будет осведомлена об изменении направления.

Вывод, осуществляемый функцией printf, также поступает в стандартный вывод, и обращения к putchar и printf могут перемежаться.

Поразительное количество программ читает только из одного входного потока и пишет только в один выходной поток; для таких программ ввод и вывод с помощью функций getchar, putchar и printf может оказаться вполне адекватным и для начала определенно достаточным. Это особенно справедливо тогда, когда имеется возможность указания файлов для ввода и вывода и поточный механизм для связи вывода одной программы с вводом другой. Рассмотрим, например, программу lower, которая преобразует прописные буквы из своего ввода в строчные:

     #include <stdio.h>

     main() /* convert input to lower case */
     {
            int c;

            while ((c = getchar()) != EOF)
                    putchar(isupper(c) ? tolower(c) : c);
     }

"Функции" isupper и tolower на самом деле являются макросами, определенными в stdio.h . Макрос isupper проверяет, является ли его аргумент буквой из верхнего регистра, и возвращает ненулевое значение, если это так, и нуль в противном случае. Макрос tolower преобразует букву из верхнего регистра в ту же букву нижнего регистра. Независимо от того, как эти функции реализованы на конкретной машине, их внешнее поведение совершенно одинаково, так что использующие их программы избавлены от знания символьного набора.

Если требуется преобразовать несколько файлов, то можно собрать эти файлы с помощью программы, подобной утилите сат системы UNIX,

     cat file1 file2 ... | lower > output

и избежать тем самым вопроса о том, как обратиться к этим файлам из программы. (программа сат приводится позже в этой главе).

Кроме того отметим, что в стандартной библиотеке ввода/вывода "функции" getchar и putchar на самом деле могут быть макросами. Это позволяет избежать накладных расходов на обращение к функции для обработки каждого символа. В главе 8 мы продемонстрируем, как это делается.

## Форматный вывод - функция printf

Две функции: printf для вывода и scanf для ввода (следующий раздел) позволяют преобразовывать численные величины в символьное представление и обратно. Они также позволяют генерировать и интерпретировать форматные строки. Мы уже всюду в предыдущих главах неформально использовали функцию printf; здесь приводится более полное и точное описание. Функция

     printf(control, arg1, arg2, ...)

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

Каждая спецификация преобразования начинается с символа % и заканчивается символом преобразования. Между % и символом преобразования могут находиться:

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

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

- Точка, которая отделяет ширину поля от следующей строки цифр.

- Строка цифр (точность), которая указывает максимальное число символов строки, которые должны быть напечатаны, или число печатаемых справа от десятичной точки цифр для переменных типа float или double.

- Модификатор длины l, который указывает, что соответствующий элемент данных имеет тип long, а не int.

  Ниже приводятся символы преобразования и их смысл:

  d
    аргумент преобразуется к десятичному виду.

  o
    аргумент преобразуется в беззнаковую восьмеричную форму (без лидирующего нуля).

  x
    аргумент преобразуется в беззнаковую шестнадцатеричную форму (без лидирующих 0х).

  u
    аргумент преобразуется в беззнаковую десятичную форму.

  c
    аргумент рассматривается как отдельный символ.

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

  e
    аргумент, рассматриваемый как переменная типа float или double, преобразуется в десятичную форму в виде [-]m.nnnnnne[+-]хх, где длина строки из n определяется указанной точностью. Точность по умолчанию равна 6.

  f
    аргумент, рассматриваемый как переменная типа float или double, преобразуется в десятичную форму в виде [-]mmm.nnnnn, где длина строки из n определяется указанной точностью. Точность по умолчанию равна 6. Отметим, что эта точность не определяет количество печатаемых в формате f значащих цифр.

  g
    используется или формат %е или %f, какой короче; незначащие нули не печатаются. Если идущий за % символ не является символом преобразования, то печатается сам этот символ; следовательно,символ % можно напечатать, указав %%.

  Большинство из форматных преобразований очевидно и было проиллюстрировано в предыдущих главах. Единственным исключением является то, как точность взаимодействует со строками. Следующая таблица демонстрирует влияние задания различных спецификаций на печать "hello, world" (12 символов). Мы поместили двоеточия вокруг каждого поля для того, чтобы вы могли видеть его протяженность.

       :%10s:         :hello, world:
       :%10-s:        :hello, world:
       :%20s:         :        hello, world:
       :%-20s:        :hello, world        :
       :%20.10s:      :          hello, wor:
       :%-20.10s:     :hello, wor          :
       :%.10s:        :hello, wor:

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

  Упражнение 7-1.
    Напишите программу, которая будет печатать разумным образом произвольный ввод. Как минимум она должна печатать неграфические символы в восьмеричном или шестнадцатеричном виде (в соответствии с принятыми у вас обычаями) и складывать длинные строки.

  ## Форматный ввод - функция scanf.

  Осуществляющая ввод функция scanf является аналогом printf и позволяет проводить в обратном направлении многие из тех же самых преобразований. Функция

       scanf(control, arg1, arg2, ...)

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

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

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

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

  Символ преобразования определяет интерпретацию поля ввода; согласно требованиям основанной на вызове по значению семантики языка "Си" соответствующий аргумент должен быть указателем. Допускаются следующие символы преобразования:

  d
    на вводе ожидается десятичное целое; соответствующий аргумент должен быть указателем на целое.

  o
    на вводе ожидается восьмеричное целое (с лидирующим нулем или без него); соответствующий аргумент должен быть указателем на целое.

  x
    на вводе ожидается шестнадцатеричное целое (с лидирующими 0х или без них); соответствующий аргумент должен быть указателем на целое.

  h
    на вводе ожидается целое типа short; соответсвующий аргумент должен быть указателем на целое типа short.

  c
    ожидается отдельный символ; соответствующий аргумент должен быть указателем на символы; следующий вводимый символ помещается в указанное место. Обычный пропуск символов пустых промежутков в этом случае подавляется; для чтения следующего символа, который не является символом пустого промежутка, пользуйтесь спецификацией преобразования %1s.

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

  f
    ожидается число с плавающей точкой; соответствующий аргумент должен быть указателем на переменную типа float.

  e
    символ преобразования е является синонимом для f. Формат ввода переменной типа float включает необязательный знак, строку цифр, возможно содержащую десятичную точку и необязательное поле экспоненты, состоящее из буквы е, за которой следует целое, возможно имеющее знак.

  Перед символами преобразования d, о и х может стоять l, которая означает , что в списке аргументов должен находиться указатель на переменную типа long, а не типа int. Аналогично, буква l может стоять перед символами преобразования е или f, говоря о том, что в списке аргументов должен находиться указатель на переменную типа double, а не типа float.

  Например, обращение

       int 1;
       float x;
       char name[50];
       scanf("&d %f %s", &i, &x, name);

  со строкой на вводе

       25 54.32e-1 thompson

  приводит к присваиванию i значения 25, x - значения 5.432 и name - строки "thompson", надлежащим образом законченной символом \ 0. Эти три поля ввода можно разделить столькими пробелами, табуляциями и символами новых строк, сколько вы пожелаете. Обращение

       int i;
       float x;
       char name[50];
       scanf("%2d %f %*d %2s", &i, &x, name);

  с вводом

       56789 0123 45a72

  присвоит i значение 56, x - 789.0, пропустит 0123 и поместит в name строку "45". При следующем обращении к любой процедуре ввода рассмотрение начнется с буквы а. В этих двух примерах name является указателем и, следовательно, перед ним не нужно помещать знак &.

  В качестве другого примера перепишем теперь элементарный калькулятор из главы 4, используя для преобразования ввода функцию scanf:

       #include <stdio.h>
       main() /* rudimentary desk calculator */
       {
              double sum, v;
              sum =0;
              while (scanf("%lf", &v) !=EOF)
                      printf("\\t%.2f\n", sum += v);
       }

  Выполнение функции scanf заканчивается либо тогда, когда она исчерпывает свою управляющую строку, либо когда некоторый элемент ввода не совпадает с управляющей спецификацией. В качестве своего значения она возвращает число правильно совпадающих и присвоенных элементов ввода. Это число может быть использовано для определения количества найденных элементов ввода. При выходе на конец файла возвращается EOF; подчеркнем, что это значение отлично от 0, что следующий вводимый символ не удовлетворяет первой спецификации в управляющей строке. При следующем обращении к scanf поиск возобновляется непосредственно за последним введенным символом.

  Заключительное предостережение: аргументы функции scanf должны быть указателями. Несомненно наиболее распространенная ошибка состоит в написании

       scanf("%d", n);

  вместо

       scanf("%d", &n);

  ## Форматное преобразование в памяти.

  От функции scanf и printf происходят функции sscanf и sprintf, которые осуществляют аналогичные преобразования, но оперируют со строкой, а не с файлом. Обращения к этим функциям имеют вид:

       sprintf(string, control, arg1, arg2, ...)
       sscanf(string, control, arg1, arg2, ...)

  Как и раньше, функция sprintf преобразует свои аргументы arg1, arg2 и т.д. в соответствии с форматом, указанным в control, но помещает результаты в string, а не в стандартный вывод. Конечно, строка string должна быть достаточно велика, чтобы принять результат. Например, если name - это символьный массив, а n - целое, то

       sprintf(name, "temp%d", n);

  создает в name строку вида tempnnn, где nnn - значение n.

  Функция sscanf выполняет обратные преобразования - она просматривает строку string в соответствии с форматом в аргументе control и помещает результирующие значения в аргументы arg1, arg2 и т.д.эти аргументы должны быть указателями. В результате обращения

       sscanf(name, "temp%d", &n);

  переменная n получает значение строки цифр, следующих за темр в name.
  Упражнение 7-2.
    Перепишите настольный калькулятор из главы 4, используя для ввода и преобразования чисел scanf и/или sscanf.

  ## Доступ к файлам.

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

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

       cat x.c.y.c

  Печатает содержимое файлов x.c и y.y В стандартный вывод.

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

  Эти правила просты. Прежде чем можно считывать из некоторого файла или записывать в него, этот файл должен быть открыт с помощью функции fopen из стандартной библиотеки. Функция fopen берет внешнее имя (подобное x.c или y.c), проводит некоторые обслуживающие действия и переговоры с операционной системой (детали которых не должны нас касаться) и возвращает внутреннее имя, которое должно использоваться при последующих чтениях из файла или записях в него.

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

      FILE *fopen(), *fp;

  Здесь говорится, что fp является указателем на FILE и fopen возвращает указатель на FILE. Обратите внимание, что FILE является именем типа, подобным int, а не ярлыку структуры; это реализовано как typedef. (Подробности того, как все это работает на системе UNIX, приведены в главе 8).

  Фактическое обращение к функции fopen в программе имеет вид:

      fp = fopen( name, mode);

  Первым аргументом функции fopen является "имя" файла, которое задается в виде символьной строки. Второй аргумент mode ("режим") также является символьной строкой, которая указывает, как этот файл будет использоваться. Допустимыми режимами являются: чтение ("r"), запись ("w") и добавление ("a").

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

  Другой необходимой вещью является способ чтения или записи, если файл уже открыт. Здесь имеется несколько возможностей, из которых getc и putc являются простейшими.функция getc возвращает следующий символ из файла; ей необходим указатель файла, чтобы знать, из какого файла читать. Таким образом,

      c=getc(fp)

  помещает в "C" следующий символ из файла, указанного посредством fp, и EOF, если достигнут конец файла.

  Функция putc, являющаяся обращением к функции getc,

      putc(c,fp)

  помещает символ "C" в файл fp и возвращает "C". Подобно функциям getchar и putchar, getc и putc могут быть макросами, а не функциями.

  При запуске программы автоматически открываются три файла, которые снабжены определенными указателями файлов. Этими файлами являются стандартный ввод, стандартный вывод и стандартный вывод ошибок; соответствующие указатели файлов называются stdin, stdout и stderr. Обычно все эти указатели связаны с терминалом, но stdin и stdout могут быть перенаправлены на файлы или в поток (pipe), как описывалось в разделе 7.2.

  Функции getchar и putchar могут быть определены в терминалах getc, putc, stdin и stdout следующим образом:

       #define getchar() getc(stdin)
       #define putchar(с) putc(с, stdout)

  При работе с файлами для форматного ввода и вывода можно использовать функции fscanf и fprintf. Они идентичны функциям scanf и printf, за исключением того, что первым аргументом является указатель файла, определяющий тот файл, который будет читаться или куда будет вестись запись; управляющая строка будет вторым аргументом.

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

       #include <stdio.h>
       main(argc, argv) /*cat: concatenate files*/
       int argc;
       char *argv[];
       {
              FILE *fp, *fopen();

              if(argc==1) /*no args; copy standard input*/
                      filecopy(stdin);
              else
                      while (--argc > 0)
                              if ((fp=fopen(*++argv,"r"))==NULL) {
                                      printf("cat:can't open %\n",*argv);
                                      break;
                              } else {
                                      filecopy(fp);
                                      fclose(fp);
                              }
       }

       filecopy(fp) /*copy file fp to standard output*/
       FILE *fp;
       {
       int c;
              while ((c=getc(fp)) !=EOF)
                      putc(c, stdout);
       }

  Указатели файлов stdin и stdout заранее определены в библиотеке ввода-вывода как стандартный ввод и стандартный вывод; они могут быть использованы в любом месте, где можно использовать об'ект типа FILE*. Они, однако, являются константами, а не переменными, так что не пытайтесь им что-либо присваивать.

  Функция fclose является обратной по отношению к fopen; она разрывает связь между указателем файла и внешним именем, установленную функцией fopen, и высвобождает указатель файла для другого файла.большинство Операционных систем имеют некоторые ограничения на число одновременно открытых файлов, которыми может распоряжаться программа. Поэтому, то как мы поступили в cat, освободив не нужные нам более об'екты, является хорошей идеей. Имеется и другая причина для применения функции fclose к выходному файлу - она вызывает выдачу информации из буфера, в котором putc собирает вывод. (при нормальном завершении работы программы функция fclose вызывается автоматически для каждого открытого файла).

  ## Обработка ошибок - stderr и exit.

  Обработка ошибок в сат неидеальна. Неудобство заключается в том, что если один из файлов по некоторой причине оказывается недоступным, диагностическое сообщение об этом печатается в конце об'единенного вывода. Это приемлемо, если вывод поступает на терминал, но не годится, если вывод поступает в некоторый файл или через поточный (pipeline) механизм в другую программу.

  Чтобы лучше обрабатывать такую ситуацию, к программе точно таким же образом, как stdin и stdout, присоединяется второй выходной файл, называемый stderr. Если это вообще возможно, вывод, записанный в файле stderr, появляется на терминале пользователя, даже если стандартный вывод направляется в другое место.

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

       #include <stdio.h>
       main(argc,argv) /*cat: concatenate files*/
       int argc;
       char *argv[];
       {
              FILE *fp, *fopen();

              if(argc==1) /*no args; copy standard input*/
                      filecopy(stdin);
              else
                      while (--argc > 0)
                              if((fp=fopen(*++argv,"r#))==NULL) {
                                      printf(stderr,
                                        "cat: can't open,%s\n", argv);
                                      exit(1);
                              } else {
                                      filecopy(fp);
                              }
              exit(0);
       }

  Программа сообщает об ошибках двумя способами. Диагностическое сообщение, выдаваемое функцией fprintf, поступает в stderr и, таким образом, оказывается на терминале пользователя, а не исчезает в потоке (pipeline) или в выходном файле.

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

  Функция exit вызывает функцию fclose для каждого открытого выходного файла, с тем чтобы вывести всю помещенную в буферы выходную информацию, а затем вызывает функцию _exit. Функция _exit приводит к немедленному завершению без очистки каких-либо буферов; конечно, при желании к этой функции можно обратиться непосредственно.

  ## Ввод и вывод строк.

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

       fgets(line, maxline, fp)

  следующая строка ввода (включая символ новой строки) считывается из файла fp в символьный массив line; самое большое maxline_1 символ будет прочитан. Результирующая строка заканчивается символом \ 0. Нормально функция fgets возвращает line; в конце файла она возвращает NULL. (Наша функция getline возвращает длину строки, а при выходе на конец файла - нуль).

  Предназначенная для вывода функция fputs записывает строку (которая не обязана содержать символ новой строки) в файл:

       fputs(line, fp)

  Чтобы показать, что в функциях типа fgets и fputs нет ничего таинственного, мы приводим их ниже, скопированными непосредственно из стандартной библиотеки ввода-вывода:

       #include <stdio.h>
       char *fgets(s,n,iop) /*get at most n chars from iop*/
       char *s;
       int n;
       register FILE *iop;
       {
              register int c;
              register char *cs;

              cs = s;
              while(--n>0&&(c=getc(iop)) !=EOF)
                      if ((*cs++ = c)=='\n')
                              break;
              *cs = '\0';
              return((c==EOF && cs==s) ? NULL : s);
       }

       fputs(s,iop) /*put string s on fils iop*/
       register char *s;
       register FILE *iop;
       {
              register int c;
              while (c = *s++)
                      putc(c,iop);
       }

  Упражнение 7-3.
    Напишите программу сравнения двух файлов, которая будет печатать первую строку и позицию символа, где они различаются.

  Упражнение 7-4.
    Переделайте программу поиска заданной комбинации символов из главы 5 таким образом, чтобы в качестве ввода использовался набор именованных файлов или, если никакие файлы не указаны как аргументы, стандартный ввод. Следует ли печатать имя файла при нахождении подходящей строки?

  Упражнение 7-5.
    Напишите программу печати набора файлов, которая начинает каждый новый файл с новой страницы и печатает для каждого файла заголовок и счетчик текущих страниц.

  ## Несколько разнообразных функций

  Стандартная библиотека предоставляет множество разнообразных функций, некоторые из которых оказываются особенно полезными. Мы уже упоминали функции для работы со строками: strlen, strcpy, strcat и strcmp. Вот некоторые другие.

  ### Проверка вида символов и преобразования.

  Некоторые макросы выполняют проверку символов и преобразования:

  - isalpha(c) не 0, если "c" алфавитный символ, 0 - если нет.
  - isupper(c) не 0, если "c" буква верхнего регистра, 0 - если нет.
  - islower(c) не 0, если "c" буква нижнего регистра, 0 - если нет.
  - isdigit(c) не 0, если "c" цифра, 0 - если нет.
  - isspacl(c) не 0, если "c" пробел, табуляция или новая строка, 0 - если нет.
  - toupper(c) преобразует "c" в букву верхнего регистра.
  - tolower(c) преобразует "c" в букву нижнего регистра.

  ### Функция ungetc.

  Стандартная библиотека содержит довольно ограниченную версию функции ungetch, написанной нами в главе 4; она называется ungetc. В результате обращения

       ungetc(c,fp)

  символ "c" возвращается в файл fp. Позволяется возвращать в каждый файл только один символ. Функция ungetc может быть использована в любой из функций ввода и с макросами типа scanf, getc или getchar.

  ### Обращение к системе.

  Функция system(s) выполняет команду, содержащуюся в символьной строке s, и затем возобновляет выполнение текущей программы. Содержимое s сильно зависит от используемой операционной системы. В качестве тривиального примера, укажем, что на системе UNIX строка

       system("date");

  приводит к выполнению программы date, которая печатает дату и время дня.

  ### Управление памятью.

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

       calloc(n, sizeof(objcct))

  возвращается либо указатель пространства, достаточного для размещения n об'ектов указанного размера, либо NULL, если запрос не может быть удволетворен. Отводимая память инициализируется нулевыми значениями.

  Указатель обладает нужным для рассматриваемых об'ектов выравниванием, но ему следует приписывать соответствующий тип, как в

       char *calloc();
       int *ip;
       ip=(int*) calloc(n,sizeof(int));

  Функция cfree(р) освобождает пространство, на которое указывает "p", причем указатель "p" певоначально должен быть получен в результате обращения к calloc. Здесь нет никаких ограничений на порядок освобождения пространства, но будет неприятнейшей ошибкой освободить что-нибудь, что не было получено обращением к calloc.

  Реализация программы распределения памяти, подобной calloc, в которой размещенные блоки могут освобождаться в произвольном порядке, продемонстрирована в главе 8.