В этой статье мы узнаем, как считывать данные из файлов и записывать информацию в файлы в программах си. Файлы в си используются для того, чтобы сохранять результат работы программы си и использовать его при новом запуске программы . Например можно сохранять результаты вычислений , статистику игр.
Чтобы работать с файлами в си необходимо подключить библиотеку stdio.h
#include
Чтобы работать с файлом в си необходимо задать указатель на файл по образцу
FILE *имя указателя на файл;
Например
FILE *fin;
Задает указатель fin на файл
Дальше необходимо открыть файл и привязать его к файловому указателю. Для открытия файла в си на чтение используется команда
Имя указателя на файл= fopen(«путь к файлу», «r»);
Например следующая команда
fin = fopen(«C:\Users\user\Desktop\data.txt», «r»);
откроет файл data.txt, находящийся на рабочем столе по пути C:UsersuserDesktop Чтобы узнать путь к файлу можно выбрать файл мышью нажать на правую кнопку мыши и выбрать свойства файла. В разделе Расположение будет указан путь к файлу. Обратите внимание , что в си путь указывается с помощью двух слешей.
Структура и порядок выполнения программы. #Include. iostream. using namespace.
После работы с файлом в си , необходимо его закрыть с помощью команды
fclose(имя указателя на файл)
Считывание информации из текстового файла в Си
Чтобы можно было считывать русские символы из файла, необходимо настроить работу с Кириллицей с помощью команды
setlocale(LC_ALL, «Russian»);
При этом необходимо в начале программы подключить #include
Оператор fscanf()
Для считывания слова из файла в си используется команда fscanf(). Эта команда аналогична команде ввода информации с клавиватуры в си scanf() только первый параметр это указатель на файл
fscanf(указатель на файл,»%формат ввода данных1% форматввода данных2…»,переменная2…);
Например команда
fscanf(fin,»%d%d%d»,b,
считает из файла, который привязан к указателю на файл fin строку из трех целочисленных переменных
Разберем пример программы, которая считывает из текстового файла data.txt в которые записаны три столбца цифр информацию и записывает ее в массивы. Для каждого столбца информации свой массив. Подробно о работе с массивами в Си.
#include
#include
main()
< int a[10];
int b[10];
int c[10];
int i;
// определяем указатель на файл
FILE *fin;
// открываем файл на чтение
fin = fopen(«C:\Users\user\Desktop\data.txt», «r»);
// построчное считывание из файла
for (i=0;i <3;i++)
// считывание строки из трех значений файла и запись в массивы
fscanf(fin,»%d%d%d»,b[i],
>
// вывод массивов на экран
for (i=0;i <3;i++)
printf(«%d %d %dn»,a[i],b[i],c[i]);
>
getch();
// закрытие файла
fclose(fin);
Работа с файлами с++. Чтение из файла с++ ifstream. Изучение С++ для начинающих. Урок #116
>
Построковое считывание информации из файла в СИ.Функция fgets ( )
Оператор fscanf() считывает из файла слово , т.е. до первого встречного пробела.
Чтобы считать из файла всю строку из файла в Си используется конструкция
if ( NULL != fgets (строковая переменная, длина строки, указатель на файл ) )
действия при считывании строки
>
Например программа на Си которая считывает две строки из файла и выводит их на экран
#include
#include
#include
main()
// задаем строковые перменные
char st1[100];
char st2[100];
//определяем указатель на файл
FILE *fin;
// настриваем работу с Кириллицей
setlocale(LC_ALL, «Russian»);
// открываем файл на чтение
fin = fopen(«C:\data.txt», «r»);
// считываем первую строку из файла
if ( NULL != fgets ( st1, 100, fin ) )
// выводим строку на экран
printf(«%s «,st1);>
// считываем вторую строку из файла
if ( NULL != fgets ( st2, 100, fin ) )
// выводим строку на экран
printf(«%sn»,st2);>
// закрываем файл на чтение
fclose(fin);
>
Запись информации в текстовый файл в Си
Для записи данных в файл в Си, необходимо открыть файл в режиме записи
Имя указателя на файл= fopen(«путь к файлу», «w»);
Для записи в строку текстового файла используется команда fprnitf(), которая аналогична команде printf() вывод на экран в си только первый параметр это указатель на файл
fprintf (имя указателя на файл,”%формат ввода”, переменные);
Например запись в файл out.txt значение переменной а
a=10;
fout = fopen(«C:\Users\user\Desktop\out.txt», «w»);
fprintf (fout,”%d”, a);
Пример программы на си которая запрашивает два числа и записывает в файл out.txt оба эти числа и их сумму
main()
< int a;
int b;
int c;
FILE *fout;
fout = fopen(«C:\Users\user\Desktop\out.txt», «w»);
printf («введите первое число n»);
scanf(«%d»,
printf («введите второе число n»);
scanf(«%d»,
c=a+b;
fprintf(fout,»%d %d %d»,a,b,c);
getch();
fclose(fout);
>
Вернуться к содержанию
Перейти к уроку Ошибки в программах на си
Источник: itrobo.ru
Чтобы подключить файл в программу на с например iostream необходимо написать
Потоки для работы с текстовыми файлами представляют объекты, для которых не задан режим открытия ios::binary .
Запись в файл
Для записи в файл к объекту ofstream или fstream применяется оператор
#include #include int main() < std::ofstream out; // поток для записи out.open(«hello.txt»); // открываем файл для записи if (out.is_open()) < out out.close(); std::cout
Здесь предполагается, что файла «hello.txt» располагается в одной папке с файлом программы. Данный способ перезаписывает файл заново. Если надо дозаписать текст в конец файла, то для открытия файла нужно использовать режим ios::app :
std::ofstream out(«hello.txt», std::ios::app); if (out.is_open()) < out out.close();
Чтение из файла
Если надо считать всю строку целиком или даже все строки из файла, то лучше использовать встроенную функцию getline() , которая принимает поток для чтения и переменную, в которую надо считать текст:
#include #include #include // для std::getline int main() < std::string line; std::ifstream in(«hello.txt»); // окрываем файл для чтения if (in.is_open()) < while (std::getline(in, line)) < std::cout > in.close(); // закрываем файл >
Также для чтения данных из файла для объектов ifstream и fstream может применяться оператор >> (также как и при чтении с консоли):
#include #include #include struct Point < Point(double x, double y): x, y <> double x; double y; >; int main() < std::vectorpoints< Point, Point, Point>; std::ofstream out(«points.txt»); if (out.is_open()) < // записываем все объекты Point в файл for (const Point out > out.close(); std::vector new_points; std::ifstream in(«points.txt»); // окрываем файл для чтения if (in.is_open()) < double x, y; while (in >> x >> y) < new_points.push_back(Point); > > in.close(); for (const Point std::cout >
Здесь вектор структур Point записывается в файл.
for (const Point>, можно считать последовательно данные в переменные x и y и ими инициализировать структуру.
double x, y; while (in >> x >> y) < new_points.push_back(Point); >
Но стоит отметить, что это ограниченный способ, поскольку при чтении файла поток in использует пробел для отделения одного значения от другого и таким образом считывает эти значения в переменные x и y. Если же нам надо записать и затем считать строку, которая содержит пробелы, и какие-то другие данные, то такой способ, конечно, не сработает.
Источник: metanit.com
Работа с файлами и другими потоками в СиС++
При закрытии программы, область оперативной памяти, в которой работала программа возвращается операционной системе, при этом мы никак не сможем повторно получить эти данные. Если нужно хранить информацию между запусками программы — используем файлы. Под файлом понимается область внешней памяти (жесткого диска), которой в операционной системе присвоено имя.
Поддержка операционной системы состоит в том, что в ней имеются средства: создания, удаления, поиска, открытия/закрытия файлов, а также чтения/записи содержимого файлов. Любой развитый язык программирования содержит средства для организации хранения информации на внешних запоминающих устройствах и доступа к этой информации.
Файлы могут быть текстовыми и двоичными (типизированными). Вид файла определяется способом хранения информации в файле. В любом файле имеется указатель чтения/записи, который можно перемещать специальными функциями. После каждого чтения или записи указатель сдвигается на заданное (при чтении/записи) количество байт. Такой способ доступа называется последовательным.
Текстовый файл можно рассматривать как набор строк произвольной длины, разделенных управляющим символом ‘n’ . Логически текстовый файл представляет собой цепочку байт, имеющую начало и конец. Чтение (или запись) из файла (в файл) ведется байт за байтом от начала к концу. Поток представляет собой дополнительную абстракцию для работы с данными.
Его можно рассматривать как последовательность байтов. Он может перемещать данные в нашу программу (от клавиатуры, из файла, сети, переменной) или из нашей программы (в консоль, файл, сеть). Мы можем перенаправлять потоки в файлы. Такой механизм поддерживается уже на уровне операционной системы.
2.1 Работа с файлами в Си
- fscanf/fprintf используются для форматированного ввода/вывода при работе с текстовыми файлами. Описаны эти функции с библиотеке stdio.h ( cstdio ) и являются аналогами функций scanf и printf, которые, в свою очередь используются для ввода с клавиатуры и вывода на экран;
- fread/fwrite для чтения/записи бинарных файлов
2.2 Работа с файлами и потоками в C++
Существует четыре стандартных потока: cout, cerr, clog для вывода, и cin для ввода. Чтобы работать с потоками, нужно включить заголовочный файл iostream. Так что для любого консольного приложения, нужно добавить следующую строчку:
Частью стандартной библиотеки С++ является библиотека iostream, которая реализована как иерархия классов и обеспечивает базовые возможности ввода/вывода. Ввод с клавиатуры, называемый стандартным вводом, “привязан” к предопределенному объекту cin. Вывод на монитор, или стандартный вывод, привязан к объекту cout.
Основным отличием файлового ввод/вывода является то, что ввод/вывод выполнятся не с клавиатуры и на экран, а из файла и в файл. Для организации файлового ввода/вывода достаточно создать собственные объекты, которые можно использовать аналогично cin и cout. Для работы с файлами с использованием потокового ввода-вывода необходимо подключить заголовочный файл . В этом файле определены несколько классов и подключены заголовочные файлы – файловый ввод и – файловый вывод.
Например, необходимо создать текстовый файл и записать в него строку «Скоро Новый год!». Для этого необходимо проделать следующие шаги:
создать объект класса ofstream;
связать этот объект с файлом, в который будет производиться запись;
записать строку в файл;
закрыть файл.
Например, создаём объект fout для записи в файл:
ofstream out ; // объект класса ofstream
Объект создан, связываем его с файлом, в который планируется записать строку:
out.open(«out.txt»); // связываем объект с файлом
Указанный файл будет создан в текущей директории. Если файл с таким именем существует, то существующий файл будет заменен новым. Итак, файл открыт, записываем в него нужную строку:
Так как больше нет необходимости изменять содержимое файла, его нужно закрыть, то есть отделить объект от файла.
out.close (); // закрываем файл
Шаги по созданию объекта и связыванию его с файлом можно объединить:
Объединим весь код и получим следующую программу.
#include using namespace std; int main( ) < ofstream out(«out.txt»); // создаём объект out
При считывании данных из файла может произойти ситуация достижения конца файла (end of file, сокращенно EOF). После достижения конца файла никакое чтение из файла невозможно. Для того чтобы проверить состояние файла, необходимо вызвать метод eof(). Данный метод возвращает true, если конец файла достигнут или false, если не достигнут. Например, в файле в текстовом файле File.txt хранится последовательность целых чисел, необходимо их считать и найти сумму:
ifstream in; in.open(«C:\File.txt»); int k; int s = 0; while (!in.eof()) < in >> k; s= s+k; >
Кроме того, состояние файлового потока можно проверить, если просто использовать в качестве условия результат, возвращаемой операцией считывания. Если считывание было удачным, то результат считается истиной, а если неудачным – ложью:
ifstream in(«C:\File.txt»); int k; int s = 0; while (in >> k) s= s+k;
Организацию считывания файла построчно (считая, что строка заканчивается символом перехода на новую строку) продемонстрируем на примере кодирования файла путем замены кода символа следующим кодом из таблицы ASCII :
#include #include #include using namespace std; int main() < ifstream in(«C:\in.txt»); ofstream out; out.open(«C:\out.txt»); char line[255];//Буферная переменная int c; if (!in.is_open()) // если файл не открыт cout out.close(); > >
Пример входного файла
До этого мы уже затрагивали тему ввода-вывода, но раньше данные считывались с клавиатуры и выводились в консоль. Теперь мы поговорим о чтении данных с файлов и вывода в такие же файлы. Мы тут не будем говорить о работе со структурой FILE (как это делалось в языке Си), речь пойдет о файловых потоках:
- Стандартный поток ввода — stdin;
- Стандартный поток вывода — stdout;
- Стандартный поток ошибок, этакий error_log — stderr;
Начнем с практики — программа считывающая из input.txt и записывающая в output.txt :
#include #include #include // две новые библиотеки, нужны для работы freopen using namespace std; int d[1000000], n; /* переменные, инициализированные до функции main, считаются глобальными т.е. изначально равны нулю и могут быть вызваны в любой части программы. Рекомендую создавать массивы глобальными всегда. */ int sum (int l, int r) < int ans = 0; n = r — l + 1; for (int i = l, j = 1; i int main() < freopen («input.txt», «r», stdin); freopen («output.txt», «w», stdout); int a, b; cin >> a >> b; cout
В этом примере работа с файлами идет через стандартные потоки ввода/вывода, но для того, чтобы перенаправить их в файл используется функция freopen . Константы «r» и «w» задают режимы работы с файлом. Всего есть 6 режимов:
1) Считывание, или «r» , от слова read . Используется для потока ввода. Для считывания файл должен существовать.
2) Запись, или «w» , от английского write . Используется для потока вывода. Если файла не существует, то он будет создан, иначе — перезаписан.
3) Добавление, или «a» , от слова append . Используется для вывода, отличается от «w» тем, что продолжает записывать в файл, а не очищает его.
4,5,6) Те же моды, с разницей в том, что их можно использовать и для ввода, и для вывода. Вот сами моды «r+» , «w+» , «a+» .
Так же для считывания можно использовать функции ifstream и ofstream , которые находятся в библиотеке .
ifstream считывает с заданного файла. ofstream выводит в заданный файл.
Теперь о том как их написать:
ifstream название_функции_ввода («название_файла_ввода»);
ofstream название_функции_вывода («название_файла_вывода»);
Пример той же программы с использованием функций библиотеки fstream :
#include using namespace std; int d[1000000], n; int sum (int l, int r) < int ans = 0; n = r — l + 1; for (int i = l, j = 1; i int main() < ifstream read_file («input.txt»); ofstream write_file («output.txt»); /* для считывания с файла input.txt мы будем использовать функцию read_file, можете заменить ее на что-нибудь другое */ int a, b; read_file >> a >> b; write_file
Стоит отметить, что ifstream использует режим «a» , а ofstream — режим «w» . Можно открыть сколько угодно файлов, главное дать уникальное имя для функций ввода.
Для закрытия считывания или записи используйте функцию .close() :
Источник: pro-prof.com