Файловые функции: fopen(), fclose(), fgetc(), fputc()

Практический курс по C/C++: https://stepik.org/course/193691

С этого занятия мы начинаем большую тему по работе с файлами. Думаю, не надо объяснять, что такое файлы, где они располагаются и для чего нужны. Было бы странно видеть человека, который смотрит курс по языку Си и не знает этих базовых вещей. Также, я полагаю, что вы все умеете прописывать абсолютные и относительные пути к файлам. Вот здесь, наверное, надо сказать пару слов. Предположим, у нас с вами имеется следующая структура каталогов и файлов:

с рабочим каталогом "d:/app/". Тогда относительные и абсолютные пути можно к разным файлам можно прописывать следующим образом:

Варианты

"d:\\app\\my_file.txt" и "d:/app/my_file.txt"

представляют собой абсолютный путь к файлу, то есть, полный путь, начиная с указания диска. Причем, обычно используют слеш в качестве разделителя: так короче писать и такой путь будет корректно восприниматься как под ОС Windows, так и Linux.

Для доступа к файлу out.txt пути могут быть записаны как:

"../out.txt"
"d:/out.txt"

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

"../parent/prt.dat"
"d:/parent/prt.dat"

Если вам все это кажется непонятным, почитайте об этом подробнее, а я вернусь непосредственно к языку Си.

Функции fopen() и fclose()

Философия работы с файлами заключается в открытии потока, связанного с тем или иным файлом. Затем, через открытый поток выполняется чтение или запись информации в файл. Что это за поток, какую роль он играет и как его открыть? Начну с последнего. Для открытия потока, связанного с файлом, используется функция:

FILE* fopen(const char* path, const char* mode);

Первый параметр path – это путь к файлу; второй параметр mode – режим доступа к файлу. Как прописывать путь, мы с вами уже знаем, а режимы доступа могут быть следующими:

Все эти режимы для работы именно с текстовыми файлами. Есть еще набор режимов для бинарного доступа файлам:

"rb", "wb", "ab", "rb+", "wb+", "ab+"

То есть, здесь просто добавляется буква "b". В ОС Unix текстовый режим и бинарный работают одинаково. Но в ОС Windows по-разному. Что это за режим и как с ним работать мы будем говорить позже.

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

Теперь, что из себя представляет файловый поток. Когда отрабатывает функция fopen() она делает системный запрос к ОС на открытие указанного файла. ОС выполняет необходимые действия и в случае успеха возвращает дескриптор файлового потока. Дополнительно функция fopen() создает входной буфер, при чтении данных из файла, или выходной, при записи данных в файл, или на чтение и записи одновременно:

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

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

int fclose(FILE* fp);

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

Данная функция возвращает 0, если закрытие файла прошло успешно и -1, если возникли какие-либо ошибки. Правда, обработать эти ошибки мы все равно вряд ли сможем, т.к. они обычно связаны с системными вызовами, а это уже зона действия ОС.

Давайте для примера, посмотрим, как в программе можно открыть файл на запись и закрыть его:

#include <stdio.h>
 
int main(void)
{
    FILE* fp = fopen("my_file.txt", "w");
    if(fp == NULL)
        return 1;
 
    fclose(fp);
 
    return 0;
}

Если все прошло успешно, то в каталоге рядом с файлом lessons.exe появится еще один пустой файл с именем my_file.txt.

Функции fgetc() и fputc()

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

int fgetc(FILE* stream);
int fputc(int ch, FILE* stream);

Первая функция fgetc() позволяет побайтового читать данные из указанного потока stream, а вторая fputc() побайтно записывает данные в поток stream. Причем, в качестве потоков могут быть как файловые, так и стандартные: stdin, stdout. Вообще эти функции работают аналогично функциям getchar() и putchar(), о которых мы с вами уже говорили.

Давайте с помощью функции fputc() запишем в файл небольшую строку:

#include <stdio.h>
 
int main(void)
{
    char str[] = "Function fputc() in action.";
 
    FILE* fp = fopen("my_file.txt", "w");
    if(fp == NULL)
        return 1;
 
    for(int i = 0; str[i]; ++i)
        fputc(str[i], fp);
 
    fclose(fp);
 
    return 0;
}

Если после выполнения программы открыть файл my_file.txt, то увидим в нем искомую строку.

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

#include <stdio.h>
 
int main(void)
{
    char str[] = "Function fputc() in action.";
    char buff[100];
 
    FILE* fp = fopen("my_file.txt", "w");
    if(fp == NULL)
        return 1;
 
    for(int i = 0; str[i]; ++i)
        fputc(str[i], fp);
 
    FILE* in = fopen("my_file.txt", "r");
    if(in == NULL) {
        puts("File open error");
        return 2;
    }
 
    char ch;
    int i = 0;
    while((ch = fgetc(in)) != EOF)
        buff[i++] = ch;
    buff[i] = '\0';
    puts(buff);
 
    fclose(fp);
    return 0;
}

Если сейчас запустить программу, то на экране будет высвечена пустая строка, так как файл my_file.txt пустой. Но, если его закрыть, прежде чем читать из него данные, то строка будет успешно прочитана.

Практический курс по C/C++: https://stepik.org/course/193691

Видео по теме

Язык Си. Рождение легенды

#1. Этапы трансляции программы в машинный код. Стандарты

#2. Установка компилятора gcc и Visual Studio Code на ОС Windows

#3. Структура и понимание работы программы "Hello, World!"

#4. Двоичная, шестнадцатеричная и восьмеричная системы счисления

#5. Переменные и их базовые типы. Модификаторы unsigned и signed

#6. Операция присваивания. Числовые и символьные литералы. Операция sizeof

#7. Стандартные потоки ввода/вывода. Функции putchar() и getchar()

#8. Функция printf() для форматированного вывода

#9. Функция scanf() для форматированного ввода

#10. Арифметические операции: сложение, вычитание, умножение и деление

#11. Арифметические операции деления по модулю, инкремента и декремента

#12. Арифметические операции +=, -=, *=, /=, %=

#13. Булевый тип. Операции сравнения. Логические И, ИЛИ, НЕ

#14. Условный оператор if. Конструкция if-else

#15. Условное тернарное выражение

#16. Оператор switch множественного выбора. Ключевое слово break

#17. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операции

#18. Генерация псевдослучайных чисел. Функции математической библиотеки

#19. Директивы макропроцессора #define и #undef

#20. Директива #define для определения макросов-функций. Операции # и ##

#21. Директивы #include и условной компиляции

#22. Оператор цикла while

#23. Оператор цикла for

#24. Цикл do-while с постусловием. Вложенные циклы

#25. Операторы break, continue и goto

#26. Указатели. Проще простого

#27. Указатели. Приведение типов. Константа NULL

#28. Долгожданная адресная арифметика

#29. Введение в массивы

#30. Вычисление размера массива. Инициализация массивов

#31. Указатели на массивы

#32. Ключевое слово const с указателями и переменными

#33. Операции с массивами копирование, вставка, удаление и сортировка

#34. Двумерные и многомерные массивы. Указатели на двумерные массивы

#35. Строки. Способы объявления, escape-последовательности

#36. Ввод/вывод строк в стандартные потоки

#37. Строковые функции strlen(), strcpy(), strncpy(), strcat(), strncat()

#38. Строковые функции сравнения, поиска символов и фрагментов

#39. Строковые функции sprintf(), atoi(), atol(), atoll() и atof()

#40. Объявление и вызов функций

#41. Оператор return. Вызов функций в аргументах

#42. Прототипы функций

#43. Указатели как параметры. Передача массивов в функции

#44. Указатели на функцию. Функция как параметр (callback)

#45. Стековый фрейм. Автоматические переменные

#46. Рекурсивные функции

#47. Функции с произвольным числом параметров

#48. Локальные и глобальные переменные

#49. Локальные во вложенных блоках

#50. Ключевые слова static и extern

#51. Функции malloc(), free(), calloc(), realloc(), memcpy() и memmove()

#52. Перечисления (enum). Директива typedef

#53. Структуры. Вложенные структуры

#54. Указатели на структуры. Передача структур в функции

#55. Реализация стека (пример использования структур)

#56. Объединения (union). Битовые поля

#57. Файловые функции: fopen(), fclose(), fgetc(), fputc()

#58. Функции perror(), fseek() и ftell()

#59. Функции fputs(), fgets() и fprintf(), fscanf()

#60. Функции feof(), fflush(), setvbuf()

#61. Бинарный режим доступа. Функции fwrite() и fread()

С++. Начало

#1. Первая программа на С++

#2. Ввод-вывод с помощью объектов cin и cout

#3. Пространства имен (namespace)

#4. Оператор using

#5. Новые типы данных. Приведение типов указателей

#6. Инициализация переменных. Ключевые слова auto и decltype

#7. Ссылки. Константные ссылки

#8. Объект-строка string. Операции с объектами класса string

#9. Файловые потоки. Открытие и закрытие файлов. Режимы доступа

#10. Чтение и запись данных в файл в текстовом режиме

#11. Чтение и запись данных в файл в бинарном режиме

#12. Перегрузка функций. Директива extern C

#13. Значения параметров функции по умолчанию

#14. inline-функции

#15. Лямбда-выражения. Объявление и вызов

#16. Захват внешних значений в лямбда выражениях

#17. Структуры в С++, как обновленный тип данных

#18. Структуры. Режимы доступа. Сеттеры и геттеры

#19. Структуры. Конструкторы и деструкторы

#20. Операторы new / delete и new [] / delete []

#21. Особенности работы new и delete

#22. Smart-указатели типа unique_ptr

#23. Smart-указатели типа shared_ptr