Храмцов П.Б. Открытые системы
Подождите немного. Документ загружается.
131
fildes [0]служит для чтения, fildes [1] – для записи. Данные читаются в
том же порядке, в каком были записаны.
При успешном завершении pipe() возвращает 0, при неудаче – -1.
Функция fopen() из группы буферизованного ввода/вывода по сути
аналогична open(), только вместо файлового дескриптора в качестве
результата возвращается указатель на объект, служащий для управления
сформированным потоком (в случае неудачи результат равен пустому
указателю NULL).
Второй аргумент, mode, определяющий допустимые виды
операций ввода/вывода, задается как цепочка символов. Он может
принимать следующие значения.
"r"
Открыть файл на чтение.
"w"
Опустошить или создать файл, открыв его на запись.
"a"
Открыть или создать файл на запись в конец.
"r+"
Открыть файл на изменение (чтение и запись).
"w+"
Опустошить или создать файл, открыв его на изменение.
"a+"
Открыть или создать файл на изменение с записью в конец.
(Стандарт языка C позволяет приписывать к перечисленным
цепочкам символ 'b', который, впрочем, ни на что не влияет.)
Если открытый файл не соответствует интерактивному
устройству, ассоциированный с ним поток полностью буферизуется.
Функция fdopen() формирует поток, ассоциированный с
дескриптором ранее открытого файла.
Второй аргумент, mode, может принимать те же значения, что и
для fopen(), но их трактовка по понятным причинам отличается:
существующие файлы не опустошаются, а новые не создаются.
Функция freopen() предназначена для ассоциирования
существующего потока (третий аргумент, stream) с заданным файлом
(первый аргумент, path) и разрешенными видами операций ввода/вывода
(второй аргумент, mode).
В первую очередь freopen() пытается вытолкнуть буфера потока
stream и закрыть ассоциированный с ним файл. Неудача данного
действия ни на что не влияет.
Затем, аналогично fopen(), открывается заданный файл, только без
формирования нового потока; результатом служит stream (лишенный,
правда, ориентации) или NULL (в случае неудачи).
Если в качестве первого аргумента функции freopen() задан пустой
указатель, делается попытка изменить виды операций, разрешенные для
потока stream. (Формально можно считать, что первым аргументом
132
freopen() служит имя файла, ассоциированного с этим потоком.) От
реализации зависит, разрешены ли подобные действия вообще и при
каких условиях они завершаются успешно.
Для закрытия файлов (точнее, файловых дескрипторов или
потоков) предназначены функции close() и fclose() (см. листинг 5.3).
#include <unistd.h>
int close (int fildes);
#include <stdio.h>
int fclose (FILE *stream);
Листинг 5.3. Описание функций close() и fclose().
Функция close() освобождает файловый дескриптор fildes, который
становится доступным для последующего использования при открытии
файлов.
Когда закрывается последний дескриптор, ссылающийся на
описание открытого файла, оно освобождается.
Если число жестких ссылок на файл равно нулю и закрывается
последний ассоциированный с ним дескриптор, файл перестает быть
доступным, а занимавшееся им пространство освобождается.
Когда закрывается последний дескриптор, ассоциированный с
каналом, все оставшиеся непрочитанными данные теряются.
Функция close() возвращает 0 в случае успешного завершения и -1
при неудаче.
Функция fclose() по сути аналогична, только она освобождает
поток, выталкивая при этом буфера. Признаком успешного завершения
также служит 0, признаком неудачи – константа EOF.
Приведем примеры использования описанных функций.
Сочетание флагов O_CREAT и O_EXCL функции open() позволяет
организовать проверку и создание файлов-замков, для которых важен
факт существования в одном экземпляре, а не содержимое (см. листинг
5.4).
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#define LOCK_FILE "my_lock"
/* Функция пытается создать файл-замок */
/* Результат равен 0 в случае успеха, */
/* 1, если файл уже существует, */
/* -1 в случае прочих ошибок */
static int gate (const char *lock_name) {
int fd;
if ((fd = open (lock_name, O_WRONLY | O_CREAT |
O_EXCL, (mode_t) 0)) < 0) {
if (errno == EEXIST) {
return (1);
133
}
return (-1);
}
return (close (fd));
}
int main (void) {
int res;
if ((res = gate (LOCK_FILE)) > 0) {
perror ("Ошибка при создании файла-замка "
LOCK_FILE);
} else if (res == 1) {
fprintf (stderr, "Файл-замок " LOCK_FILE "
уже существует\n");
}
return (res);
}
Листинг 5.4. Пример программы, использующей функции
open() и close().
Читателю предлагается выполнить приведенную программу
дважды.
Следующая программа иллюстрирует перенаправление
стандартного вывода в файл (см. листинг 5.5). Ее тоже полезно
выполнить дважды и затем самостоятельно осмыслить результаты.
#include <stdio.h>
#define LOGFILE "my_logfile"
int main (void) {
FILE *fp;
printf ("До перенаправления стандартного вывода
в файл " LOGFILE "\n");
if ((fp = freopen (LOGFILE, "a", stdout)) ==
NULL) {
perror ("Не удалось перенаправить стандартный
вывод в файл " LOGFILE);
return (-1);
}
printf ("После перенаправления стандартного
вывода в файл " LOGFILE "\n");
if (fclose (fp) == EOF) {
perror ("Не удалось закрыть файл " LOGFILE);
return (-1);
}
printf ("После закрытия файла " LOGFILE "\n");
return (0);
}
134
Листинг 5.5. Перенаправление стандартного вывода с
помощью функции freopen().
Весьма полезной с практической точки зрения является функция
создания и открытия временных файлов tmpfile() (см. листинг 5.6).
#include <stdio.h>
FILE *tmpfile (void);
Листинг 5.6. Описание функции tmpfile().
Временный файл открывается на изменение (w+) и автоматически
удаляется после закрытия всех ссылок на него.
Использование функции tmpfile() предпочтительнее генерации
«временного» имени с помощью функции tmpnam() и последующего
создания файла с этим именем, поскольку в промежутке какой-либо
другой процесс может создать одноименный файл.
Чтение и запись данных
Чтение данных из файла выполняют функции read() и fread() (см.
листинг 5.7).
#include <unistd.h>
ssize_t read (int fd, void *buf, size_t nbyte);
#include <stdio.h>
size_t fread (void *restrict buf, size_t size,
size_t nitems, FILE *restrict stream);
Листинг 5.7. Описание функций read() и fread().
Функция read() пытается прочитать nbyte байт из файла,
ассоциированного с дескриптором fd, и поместить их в буфер buf.
Для файлов, допускающих позиционирование, read() выполняет
чтение, начиная со значения индикатора текущей позиции,
ассоциированного с дескриптором fd. После завершения операции этот
индикатор увеличивается на количество прочитанных байт. Для
устройств, не поддерживающих позиционирования (таких, например,
как терминал), значение упомянутого индикатора не определено, а
чтение выполняется с текущей позиции устройства.
При успешном завершении read() возвращает количество байт,
реально прочитанных и помещенных в буфер; это значение может
оказаться меньше значения аргумента nbyte, если до конца файла
оставалось меньше, чем nbyte байт. Например, если текущая позиция
совпадала с концом файла, результат будет равен 0. В случае ошибки
возвращается -1.
Функция буферизованного ввода/вывода fread() во многом
аналогична read(), но число читаемых байт задается как произведение
размера одного элемента (аргумент size) на число элементов (аргумент
nitems), а результатом служит количество успешно прочитанных
элементов. В стандарте оговаривается, что элементы читаются побайтно.
Число элементов, успешно прочитанных функцией fread(), может
быть меньше затребованного, только если достигнут конец файла или
произошла ошибка чтения. В таком случае fread() устанавливает для
135
потока индикатор ошибки или конца файла, проверить которые
позволяют функции feof() и ferror(), соответственно (см. листинг 5.8),
возвращая при установленном индикаторе ненулевой результат.
#include <stdio.h>
int feof (FILE *stream);
#include <stdio.h>
int ferror (FILE *stream);
Листинг 5.8. Описание функций feof() и ferror().
Отметим, что использование функции бинарного ввода fread()
ограничивает мобильность приложений, так как результат зависит от
размера элементов и порядка байт, поддерживаемого процессором.
Обратим также внимание на некоторые нюансы синхронного и
асинхронного ввода с помощью функции read(). При попытке чтения из
пустого канала, не открытого кем-либо на запись, результат равен 0 (как
признак конца файла). Если пустой канал открыт кем-либо на запись,
при установленном флаге O_NONBLOCK возвращается -1 (как признак
ошибки EAGAIN); при отсутствии флага O_NONBLOCK процесс (поток
управления) блокируется до появления данных в канале. Аналогичным
образом устроен ввод из файлов других типов, поддерживающих чтение
в асинхронном режиме.
Содержимое символьных ссылок приходится читать особым
образом (хотя бы потому, что обычно функция open() раскрывает их, т.
е. открывает указуемый файл). Для этого служит функция readlink() (см.
листинг 5.9). Она помещает содержимое ссылки с именем link_name в
буфер buf длины buf_size (если буфер мал, остаток содержимого
отбрасывается). Результат равен числу помещенных в буфер байт или -1
в случае неудачи.
#include <unistd.h>
ssize_t readlink (const char *restrict
link_name, char *restrict buf,
size_t buf_size);
Листинг 5.9. Описание функции readlink().
Следующая программа (см. листинг 5.10) переправляет недлинные
сообщения с управляющего терминала процесса (ему соответствует
специальный файл /dev/tty) на стандартный вывод до тех пор, пока не
будет введен символ конца файла.
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#define C_TERM "/dev/tty"
int main (void) {
char buf [BUFSIZ];
int fd;
ssize_t line_len;
136
/* Открытие на чтение специального файла, */
/* ассоциированного с управляющим терминалом */
if ((fd = open (C_TERM, O_RDONLY)) < 0) {
perror ("OPEN");
return (-1);
}
/* Ввод с терминала */
printf ("Вводите строки\n");
while ((line_len = read (fd, buf, BUFSIZ - 1))
> 0) {
buf [line_len] = '\0';
printf ("Вы ввели: %s", buf);
}
if (line_len == -1) {
perror ("READ");
close (fd);
return (-1);
}
return (close (fd));
}
Листинг 5.10. Пример чтения из файла.
В качестве примера мобильного использования функции fread(), а
также функций feof() и ferror(), рассмотрим программу,
подсчитывающую число символов, слов и строк в файле – аргументе
командной строки (см. листинг 5.11).
/* * * * * * * * * * * * * * * * * * * * * */
/* Подсчет символов, слов и строк в файле */
/* * * * * * * * * * * * * * * * * * * * * */
#include <stdio.h>
int main (int argc, char *argv[]) {
long nwords = 0; /* Счетчик слов */
long nlines = 0; /* Счетчик строк */
long nchars = 0; /* Счетчик символов */
FILE *fp = stdin; /* Если файл не задан, */
/* читается стандартный ввод */
unsigned char buf [BUFSIZ]; /* Буфер для */
/* чтения файла */
unsigned char *p1; /* Указатель на */
/* обрабатываемую часть буфера */
size_t nbytes = 0; /* Количество прочитанных,*/
/* но не обработанных байт */
register int c; /* Обрабатываемый символ */
int inword = 0; /* Признак - находимся ли мы */
/* внутри слова */
if (argc > 2) {
137
fprintf (stderr, "Использование: %s [файл]\n",
argv [0]);
return (2);
}
if (argc > 1 && (fp = fopen (argv [1], "r")) ==
NULL) {
perror ("OPEN");
fprintf (stderr, "%s: Не могу открыть файл
%s\n", argv [0], argv[1]);
return (2);
}
p1 = buf;
for (;;) { /* Посимвольная обработка файла */
if (nbytes == 0) { /* Нужно прочитать новую порцию */
if (feof (fp)) {
/* При предыдущем чтении дошли до конца файла */
break;
}
nbytes = fread (p1 = buf, (size_t) 1,
sizeof (buf), fp);
if (ferror (fp)) {
perror ("READ");
fprintf (stderr, "%s: Ошибка чтения из
файла %s:", argv [0],
argc == 1 ? "стандартного ввода" : argv
[1]);
break;
}
if (nbytes == 0) {
/* В файле не оставалось непрочитанных символов */
break;
}
nchars += nbytes;
}
c = *p1++; /* Обработка одного символа */
nbytes--;
if (c > ' ') {
if (!inword) {
nwords++;
inword = 1;
}
continue;
}
if (c == '\n') {
nlines++;
138
} else if (c != ' ' && c != '\t') {
continue;
}
inword = 0;
}
if (argc > 1) {
fclose (fp);
}
printf ("Файл %s: строк: %ld, слов: %ld,
символов: %ld\n",
argc == 1 ? "стандартного ввода" : argv [1],
nlines, nwords, nchars);
return (0);
}
Листинг 5.11. Программа, подсчитывающая число строк, слов
и символов в файле.
Читателю предлагается убрать из цикла проверку feof (fp) и
оценить, как изменится обработка интерактивного стандартного ввода.
Для иллюстрации использования функции readlink() напишем
программу, выдающую на стандартный вывод содержимое символьных
ссылок, имена которых заданы в командной строке (см. листинг 5.12).
#include <unistd.h>
#include <stdio.h>
/* Программа выдает на стандартный вывод */
/* содержимое символьных ссылок - */
/* аргументов командной строки */
int main (int argc, char *argv[]) {
char buf [BUFSIZ];
ssize_t link_len;
int err = 0;
int i;
for (i = 1; i < argc; i++) {
if ((link_len = readlink (argv [i], buf,
sizeof (buf) - 1)) < 0) {
perror ("READLINK");
fprintf (stderr, "%s: Не удалось прочитать содержимое
символьной ссылки %s\n", argv [0], argv [i]);
err = -1;
continue;
}
buf [link_len] = '\0';
printf ("Содержимое символьной ссылки %s -> %s\n", argv [i],
buf);
}
return (err);
139
}
Листинг 5.12. Пример программы, читающей содержимое
символьных ссылок.
Запись данных в файл выполняют функции write() и fwrite() (см.
листинг 5.13).
#include <unistd.h>
ssize_t write (int fildes, const void *buf,
size_t nbyte);
#include <stdio.h>
size_t fwrite (const void *restrict buf,
size_t size, size_t nitems,
FILE *restrict stream);
Листинг 5.13. Описание функций write() и fwrite().
Вероятно, лишь несколько моментов, связанных с функциями
write() и fwrite(), нуждаются в пояснениях. При записи размер файла
может увеличиться. Если файл открыт на добавление, запись
производится в его конец.
При записи в канал, если флаг O_NONBLOCK не установлен,
процесс (поток управления) может быть отложен, но после нормального
завершения функция write() вернет nbyte. При установленном флаге
O_NONBLOCK поведение зависит от значения nbyte и наличия
свободного места в канале. Если nbyte не превосходит константы
PIPE_BUF, запишется все или ничего (в последнем случае результат
будет равен -1). При попытке записать порцию данных большего
размера запишется сколько можно или ничего.
Приведем несколько примеров. Следующая программа (см.
листинг 5.14) выводит приветствие на управляющий терминал.
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#define C_TERM "/dev/tty"
char msg [] = "HELLO !!!\n";
int main (void) {
int fd;
/* Открытие на запись специального файла,
ассоциированного с управляющим терминалом */
if ((fd = open (C_TERM, O_WRONLY)) < 0)
{
perror ("OPEN");
return (-1);
}
/* Вывод на терминал */
if (write (fd, msg, sizeof (msg)) != (ssize_t)
sizeof (msg)) {
perror ("WRITE");
140
return (1);
}
return (close (fd));
}
Листинг 5.14. Пример программы, использующей функцию
write().
Программа prnmyself (см. листинг 5.15) выводит свой собственный
исходный текст. При этом применяется следующий прием: данные
фиксированными порциями читаются из файла и выводятся на
терминал; процесс повторяется до тех пор, пока число реально
прочитанных байт совпадает с указанным (до обнаружения конца
файла).
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#define SOURCE_FILE "prnmyself.c"
#define C_TERM "/dev/tty"
int main (void) {
unsigned char buf [BUFSIZ];
int fdr, fdw; /* Дескрипторы для чтения и записи */
ssize_t nb;
if (((fdr = open (SOURCE_FILE, O_RDONLY)) < 0) ||
((fdw = open (C_TERM, O_WRONLY)) < 0)) {
perror ("OPEN " SOURCE_FILE " or " C_TERM);
return (1);
}
do {
if ((nb = read (fdr, buf, BUFSIZ)) < 0) {
perror ("READ");
break;
}
if (write (fdw, buf, nb) != nb) {
perror ("WRITE");
break;
}
} while (nb == BUFSIZ);
(void) close (fdw);
(void) close (fdr);
return (0);
}
Листинг 5.15. Пример программы, использующей функции
read() и write().