Как написать программу для открытия файлов

Большинство компьютерных программ работают с файлами, и поэтому возникает необходимость создавать, удалять, записывать читать, открывать файлы. Что же такое файл? Файл – именованный набор байтов, который может быть сохранен на некотором накопителе.

Ну, теперь ясно, что под файлом понимается некоторая последовательность байтов, которая имеет своё, уникальное имя, например файл.txt . В одной директории не могут находиться файлы с одинаковыми именами. Под именем файла понимается не только его название, но и расширение, например: file.txt и file.dat — разные файлы, хоть и имеют одинаковые названия. Существует такое понятие, как полное имя файлов – это полный адрес к директории файла с указанием имени файла, например: D:docsfile.txt . Важно понимать эти базовые понятия, иначе сложно будет работать с файлами.

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

Файловый ввод/вывод аналогичен стандартному вводу/выводу, единственное отличие – это то, что ввод/вывод выполнятся не на экран, а в файл. Если ввод/вывод на стандартные устройства выполняется с помощью объектов cin и cout , то для организации файлового ввода/вывода достаточно создать собственные объекты, которые можно использовать аналогично операторам cin и cout .

Например, необходимо создать текстовый файл и записать в него строку Работа с файлами в С++ . Для этого необходимо проделать следующие шаги:

1. создать объект класса ofstream ;
2. связать объект класса с файлом, в который будет производиться запись;
3. записать строку в файл;
4. закрыть файл.

Почему необходимо создавать объект класса ofstream , а не класса ifstream ? Потому, что нужно сделать запись в файл, а если бы нужно было считать данные из файла, то создавался бы объект класса ifstream .

// создаём объект для записи в файл ofstream /*имя объекта*/; // объект класса ofstream

Назовём объект – fout , Вот что получится:

ofstream fout;

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

fout.open(«cppstudio.txt»); // связываем объект с файлом

Через операцию точка получаем доступ к методу класса open(), в круглых скобочках которого указываем имя файла. Указанный файл будет создан в текущей директории с программой. Если файл с таким именем существует, то существующий файл будет заменен новым. Итак, файл открыт, осталось записать в него нужную строку. Делается это так:

fout

Используя операцию передачи в поток совместно с объектом fout строка Работа с файлами в С++ записывается в файл. Так как больше нет необходимости изменять содержимое файла, его нужно закрыть, то есть отделить объект от файла.

fout.close(); // закрываем файл

Итог – создан файл со строкой Работа с файлами в С++ .

Шаги 1 и 2 можно объединить, то есть в одной строке создать объект и связать его с файлом. Делается это так:

Уроки Python / Работа с файлами чтение из файлов

ofstream fout(«cppstudio.txt»); // создаём объект класса ofstream и связываем его с файлом cppstudio.txt

Объединим весь код и получим следующую программу.

// file.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include using namespace std; int main(int argc, char* argv[]) < ofstream fout(«cppstudio.txt»); // создаём объект класса ofstream для записи и связываем его с файлом cppstudio.txt fout

Осталось проверить правильность работы программы, а для этого открываем файл cppstudio.txt и смотрим его содержимое, должно быть — Работа с файлами в С++ .

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

1. создать объект класса ifstream и связать его с файлом, из которого будет производиться считывание;
2. прочитать файл;
3. закрыть файл.

// file_read.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include #include using namespace std; int main(int argc, char* argv[]) < setlocale(LC_ALL, «rus»); // корректное отображение Кириллицы char buff[50]; // буфер промежуточного хранения считываемого из файла текста ifstream fin(«cppstudio.txt»); // открыли файл для чтения fin >> buff; // считали первое слово из файла cout

В программе показаны два способа чтения из файла, первый – используя операцию передачи в поток, второй – используя функцию getline() . В первом случае считывается только первое слово, а во втором случае считывается строка, длинной 50 символов. Но так как в файле осталось меньше 50 символов, то считываются символы включительно до последнего. Обратите внимание на то, что считывание во второй раз ( строка 17 ) продолжилось, после первого слова, а не с начала, так как первое слово было прочитано в строке 14 . Результат работы программы показан на рисунке 1.

CppStudio.com

Работа с файлами в С++ Для продолжения нажмите любую клавишу . . .

Рисунок 1 — Работа с файлами в С++

Программа сработала правильно, но не всегда так бывает, даже в том случае, если с кодом всё впорядке. Например, в программу передано имя несуществующего файла или в имени допущена ошибка. Что тогда? В этом случае ничего не произойдёт вообще. Файл не будет найден, а значит и прочитать его не возможно. Поэтому компилятор проигнорирует строки, где выполняется работа с файлом.

В результате корректно завершится работа программы, но ничего, на экране показано не будет. Казалось бы это вполне нормальная реакции на такую ситуацию. Но простому пользователю не будет понятно, в чём дело и почему на экране не появилась строка из файла. Так вот, чтобы всё было предельно понятно в С++ предусмотрена такая функция — is_open() , которая возвращает целые значения: 1 — если файл был успешно открыт, 0 — если файл открыт не был. Доработаем программу с открытием файла, таким образом, что если файл не открыт выводилось соответствующее сообщение.

Результат работы программы показан на рисунке 2.

CppStudio.com

Файл не может быть открыт! Для продолжения нажмите любую клавишу . . .

Рисунок 2 — Работа с файлами в С++

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

Режимы открытия файлов

Режимы открытия файлов устанавливают характер использования файлов. Для установки режима в классе ios_base предусмотрены константы, которые определяют режим открытия файлов (см. Таблица 1).

Таблица 1 — режимы открытия файлов

Константа Описание

ios_base::in	открыть файл для чтения
ios_base::out	открыть файл для записи
ios_base::ate	при открытии переместить указатель в конец файла
ios_base::app	открыть файл для записи в конец файла
ios_base::trunc	удалить содержимое файла, если он существует
ios_base::binary	открытие файла в двоичном режиме

Режимы открытия файлов можно устанавливать непосредственно при создании объекта или при вызове функции open() .

ofstream fout(«cppstudio.txt», ios_base::app); // открываем файл для добавления информации к концу файла fout.open(«cppstudio.txt», ios_base::app); // открываем файл для добавления информации к концу файла

Режимы открытия файлов можно комбинировать с помощью поразрядной логической операции или | , например: ios_base::out | ios_base::trunc — открытие файла для записи, предварительно очистив его.

Объекты класса ofstream , при связке с файлами по умолчанию содержат режимы открытия файлов ios_base::out | ios_base::trunc . То есть файл будет создан, если не существует. Если же файл существует, то его содержимое будет удалено, а сам файл будет готов к записи. Объекты класса ifstream связываясь с файлом, имеют по умолчанию режим открытия файла ios_base::in — файл открыт только для чтения.

Режим открытия файла ещё называют — флаг, для удобочитаемости в дальнейшем будем использовать именно этот термин. В таблице 1 перечислены далеко не все флаги, но для начала этих должно хватить.

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

Разработаем программу, которая, используя операцию sizeof() , будет вычислять характеристики основных типов данных в С++ и записывать их в файл. Характеристики:

1. число байт, отводимое под тип данных
2. максимальное значение, которое может хранить определённый тип данных.

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

/* data type byte max value bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 long int = 4 2147483647.00 unsigned long int = 4 4294967295.00 float = 4 2147483647.00 long float = 8 9223372036854775800.00 double = 8 9223372036854775800.00 */

Такая программа уже разрабатывалась ранее в разделе Типы данных С++ , но там вся информация о типах данных выводилась на стандартное устройство вывода, а нам необходимо программу переделать так, чтобы информация записывалась в файл. Для этого необходимо открыть файл в режиме записи, с предварительным усечением текущей информации файла (строка 14). Как только файл создан и успешно открыт (строки 16 — 20), вместо оператора cout , в строке 22 используем объект fout . таким образом, вместо экрана информация о типах данных запишется в файл.

// write_file.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include #include // работа с файлами #include // манипуляторы ввода/вывода using namespace std; int main(int argc, char* argv[]) < setlocale(LC_ALL, «rus»); // связываем объект с файлом, при этом файл открываем в режиме записи, предварительно удаляя все данные из него ofstream fout(«data_types.txt», ios_base::out | ios_base::trunc); if (!fout.is_open()) // если файл небыл открыт < cout fout << » data type » << «byte» << » » << » max value » << endl // заголовки столбцов << «bool = » << sizeof(bool) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) — 1) << endl << «char = » << sizeof(char) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) — 1) << endl << «short int = » << sizeof(short int) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 — 1) — 1) << endl << «unsigned short int = » << sizeof(unsigned short int) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) — 1) << endl << «int = » << sizeof(int) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 — 1) — 1) << endl << «unsigned int = » << sizeof(unsigned int) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) — 1) << endl << «long int = » << sizeof(long int) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 — 1) — 1) << endl << «unsigned long int = » << sizeof(unsigned long int) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) — 1) << endl << «float = » << sizeof(float) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 — 1) — 1) << endl << «long float = » << sizeof(long float) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long float*/ << (pow(2,sizeof(long float) * 8.0 — 1) — 1) << endl << «double = » << sizeof(double) << » » << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 — 1) — 1) << endl; fout.close(); // программа больше не использует файл, поэтому его нужно закрыть cout

Нельзя не заметить, что изменения в программе минимальны, а всё благодаря тому, что стандартный ввод/вывод и файловый ввод/вывод используются абсолютно аналогично. В конце программы, в строке 45 мы явно закрыли файл, хотя это и не обязательно, но считается хорошим тоном программирования. Стоит отметить, что все функции и манипуляторы используемые для форматирования стандартного ввода/вывода актуальны и для файлового ввода/вывода. Поэтому не возникло никаких ошибок, когда оператор cout был заменён объектом fout .

Источник: cppstudio.com

Как написать программу для открытия файлов

Для работы с файлами в стандартной библиотеке определен заголовочный файл fstream , который определяет базовые типы для чтения и записи файлов. В частности, это:

• ifstream : для чтения с файла
• ofstream : для записи в файл
• fstream : совмещает запись и чтение

Для работы с данными типа wchar_t для этих потоков определены двойники:

• wifstream
• wofstream
• wfstream

Открытие файла

При операциях с файлом вначале необходимо открыть файл с помощью функции open() . Данная функция имеет две версии:

• open(путь)
• open(путь, режим)

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

• ios::in : файл открывается для ввода (чтения). Может быть установлен только для объекта ifstream или fstream
• ios::out : файл открывается для вывода (записи). При этом старые данные удаляются. Может быть установлен только для объекта ofstream или fstream
• ios::app : файл открывается для дозаписи. Старые данные не удаляются.
• ios::ate : после открытия файла перемещает указатель в конец файла
• ios::trunc : файл усекается при открытии. Может быть установлен, если также установлен режим out
• ios::binary : файл открывается в бинарном режиме

Если при открытии режим не указан, то по умолчанию для объектов ofstream применяется режим ios::out , а для объектов ifstream — режим ios::in . Для объектов fstream совмещаются режимы ios::out и ios::in .

std::ofstream out; // поток для записи out.open(«hello1.txt»); // окрываем файл для записи std::ofstream out2; out2.open(«hello2.txt», std::ios::app); // окрываем файл для дозаписи std::ofstream out3; out2.open(«hello3.txt», std::ios::out | std::ios::trunc); // установка нескольких режимов std::ifstream in; // поток для чтения in.open(«hello4.txt»); // окрываем файл для чтения std::fstream fs; // поток для чтения-записи fs.open(«hello5.txt»); // окрываем файл для чтения-записи

Однако в принципе необязательно использовать функцию open для открытия файла. В качестве альтернативы можно также использовать конструктор объектов-потоков и передавать в них путь к файлу и режим открытия:

fstream(путь) fstream(путь, режим)

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

std::ofstream out(«hello.txt»); std::ifstream in(«hello.txt»); std::fstream fs(«hello.txt», std::ios::app);

В данном случае предполагается, что файл «hello.txt» располагается в той же папке, где и файл программы.

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

В процессе работы мы можем проверить, окрыт ли файл с помощью функции is_open() . Если файл открыт, то она возвращает true:

std::ifstream in; // поток для чтения in.open(«hello.txt»); // окрываем файл для чтения // если файл открыт if (in.is_open())

Закрытие файла

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

#include #include int main() < std::ofstream out; // поток для записи out.open(«hello.txt»); // окрываем файл для записи out.close(); // закрываем файл std::ifstream in; // поток для чтения in.open(«hello.txt»); // окрываем файл для чтения in.close(); // закрываем файл std::fstream fs; // поток для чтения-записи fs.open(«hello.txt»); // окрываем файл для чтения-записи fs.close(); // закрываем файл >

Источник: metanit.com

Открытие файла для чтения или записи

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

Пример. Открытие файла для записи

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

Последующий вызов открытия этого файла с помощью CreateFile завершится ошибкой, пока дескриптор не будет закрыт.

#include #include #include #include void DisplayError(LPTSTR lpszFunction); int __cdecl _tmain(int argc, TCHAR *argv[]) < HANDLE hFile; char DataBuffer[] = «This is some test data to write to the file.»; DWORD dwBytesToWrite = (DWORD)strlen(DataBuffer); DWORD dwBytesWritten = 0; BOOL bErrorFlag = FALSE; printf(«n»); if( argc != 2 ) < printf(«Usage Error:tIncorrect number of argumentsnn»); _tprintf(TEXT(«%s n»), argv[0]); return; > hFile = CreateFile(argv[1], // name of the write GENERIC_WRITE, // open for writing 0, // do not share NULL, // default security CREATE_NEW, // create new file only FILE_ATTRIBUTE_NORMAL, // normal file NULL); // no attr. template if (hFile == INVALID_HANDLE_VALUE) < DisplayError(TEXT(«CreateFile»)); _tprintf(TEXT(«Terminal failure: Unable to open file «%s» for write.n»), argv[1]); return; >_tprintf(TEXT(«Writing %d bytes to %s.n»), dwBytesToWrite, argv[1]); bErrorFlag = WriteFile( hFile, // open file handle DataBuffer, // start of data to write dwBytesToWrite, // number of bytes to write // no overlapped structure if (FALSE == bErrorFlag) < DisplayError(TEXT(«WriteFile»)); printf(«Terminal failure: Unable to write to file.n»); >else < if (dwBytesWritten != dwBytesToWrite) < // This is an error because a synchronous write that results in // success (WriteFile returns TRUE) should write all data as // requested. This would not necessarily be the case for // asynchronous writes. printf(«Error: dwBytesWritten != dwBytesToWriten»); >else < _tprintf(TEXT(«Wrote %d bytes to %s successfully.n»), dwBytesWritten, argv[1]); >> CloseHandle(hFile); > void DisplayError(LPTSTR lpszFunction) // Routine Description: // Retrieve and output the system error message for the last-error code < LPVOID lpMsgBuf; LPVOID lpDisplayBuf; DWORD dw = GetLastError(); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) lpDisplayBuf = (LPVOID)LocalAlloc( LMEM_ZEROINIT, ( lstrlen((LPCTSTR)lpMsgBuf) + lstrlen((LPCTSTR)lpszFunction) + 40) // account for format string * sizeof(TCHAR) ); if (FAILED( StringCchPrintf((LPTSTR)lpDisplayBuf, LocalSize(lpDisplayBuf) / sizeof(TCHAR), TEXT(«%s failed with error code %d as follows:n%s»), lpszFunction, dw, lpMsgBuf))) < printf(«FATAL ERROR: Unable to output error code.n»); >_tprintf(TEXT(«ERROR: %sn»), (LPCTSTR)lpDisplayBuf); LocalFree(lpMsgBuf); LocalFree(lpDisplayBuf);

Пример. Открытие файла для чтения

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

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

Совет. Для тестирования этого примера можно использовать файл, созданный с помощью предыдущего примера WriteFile.

#include #include #include #include #define BUFFERSIZE 5 DWORD g_BytesTransferred = 0; void DisplayError(LPTSTR lpszFunction); VOID CALLBACK FileIOCompletionRoutine( __in DWORD dwErrorCode, __in DWORD dwNumberOfBytesTransfered, __in LPOVERLAPPED lpOverlapped ); VOID CALLBACK FileIOCompletionRoutine( __in DWORD dwErrorCode, __in DWORD dwNumberOfBytesTransfered, __in LPOVERLAPPED lpOverlapped ) < _tprintf(TEXT(«Error code:t%xn»), dwErrorCode); _tprintf(TEXT(«Number of bytes:t%xn»), dwNumberOfBytesTransfered); g_BytesTransferred = dwNumberOfBytesTransfered; >// // Note: this simplified sample assumes the file to read is an ANSI text file // only for the purposes of output to the screen. CreateFile and ReadFile // do not use parameters to differentiate between text and binary file types. // int __cdecl _tmain(int argc, TCHAR *argv[]) < HANDLE hFile; DWORD dwBytesRead = 0; char ReadBuffer[BUFFERSIZE] = ; OVERLAPPED ol = ; printf(«n»); if( argc != 2 ) < printf(«Usage Error: Incorrect number of argumentsnn»); _tprintf(TEXT(«Usage:nt%s n»), argv[0]); return; > hFile = CreateFile(argv[1], // file to open GENERIC_READ, // open for reading FILE_SHARE_READ, // share for reading NULL, // default security OPEN_EXISTING, // existing file only FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, // normal file NULL); // no attr. template if (hFile == INVALID_HANDLE_VALUE) < DisplayError(TEXT(«CreateFile»)); _tprintf(TEXT(«Terminal failure: unable to open file «%s» for read.n»), argv[1]); return; >// Read one character less than the buffer size to save room for // the terminating NULL character. if( FALSE == ReadFileEx(hFile, ReadBuffer, BUFFERSIZE-1, DisplayError(TEXT(«ReadFile»)); printf(«Terminal failure: Unable to read from file.n GetLastError=%08xn», GetLastError()); CloseHandle(hFile); return; >SleepEx(5000, TRUE); dwBytesRead = g_BytesTransferred; // This is the section of code that assumes the file is ANSI text. // Modify this block for other data types if needed. if (dwBytesRead > 0 dwBytesRead else if (dwBytesRead == 0) < _tprintf(TEXT(«No data read from file %sn»), argv[1]); >else < printf(«n ** Unexpected value for dwBytesRead ** n»); >// It is always good practice to close the open file handles even though // the app will exit here and clean up open handles anyway. CloseHandle(hFile); > void DisplayError(LPTSTR lpszFunction) // Routine Description: // Retrieve and output the system error message for the last-error code < LPVOID lpMsgBuf; LPVOID lpDisplayBuf; DWORD dw = GetLastError(); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) lpDisplayBuf = (LPVOID)LocalAlloc( LMEM_ZEROINIT, ( lstrlen((LPCTSTR)lpMsgBuf) + lstrlen((LPCTSTR)lpszFunction) + 40) // account for format string * sizeof(TCHAR) ); if (FAILED( StringCchPrintf((LPTSTR)lpDisplayBuf, LocalSize(lpDisplayBuf) / sizeof(TCHAR), TEXT(«%s failed with error code %d as follows:n%s»), lpszFunction, dw, lpMsgBuf))) < printf(«FATAL ERROR: Unable to output error code.n»); >_tprintf(TEXT(«ERROR: %sn»), (LPCTSTR)lpDisplayBuf); LocalFree(lpMsgBuf); LocalFree(lpDisplayBuf); >

Источник: learn.microsoft.com