Последнее обновление: 31.10.2015
Для работы с каталогами в пространстве имен System.IO предназначены сразу два класса: Directory и DirectoryInfo .
Класс Directory предоставляет ряд статических методов для управления каталогами. Некоторые из этих методов:
CreateDirectory(path) : создает каталог по указанному пути path
Delete(path) : удаляет каталог по указанному пути path
Exists(path) : определяет, существует ли каталог по указанному пути path. Если существует, возвращается true , если не существует, то false
GetDirectories(path) : получает список каталогов в каталоге path
GetFiles(path) : получает список файлов в каталоге path
Move(sourceDirName, destDirName) : перемещает каталог
GetParent(path) : получение родительского каталога
Данный класс предоставляет функциональность для создания, удаления, перемещения и других операций с каталогами. Во многом он похож на Directory. Некоторые из его свойств и методов:
Create() : создает каталог
CreateSubdirectory(path) : создает подкаталог по указанному пути path
Delete() : удаляет каталог
Свойство Exists : определяет, существует ли каталог
GetDirectories() : получает список каталогов
GetFiles() : получает список файлов
MoveTo(destDirName) : перемещает каталог
Свойство Parent : получение родительского каталога
Свойство Root : получение корневого каталога
Посмотрим на примерах применение этих классов
Обратите внимание на использование слешей в именах файлов. Либо мы используем двойной слеш: "C:\\" , либо одинарный, но тогда перед всем путем ставим знак @: @"C:\Program Files"
Вначале проверяем, а нету ли такой директории, так как если она существует, то ее создать будет нельзя, и приложение выбросит ошибку. В итоге у нас получится следующий путь: "C:\SomeDir\program\avalon"
Если мы просто применим метод Delete к непустой папке, в которой есть какие-нибудь файлы или подкаталоги, то приложение нам выбросит ошибку. Поэтому нам надо передать в метод Delete дополнительный параметр булевого типа, который укажет, что папку надо удалять со всем содержимым:
String dirName = @"C:\SomeFolder"; try { DirectoryInfo dirInfo = new DirectoryInfo(dirName); dirInfo.Delete(true); Console.WriteLine("Каталог удален"); } catch (Exception ex) { Console.WriteLine(ex.Message); }
String dirName = @"C:\SomeFolder"; Directory.Delete(dirName, true);
При перемещении надо учитывать, что новый каталог, в который мы хотим перемесить все содержимое старого каталога, не должен существовать.
Работа файлового ввода/вывода в C++ почти аналогична работе обычных (но с небольшими нюансами).
Есть три основных класса файлового ввода/вывода в C++ :
ofstream (является дочерним классу );
fstream (является дочерним классу iostream).
С помощью этих классов можно выполнять однонаправленный файловый ввод, однонаправленный файловый вывод и двунаправленный файловый ввод/вывод. Для их использования нужно всего лишь подключить fstream.
В отличие от потоков cout, cin, cerr и clog, которые сразу же можно использовать, файловые потоки должны быть явно установлены программистом. То есть, чтобы открыть файл для чтения и/или записи, нужно создать объект соответствующего класса файлового ввода/вывода, указав имя файла в качестве параметра. Затем, с помощью операторов вставки (<<) или извлечения (>>), можно записывать данные в файл или читать содержимое файла. После этого финал — нужно закрыть файл: явно вызвать метод close() или просто позволить файловой переменной ввода/вывода выйти из области видимости ( файлового класса ввода/вывода закроет этот файл автоматически вместо нас).
Для записи в файл используется класс ofstream . Например:
#include
#include #include #include int main () using namespace std ; // ofstream используется для записи данных в файл // Создаём файл SomeText.txt ofstream outf ("SomeText.txt" ) ; // Если мы не можем открыть этот файл для записи данных в него if (! outf ) // То выводим сообщение об ошибке и выполняем exit() cerr << << endl ; exit (1 ) ; // Записываем в файл следующие две строчки outf << "See line #1!" << endl ; outf << "See line #2!" << endl ; return 0 ; // Когда outf выйдет из области видимости, то деструктор класса ofstream автоматически закроет наш файл |
Если вы загляните в каталог вашего проекта (ПКМ по вкладке с названием вашего.cpp файла в Visual Studio > «Открыть содержащую папку» ), то увидите файл с именем SomeText.txt, в котором находятся следующие строчки:
See line #1!
See line #2!
Обратите внимание, мы также можем использовать метод put()
для записи одного символа в файл.
#include
#include #include #include #include int main () using namespace std ; // ifstream используется для чтения содержимого файла // Если мы не можем открыть этот файл для чтения его содержимого if (! inf ) // То выводим следующее сообщение об ошибке и выполняем exit() cerr << << endl ; exit (1 ) ; // Пока есть данные, которые мы можем прочитать while (inf ) // То перемещаем эти данные в строку, которую затем выводим на экран string strInput ; inf >> strInput ; cout << strInput << endl ; return 0 ; // Когда inf выйдет из области видимости, то деструктор класса ifstream автоматически закроет наш файл |
See
line
#1!
See
line
#2!
Хм, это не совсем то, что мы хотели. Как мы уже знаем из предыдущих уроков, оператор извлечения работает с «отформатированными данными», т.е. он игнорирует все пробелы, символы табуляции и символ новой строки. Чтобы прочитать всё содержимое как есть, без его разбивки на части (как в примере выше), нам нужно использовать метод getline() :
#include
#include #include #include #include int main () using namespace std ; // ifstream используется для чтения содержимого файлов ifstream inf ("SomeText.txt" ) ; // Если мы не можем открыть файл для чтения его содержимого if (! inf ) // То выводим следующее сообщение об ошибке и выполняем exit() cerr << "Uh oh, SomeText.txt could not be opened for reading!" << endl ; exit (1 ) ; while (inf ) string strInput ; getline (inf , strInput ) ; cout << strInput << endl ; return 0 ; // Когда inf выйдет из области видимости, то деструктор класса ifstream автоматически закроет наш файл |
Результат выполнения программы выше:
Вывод в C++ может быть буферизован. Это означает, что всё, что выводится в файловый поток, не может сразу же быть записанным на диск (в конкретный файл). Это сделано, в первую очередь, по соображениям производительности. Когда данные буфера записываются на диск, то это называется очисткой буфера . Одним из способов очистки буфера является закрытие файла. В таком случае всё содержимое буфера будет перемещено на диск, а затем файл будет закрыт.
Буферизация вывода обычно не является проблемой, но, при определённых обстоятельствах, она может вызвать проблемы у неосторожных новичков. Например, когда в буфере хранятся данные и программа преждевременно завершает своё выполнение (либо в результате сбоя, либо путём вызова ). В таких случаях деструкторы классов файлового ввода/вывода не выполняются, файлы никогда не закрываются, буферы не очищаются и наши данные теряются навсегда. Вот почему хорошей идеей является явное закрытие всех открытых файлов перед вызовом exit().
Также буфер можно очистить вручную, используя метод ostream::flush() или отправив std::flush в выходной поток. Любой из этих способов может быть полезен для обеспечения немедленной записи содержимого буфера на диск в случае сбоя программы.
Интересный нюанс
: Поскольку std::endl; также очищает выходной поток, то его чрезмерное использование (приводящее к ненужным очисткам буфера) может повлиять на производительность программы (так как очистка буфера в некоторых случаях может быть затратной операцией). По этой причине программисты, которые заботятся о производительности своего кода, часто используют \n вместо std::endl для вставки символа новой строки в выходной поток, дабы избежать ненужной очистки буфера.
Что произойдёт, если мы попытаемся записать данные в уже существующий файл? Повторный запуск программы выше (самая первая) показывает, что исходный файл полностью перезаписывается при повторном запуске программы. А что, если нам нужно добавить данные в конец файла? Оказывается, файлового потока принимают необязательный второй параметр, который позволяет указать программисту способ открытия файла. В качестве этого параметра можно передавать следующие флаги (которые находятся в классе ios):
app - открывает файл в режиме добавления;
ate - переходит в конец файла перед чтением/записью;
binary - открывает файл в бинарном режиме (вместо текстового режима);
in - открывает файл в режиме чтения (по умолчанию для ifstream);
out - открывает файл в режиме записи (по умолчанию для ofstream);
trunc - удаляет файл, если он уже существует.
Можно указать сразу несколько флагов путём использования .
ifstream по умолчанию работает в режиме ios::in;
ofstream по умолчанию работает в режиме ios::out;
fstream по умолчанию работает в режиме ios::in ИЛИ ios::out, что означает, что вы можете выполнять как чтение содержимого файла, так и запись данных в файл.
Теперь давайте напишем программу, которая добавит две строки в ранее созданный файл SomeText.txt:
#include
#include #include #include int main () using namespace std ; // Передаём флаг ios:app, чтобы сообщить fstream, что мы собираемся добавить свои данные к уже существующим данным файла, // мы не собираемся перезаписывать файл. Нам не нужно передавать флаг ios::out, // поскольку ofstream по умолчанию работает в режиме ios::out ofstream outf ("SomeText.txt" , ios :: app ) ; // Если мы не можем открыть файл для записи данных if (! outf ) // То выводим следующее сообщение об ошибке и выполняем exit() cerr << "Uh oh, SomeText.txt could not be opened for writing!" << endl ; exit (1 ) ; |
В этой статье мы узнаем, как считывать данные из файлов и записывать информацию в файлы в программах си. Файлы в си
используются для того, чтобы сохранять результат работы программы си и использовать его при новом запуске программы. Например можно сохранять результаты вычислений, статистику игр.
Чтобы работать с файлами в си необходимо подключить библиотеку stdio.h
#include
Чтобы работать с файлом в си
необходимо задать указатель на файл по образцу
FILE *имя указателя на файл;
Например
FILE *fin;
Задает указатель fin на файл
Дальше необходимо открыть файл и привязать его к файловому указателю. Для открытия файла в си на чтение используется команда
Имя указателя на файл= fopen("путь к файлу", "r");
Например следующая команда
fin = fopen("C:\\Users\\user\\Desktop\\data.txt", "r");
откроет файл data.txt, находящийся на рабочем столе по пути C:\\Users\\user\\Desktop Чтобы узнать путь к файлу можно выбрать файл мышью нажать на правую кнопку мыши и выбрать свойства файла. В разделе Расположение будет указан путь к файлу. Обратите внимание, что в си путь указывается с помощью двух слешей.
После работы с файлом в си, необходимо его закрыть с помощью команды
fclose(имя указателя на файл)
Чтобы можно было считывать русские символы из файла, необходимо настроить работу с Кириллицей с помощью команды
setlocale(LC_ALL, "Russian");
При этом необходимо в начале программы подключить #include
Для считывания слова из файла в си
используется команда fscanf(). Эта команда аналогична команде ввода информации с клавиватуры только первый параметр это указатель на файл
fscanf(указатель на файл,"%формат ввода данных1% форматввода данных2…",&перменная1,&переменная2…);
Например команда
fscanf(fin,"%d%d%d",&a,&b,&c);
считает из файла, который привязан к указателю на файл fin строку из трех целочисленных переменных
Разберем пример программы, которая считывает из текстового файла data.txt в которые записаны три столбца цифр информацию и записывает ее в массивы. Для каждого столбца информации свой массив. Подробно о .
#include
#include
main()
{ int a;
int b;
int c;
int i;
// определяем указатель на файл
FILE *fin;
// открываем файл на чтение
fin = fopen("C:\\Users\\user\\Desktop\\data.txt", "r");
// построчное считывание из файла
for (i=0;i<3;i++)
{
// считывание строки из трех значений файла и запись в массивы
fscanf(fin,"%d%d%d",&a[i],&b[i],&c[i]);
}
// вывод массивов на экран
for (i=0;i<3;i++)
{
printf("%d %d %d ",a[i],b[i],c[i]);
}
getch();
// закрытие файла
fclose(fin);
}
Оператор fscanf()
считывает из файла слово, т.е. до первого встречного пробела.
Чтобы считать из файла всю строку из файла в Си используется конструкция
if (NULL != fgets (строковая переменная, длина строки, указатель на файл))
{
действия при считывании строки
}
Например программа на Си которая считывает две строки из файла и выводит их на экран
#include
#include
#include
main()
{
// задаем строковые перменные
char st1;
char st2;
//определяем указатель на файл
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("%s ",st2);}
// закрываем файл на чтение
fclose(fin);
}
Для записи данных в файл в Си
, необходимо открыть файл в режиме записи
Имя указателя на файл= fopen("путь к файлу", "w");
Для записи в строку текстового файла используется команда fprnitf(), которая аналогична команде в си только первый параметр это указатель на файл
fprintf (имя указателя на файл,”%формат ввода”, переменные);
Например запись в файл out.txt значение переменной а
a=10;
fout = fopen("C:\\Users\\user\\Desktop\\out.txt", "w");
fprintf (fout,”%d”, a);
Пример программы на си которая запрашивает два числа и записывает в файл out.txt оба эти числа и их сумму
#include
#include
main()
{ int a;
int b;
int c;
FILE *fout;
fout = fopen("C:\\Users\\user\\Desktop\\out.txt", "w");
printf ("введите первое число ");
scanf("%d", &a);
printf ("введите второе число ");
scanf("%d", &b);
c=a+b;
fprintf(fout,"%d %d %d",a,b,c);
getch();
fclose(fout);
}
Файлы позволяют пользователю считывать большие объемы данных непосредственно с диска, не вводя их с клавиатуры. Существуют два основных типа файлов: текстовые и двоичные .
Текстовыми называются файлы, состоящие из любых символов. Они организуются по строкам, каждая из которых заканчивается символом «конца строки» . Конец самого файла обозначается символом «конца файла» . При записи информации в текстовый файл, просмотреть который можно с помощью любого текстового редактора, все данные преобразуются к символьному типу и хранятся в символьном виде.
В двоичных файлах информация считывается и записывается в виде блоков определенного размера, в которых могут храниться данные любого вида и структуры.
Для работы с файлами используются специальные типы данных, называемые потоками. Поток ifstream служит для работы с файлами в режиме чтения, а ofstream в режиме записи. Для работы с файлами в режиме как записи, так и чтения служит поток fstream .
В программах на C++ при работе с текстовыми файлами необходимо подключать библиотеки iostream и fstream .
Для того чтобы записывать данные в текстовый файл, необходимо:
Для считывания данных из текстового файла, необходимо:
Как было сказано ранее, для того чтобы начать работать с текстовым файлом, необходимо описать переменную типа ofstream . Например, так:
ofstream F;
Будет создана переменная F для записи информации в файл. На следующим этапе файл необходимо открыть для записи. В общем случае оператор открытия потока будет иметь вид:
F .open («file» , mode );
Здесь F - переменная, описанная как ofstream , file - полное имя файла на диске, mode - режим работы с открываемым файлом. Обратите внимание на то, что при указании полного имени файла нужно ставить двойной слеш. Для обращения, например к файлу accounts.txt, находящемуся в папке sites на диске D , в программе необходимо указать: D:\\sites\\accounts .txt .
Файл может быть открыт в одном из следующих режимов:
Параметр mode может отсутствовать, в этом случае файл открывается в режиме по умолчанию для данного потока.
После удачного открытия файла (в любом режиме) в переменной F будет храниться true , в противном случае false . Это позволит проверить корректность операции открытия файла.
Открыть файл (в качестве примера возьмем файл D:\\sites\\accounts .txt ) в режиме записи можно одним из следующих способов:
После открытия файла в режиме записи будет создан пустой файл, в который можно будет записывать информацию.
Если вы хотите открыть существующий файл в режиме дозаписи, то в качестве режима следует использовать значение ios::app .
После открытия файла в режиме записи, в него можно писать точно так же, как и на экран, только вместо стандартного устройства вывода cout необходимо указать имя открытого файла.
Например, для записи в поток F переменной a , оператор вывода будет иметь вид:
Для последовательного вывода в поток G переменных b , c , d оператор вывода станет таким:
G<
Закрытие потока осуществляется с помощью оператора:
F.close();
В качестве примера рассмотрим следующую задачу.
Создать текстовый файл D:\\sites \\accounts .txt и записать в него n вещественных чисел.
1 |
#include «stdafx.h»
|
Для того чтобы прочитать информацию из текстового файла, необходимо описать переменную типа ifstream . После этого нужно открыть файл для чтения с помощью оператора open . Если переменную назвать F , то первые два оператора будут такими:
После открытия файла в режиме чтения из него можно считывать информацию точно так же, как и с клавиатуры, только вместо cin нужно указать имя потока, из которого будет происходить чтение данных.
Например, для чтения данных из потока F в переменную a , оператор ввода будет выглядеть так:
F>>a;
Два числа в текстовом редакторе считаются разделенными, если между ними есть хотя бы один из символов: пробел, табуляция, символ конца строки. Хорошо, когда программисту заранее известно, сколько и какие значения хранятся в текстовом файле. Однако часто известен лишь тип значений, хранящихся в файле, при этом их количество может быть различным. Для решения данной проблемы необходимо считывать значения из файла поочередно, а перед каждым считыванием проверять, достигнут ли конец файла. А поможет сделать это функция F.eof() . Здесь F - имя потока функция возвращает логическое значение: true или false , в зависимости от того достигнут ли конец файла.
Следовательно, цикл для чтения содержимого всего файла можно записать так:
Для лучшего усвоения материала рассмотрим задачу.
В текстовом файле D:\\game\\accounts.txt хранятся вещественные числа, вывести их на экран и вычислить их количество.
1 |
#include «stdafx.h»
|
На этом относительно объемный урок по текстовым файлам закончен. В следующей статье будут рассмотрены методы манипуляции, при помощи которых в C++ обрабатываются .