Fout c что это

Работа с текстовыми файлами

Теги: Текстовые файлы, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, буферизированный поток, небуферизированный поток.

Работа с текстовыми файлами

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

• 1. Открыть файл, для того, чтобы к нему можно было обращаться. Соответственно, открывать можно для чтения, записи, чтения и записи, переписывания или записи в конец файла и т.п. Когда вы открываете файл, может также произойти куча ошибок – файла может не существовать, это может быть файл не того типа, у вас может не быть прав на работу с файлом и т.д. Всё это необходимо учитывать.
• 2. Непосредственно работа с файлом — запись и чтение. Здесь также нужно помнить, что мы работаем не с памятью с произвольным доступом, а с буферизированным потоком, что добавляет свою специфику.
• 3. Закрыть файл. Так как файл является внешним по отношению к программе ресурсом, то если его не закрыть, то он продолжит висеть в памяти, возможно, даже после закрытия программы (например, нельзя будет удалить открытый файл или внести изменения и т.п.). Кроме того, иногда необходимо не закрывать, а «переоткрывать» файл для того, чтобы, например, изменить режим доступа.

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

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

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

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

Создание и выделение памяти под объект типа FILE осуществляется с помощью функции fopen или tmpfile (есть и другие, но мы остановимся только на этих).

Функция fopen открывает файл. Она получает два аргумента – строку с адресом файла и строку с режимом доступа к файлу. Имя файла может быть как абсолютным, так и относительным. fopen возвращает указатель на объект FILE, с помощью которого далее можно осуществлять доступ к файлу.

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

Например, откроем файл и запишем в него Hello World

#include #include #include void main() < //С помощью переменной file будем осуществлять доступ к файлу FILE *file; //Открываем текстовый файл с правами на запись file = fopen("C:/c/test.txt", "w+t"); //Пишем в файл fprintf(file, "Hello, World!"); //Закрываем файл fclose(file); getch(); >

Функция fopen сама выделяет память под объект, очистка проводится функцией fclose. Закрывать файл обязательно, самостоятельно он не закроется.

Функция fopen может открывать файл в текстовом или бинарном режиме. По умолчанию используется текстовый. Режим доступа может быть следующим

Параметры доступа к файлу.

Тип	Описание
r	Чтение. Файл должен существовать.
w	Запись нового файла. Если файл с таким именем уже существует, то его содержимое будет потеряно.
a	Запись в конец файла. Операции позиционирования (fseek, fsetpos, frewind) игнорируются. Файл создаётся, если не существовал.
r+	Чтение и обновление. Можно как читать, так и писать. Файл должен существовать.
w+	Запись и обновление. Создаётся новый файл. Если файл с таким именем уже существует, то его содержимое будет потеряно. Можно как писать, так и читать.
a+	Запись в конец и обновление. Операции позиционирования работают только для чтения, для записи игнорируются. Если файл не существовал, то будет создан новый.

Если необходимо открыть файл в бинарном режиме, то в конец строки добавляется буква b, например “rb”, “wb”, “ab”, или, для смешанного режима “ab+”, “wb+”, “ab+”. Вместо b можно добавлять букву t, тогда файл будет открываться в текстовом режиме. Это зависит от реализации. В новом стандарте си (2011) буква x означает, что функция fopen должна завершиться с ошибкой, если файл уже существует. Дополним нашу старую программу: заново откроем файл и считаем, что мы туда записали.

#include #include #include void main() < FILE *file; char buffer[128]; file = fopen("C:/c/test.txt", "w"); fprintf(file, "Hello, World!"); fclose(file); file = fopen("C:/c/test.txt", "r"); fgets(buffer, 127, file); printf("%s", buffer); fclose(file); getch(); >

Вместо функции fgets можно было использовать fscanf, но нужно помнить, что она может считать строку только до первого пробела.
fscanf(file, «%127s», buffer);

Также, вместо того, чтобы открывать и закрывать файл можно воспользоваться функцией freopen, которая «переоткрывает» файл с новыми правами доступа.

#include #include #include void main() < FILE *file; char buffer[128]; file = fopen("C:/c/test.txt", "w"); fprintf(file, "Hello, World!"); freopen("C:/c/test.txt", "r", file); fgets(buffer, 127, file); printf("%s", buffer); fclose(file); getch(); >

Функции fprintf и fscanf отличаются от printf и scanf только тем, что принимают в качестве первого аргумента указатель на FILE, в который они будут выводить или из которого они будут читать данные. Здесь стоит сразу же добавить, что функции printf и scanf могут быть без проблем заменены функциями fprintf и fscanf. В ОС (мы рассматриваем самые распространённые и адекватные операционные системы) существует три стандартных потока: стандартный поток вывода stdout, стандартный поток ввода stdin и стандартный поток вывода ошибок stderr. Они автоматически открываются во время запуска приложения и связаны с консолью. Пример

#include #include #include void main() < int a, b; fprintf(stdout, "Enter two numbers\n"); fscanf(stdin, "%d", &a); fscanf(stdin, "%d", &b); if (b == 0) < fprintf(stderr, "Error: divide by zero"); >else < fprintf(stdout, "%.3f", (float) a / (float) b); >getch(); >

Ошибка открытия файла

Если вызов функции fopen прошёл неудачно, то она возвратит NULL. Ошибки во время работы с файлами встречаются достаточно часто, поэтому каждый раз, когда мы окрываем файл, необходимо проверять результат работы

#include #include #include #define ERROR_OPEN_FILE -3 void main() < FILE *file; char buffer[128]; file = fopen("C:/c/test.txt", "w"); if (file == NULL) < printf("Error opening file"); getch(); exit(ERROR_OPEN_FILE); >fprintf(file, "Hello, World!"); freopen("C:/c/test.txt", "r", file); if (file == NULL) < printf("Error opening file"); getch(); exit(ERROR_OPEN_FILE); >fgets(buffer, 127, file); printf("%s", buffer); fclose(file); getch(); >

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

. FILE *inputFile, *outputFile; unsigned m, n; unsigned i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) < printf("Error opening file %s", INPUT_FILE); getch(); exit(3); >outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) < printf("Error opening file %s", OUTPUT_FILE); getch(); if (inputFile != NULL) < fclose(inputFile); >exit(4); > .

В простых случаях можно действовать влоб, как в предыдущем куске кода. В более сложных случаях используются методы, подменяющиее RAII из С++: обёртки, или особенности компилятора (cleanup в GCC) и т.п.

Буферизация данных

• 1) Если он заполнен
• 2) Если поток закрывается
• 3) Если мы явно указываем, что необходимо очистить буфер (здесь тоже есть исключения:)).
• 4) Также очищается, если программа завершилась удачно. Вместе с этим закрываются и все файлы. В случае ошибки выполнения этого может не произойти.

Форсировать выгрузку буфера можно с помощью вызова функции fflush(File *). Рассмотрим два примера – с очисткой и без.

#include #include #include void main() < FILE *file; char c; file = fopen("C:/c/test.txt", "w"); do < c = getch(); fprintf(file, "%c", c); fprintf(stdout, "%c", c); //fflush(file); >while(c != 'q'); fclose(file); getch(); >

Раскомментируйте вызов fflush. Во время выполнения откройте текстовый файл и посмотрите на поведение.

Буфер файла можно назначить самостоятельно, задав свой размер. Делается это при помощи функции

void setbuf (FILE * stream, char * buffer);

которая принимает уже открытый FILE и указатель на новый буфер. Размер нового буфера должен быть не меньше чем BUFSIZ (к примеру, на текущей рабочей станции BUFSIZ равен 512 байт). Если передать в качестве буфера NULL, то поток станет небуферизированным. Можно также воспользоваться функцией

int setvbuf ( FILE * stream, char * buffer, int mode, size_t size );

• _IOFBF — полная буферизация. Данные записываются в файл, когда он заполняется. На считывание, буфер считается заполненным, когда запрашивается операция ввода и буфер пуст.
• _IOLBF — линейная буферизация. Данные записываются в файл когда он заполняется, либо когда встречается символ новой строки. На считывание, буфер заполняется до символа новой строки, когда запрашивается операция ввода и буфер пуст.
• _IONBF – без буферизации. В этом случае параметры size и buffer игнорируются.

Пример: зададим свой буфер и посмотрим, как осуществляется чтение из файла. Пусть файл короткий (что-нибудь, типа Hello, World!), и считываем мы его посимвольно

#include #include #include void main() < FILE *input = NULL; char c; char buffer[BUFSIZ * 2] = ; input = fopen("D:/c/text.txt", "rt"); setbuf(input, buffer); while (!feof(input)) < c = fgetc(input); printf("%c\n", c); printf("%s\n", buffer); _getch(); >fclose(input); >

Видно, что данные уже находятся в буфере. Считывание посимвольно производится уже из буфера.

feof

Функция int feof (FILE * stream); возвращает истину, если конец файла достигнут. Функцию удобно использовать, когда необходимо пройти весь файл от начала до конца. Пусть есть файл с текстовым содержимым text.txt. Считаем посимвольно файл и выведем на экран.

#include #include #include void main() < FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (input == NULL) < printf("Error opening file"); _getch(); exit(0); >while (!feof(input)) < c = fgetc(input); fprintf(stdout, "%c", c); >fclose(input); _getch(); >

Всё бы ничего, только функция feof работает неправильно. Это связано с тем, что понятие «конец файла» не определено. При использовании feof часто возникает ошибка, когда последние считанные данные выводятся два раза. Это связано с тем, что данные записывается в буфер ввода, последнее считывание происходит с ошибкой и функция возвращает старое считанное значение.

#include #include #include void main() < FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (input == NULL) < printf("Error opening file"); _getch(); exit(0); >while (!feof(input)) < fscanf(input, "%c", &c); fprintf(stdout, "%c", c); >fclose(input); _getch(); >

Этот пример сработает с ошибкой (скорее всего) и выведет последний символ файла два раза.

Решение – не использовать feof. Например, хранить общее количество записей или использовать тот факт, что функции fscanf и пр. обычно возвращают число верно считанных и сопоставленных значений.

#include #include #include void main() < FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (input == NULL) < printf("Error opening file"); _getch(); exit(0); >while (fscanf(input, "%c", &c) == 1) < fprintf(stdout, "%c", c); >fclose(input); _getch(); >

Примеры

1. В одном файле записаны два числа — размерности массива. Заполним второй файл массивом случайных чисел.

#include #include #include #include //Имена файлов и права доступа #define INPUT_FILE "D:/c/input.txt" #define OUTPUT_FILE "D:/c/output.txt" #define READ_ONLY "r" #define WRITE_ONLY "w" //Максимальное значение для размера массива #define MAX_DIMENSION 100 //Ошибка при открытии файла #define ERROR_OPEN_FILE -3 void main() < FILE *inputFile, *outputFile; unsigned m, n; unsigned i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) < printf("Error opening file %s", INPUT_FILE); getch(); exit(ERROR_OPEN_FILE); >outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) < printf("Error opening file %s", OUTPUT_FILE); getch(); //Если файл для чтения удалось открыть, то его необходимо закрыть if (inputFile != NULL) < fclose(inputFile); >exit(ERROR_OPEN_FILE); > fscanf(inputFile, "%ud %ud", &m, &n); if (m > MAX_DIMENSION) < m = MAX_DIMENSION; >if (n > MAX_DIMENSION) < n = MAX_DIMENSION; >srand(time(NULL)); for (i = 0; i < n; i++) < for (j = 0; j < m; j++) < fprintf(outputFile, "%8d ", rand()); >fprintf(outputFile, "\n"); > //Закрываем файлы fclose(inputFile); fclose(outputFile); >

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

#include #include #include #define ERROR_FILE_OPEN -3 void main() < FILE *origin = NULL; FILE *output = NULL; char filename[1024]; int mode; printf("Enter filename: "); scanf("%1023s", filename); origin = fopen(filename, "r"); if (origin == NULL) < printf("Error opening file %s", filename); getch(); exit(ERROR_FILE_OPEN); >printf("enter mode: [1 - copy, 2 - print] "); scanf("%d", &mode); if (mode == 1) < printf("Enter filename: "); scanf("%1023s", filename); output = fopen(filename, "w"); if (output == NULL) < printf("Error opening file %s", filename); getch(); fclose(origin); exit(ERROR_FILE_OPEN); >> else < output = stdout; >while (!feof(origin)) < fprintf(output, "%c", fgetc(origin)); >fclose(origin); fclose(output); getch(); >

3. Пользователь вводит данные с консоли и они записываются в файл до тех пор, пока не будет нажата клавиша esc. Проверьте программу и посмотрите. как она себя ведёт в случае, если вы вводите backspace: что выводится в файл и что выводится на консоль.

#include #include #include #define ERROR_FILE_OPEN -3 void main() < FILE *output = NULL; char c; output = fopen("D:/c/test_output.txt", "w+t"); if (output == NULL) < printf("Error opening file"); _getch(); exit(ERROR_FILE_OPEN); >for (;;) < c = _getch(); if (c == 27) < break; >fputc(c, output); fputc(c, stdout); > fclose(output); >

4. В файле записаны целые числа. Найти максимальное из них. Воспользуемся тем, что функция fscanf возвращает число верно прочитанных и сопоставленных объектов. Каждый раз должно возвращаться число 1.

#include #include #include #define ERROR_FILE_OPEN -3 void main() < FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (input == NULL) < printf("Error opening file"); _getch(); exit(ERROR_FILE_OPEN); >maxn = INT_MIN; hasRead = 1; while (hasRead == 1) < hasRead = fscanf(input, "%d", &num); if (hasRead != 1) < continue; >if (num > maxn) < maxn = num; >> printf("max number = %d", maxn); fclose(input); _getch(); >

Другое решение считывать числа, пока не дойдём до конца файла.

#include #include #include #include #define ERROR_FILE_OPEN -3 void main() < FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (input == NULL) < printf("Error opening file"); _getch(); exit(ERROR_FILE_OPEN); >maxn = INT_MIN; while (!feof(input)) < fscanf(input, "%d", &num); if (num >maxn) < maxn = num; >> printf("max number = %d", maxn); fclose(input); _getch(); >

5. В файле записаны слова: русское слово, табуляция, английское слово, в несколько рядов. Пользователь вводит английское слово, необходимо вывести русское.

Файл с переводом выглядит примерно так

солнце sun
карандаш pen
шариковая ручка pencil
дверь door
окно windows
стул chair
кресло armchair

и сохранён в кодировке cp866 (OEM 866). При этом важно: последняя пара cлов также заканчивается переводом строки.

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

#include #include #include #include #define ERROR_FILE_OPEN -3 void main() < FILE *input = NULL; char buffer[512]; char enWord[128]; char ruWord[128]; char usrWord[128]; unsigned index; int length; int wasFound; input = fopen("D:/c/input.txt", "r"); if (input == NULL) < printf("Error opening file"); _getch(); exit(ERROR_FILE_OPEN); >printf("enter word: "); fgets(usrWord, 127, stdin); wasFound = 0; while (!feof(input)) < fgets(buffer, 511, input); length = strlen(buffer); for (index = 0; index < length; index++) < if (buffer[index] == '\t') < buffer[index] = '\0'; break; >> strcpy(ruWord, buffer); strcpy(enWord, &buffer[index + 1]); if (!strcmp(enWord, usrWord)) < wasFound = 1; break; >> if (wasFound) < printf("%s", ruWord); >else < printf("Word not found"); >fclose(input); _getch(); >

6. Подсчитать количество строк в файле. Будем считывать файл посимвольно, считая количество символов ‘\n’ до тех пор, пока не встретим символ EOF. EOF – это спецсимвол, который указывает на то, что ввод закончен и больше нет данных для чтения. Функция возвращает отрицательное значение в случае ошибки.
ЗАМЕЧАНИЕ: EOF имеет тип int, поэтому нужно использовать int для считывания символов. Кроме того, значение EOF не определено стандартом.

#define _CRT_SECURE_NO_WARNINGS #include #include #include int cntLines(const char *filename) < int lines = 0; int any; //any типа int, потому что EOF имеет тип int! FILE *f = fopen(filename, "r"); if (f == NULL) < return -1; >do < any = fgetc(f); //printf("%c", any);//debug if (any == '\n') < lines++; >> while(any != EOF); fclose(f); return lines; > void main() < printf("%d\n", cntLines("C:/c/file.txt")); _getch(); >

ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 sypachev_s_s@mail.ru Stepan Sypachev students

Всё ещё не понятно? – пиши вопросы на ящик

Работа с файлами в С++

Большинство компьютерных программ работают с файлами, и поэтому возникает необходимость создавать, удалять, записывать читать, открывать файлы. Что же такое файл? Файл – именованный набор байтов, который может быть сохранен на некотором накопителе. Ну, теперь ясно, что под файлом понимается некоторая последовательность байтов, которая имеет своё, уникальное имя, например файл.txt . В одной директории не могут находиться файлы с одинаковыми именами. Под именем файла понимается не только его название, но и расширение, например: file.txt и file.dat — разные файлы, хоть и имеют одинаковые названия. Существует такое понятие, как полное имя файлов – это полный адрес к директории файла с указанием имени файла, например: D:\docs\file.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 можно объединить, то есть в одной строке создать объект и связать его с файлом. Делается это так:
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 и смотрим его содержимое, должно быть — Работа с файлами в С++ .






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

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

// 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 — если файл открыт не был. Доработаем программу с открытием файла, таким образом, что если файл не открыт выводилось соответствующее сообщение.
// 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.doc"); // (ВВЕЛИ НЕ КОРРЕКТНОЕ ИМЯ ФАЙЛА) if (!fin.is_open()) // если файл не открыт cout > buff; // считали первое слово из файла cout system("pause"); return 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() , будет вычислять характеристики основных типов данных в С++ и записывать их в файл. Характеристики:

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

Запись в файл должна выполняться в таком формате:
/* 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 .
Работа с файлами в C++. Часть 1 – Библиотека fstream.
Хедер fstream предоставляет функционал для считывания данных из файла и для записи в файл. В целом он очень похож на хедер iostream , который работает с консолью, поскольку консоль это тоже файл. Поэтому все основные операции такие же, за мелкими отличиями, как в предыдущей теме по iostream.
Наиболее частые операции следующее:



Методы проверки открыт ли файл is_open() и достигнут ли конец файла eof()


Операции позиционирования tellg(), tellp() и seekg(), seekp()

Это не все возможности, которые предоставляет библиотека fstream. Рассматривать все сейчас мы не будем, поскольку их круг применения достаточно узок. Познакомимся с вышеперечисленными. Начнем с класса чтения.
Класс ifstream 
 
Предоставляет возможности для чтения файлов. Открыть файл можно двумя способами: вызвав метод open() или указав путь к нему в конструкторе. Вам необходимо подготовить текстовый файл, перед тем, как начать набирать код. На диске d создайте папку с именем 1 и в ней создайте файл с расширением txt – “файл.txt”.






Открытие файла методом open()

#include // подключаем библиотеку

using namespace std ;

ifstream file ; // создаем объект класса ifstream

file . open ( "d:\\1\\файл.txt" ) ; // открываем файл
Открытие файла в конструкторе выглядит так:
#include // подключаем библиотеку

using namespace std ;

ifstream file ( "d:\\1\\файл.txt" ) ; // открываем файл в конструкторе
Так мы просим открыть файл txt с именем файл.txt, который лежит в папке с названием 1, а папка находится на диске d.
Использование метода open() удобно, если программист не хочет сразу привязываться к файлу. Вдруг нужно свойство класса или глобальную переменную, ну а открывать файл уже потом. Если же нужно открыть файл внутри некой функции, поработать с ним и закрыть, то можно прописать путь к файлу прямо в конструкторе. В общем зависит от ситуации.
Открыв файл, желательно прописать проверку: открылся ли он? Так как есть ряд причин, по которым файл может не открыться, а мы этого не увидим. Например, файла с указанным именем нет в прописанной папке или путь указан неверно. Можно пойти двумя путями: проверить переменную файла в логическом выражении (применив оператор “!”, к примеру) или использовать метод is_open() :






Проверка открытия файла условием if

using namespace std ;

setlocale ( LC_ALL , "rus" ) ;

ifstream file ( "d:\\1\\файл.txt" ) ;

cout << "Файл не открыт\n\n" ;
cout << "Все ОК! Файл открыт!\n\n" ;


Так все отработает нормально и файл откроется:

Теперь попробуйте вписать название папки не 1, а 2 ifstream file ( "d:\\color : #ff0000;">2 \\файл.txt”); и снова запустите программу. Так как папки с указанным именем мы не создавали, то и файл, естественно, не может быть открыт:

Второй вариант проверки с использованием метода is_open() :
Проверка методом is_open()

using namespace std ;

setlocale ( LC_ALL , "rus" ) ;

ifstream file ( "d:\\1\\файл.txt" ) ;

if ( file . is_open ( ) ) // вызов метода is_open()

cout << "Все ОК! Файл открыт!\n\n" << endl ;
cout << "Файл не открыт!\n\n" << endl ;


Метод is_open() вернет 1, если файл найден и успешно открыт. Иначе вернет 0 и сработает код прописанный в блоке else .
Если файл не открыт – желательно обработать ошибку. Как правило, если вся работа программы связана с файлом пишут некое сообщение в консоль, и ставят выход из программы. При серьезных ошибках принято возвращать некий код выполнения (число), который будет характеризовать ту или иную ошибку. Коды для каждого вида ошибок автор программы может придумывать свои. Один из способов обработки ошибок в программе мы рассматривали в статье Исключения в С++.






Если файл успешно открыт, из него можно производить чтение.
Оператор считывания >> 
Так же как и в iostream считывание можно организовать оператором >> , который указывает в какую переменную будет произведено считывание:
file >> d >> i >> s ;
Считает вещественное, целое и строку. Считывание строки закончится, если появится пробел или конец строки. Стоит отметить, что оператор >> применяется к текстовым файлам. Считывание из бинарного файла производить лучше всего с помощью метода read().
Кстати этот оператор достаточно удобен, если стоит задача разделить файл на слова:






// Считка слов из файла

for ( file >> s ; ! file . eof ( ) ; file >> s )

cout << s << endl ;


Методы getline() и get() 
 
Считывание целой строки до перевода каретки производится так же как и в iostream методом getline(). Причем рекомендуется использовать его переопределеную версию в виде функции, если считывается строка типа string:
//Считка строки из текста

getline ( file , s ) ;

cout << s << endl ;


Если же читать нужно в массив символов char[], то либо get() либо getline() именно как методы:
//Создаем буффер для чтения

char * buffer = new char [ n + 1 ] ;

buffer [ n ] = 0 ;

//Читаем n символов

file . get ( buffer , n ) ;

//Или так, но до первого пробела

file . getline ( buffer , n , ' ' ) ;

//выводим считанное

cout << buffer ;
//Освобождаем буффер
delete [ ] buffer ;


Принцип в общем тот же, что и в аналогах из iostream: Указывается в параметрах буфер (переменная, куда будет производиться чтение), или точнее указатель на блок памяти (если переменная объявлена статически: char buffer[255] к примеру, то пишется в параметры &buffer), указывается максимальное количество считываемого (в примере это n), дабы не произошло переполнение и выход за пределы буфера и по необходимости символ-разделитель, до которого будет считка (в примере это пробел). Надеюсь я не больно наступлю на хобот фанатикам Си, если сажу что эти две функции на 99% взаимозаменяемы, и на 95% могут быть заменены методом read() .
Метод read() 
//Считка из файла N байт

//Создаем буффер

char * buffer = new char [ n + 1 ] ; buffer [ n ] = 0 ;

//Читаем в него байты

file . read ( buffer , n ) ;

//выводим их на экран

cout << buffer ;
delete [ ] buffer ;


Похож на предыдущий пример?
Собственно тут тот же результат – считается указанное количество символов. Исключение только в том, что нельзя указать разделитель. read() применяется для неформатированного ввода. Призван в первую очередь читать бинарные файлы. Поскольку текстовый файл – частный случай бинарного, этот метод вполне применим и к текстовому файлу.
Метод close() 
Закрывает файл. Даже добавить нечего. Единственная пожалуй ремарка – от того, что файл, открытый для чтения, не будет закрыт этим методом как правило хуже не станет. Очень редки ситуации, когда открытый для чтения файл портится, если завершить программу не закрывая файл. Связана эта порча прежде всего с нестандартными устройствами типа стримеров на магнитной ленте или каких нибудь потоковых хитрых промышленных контроллерах, но по феншую стоит запомнить – открытый файл должен быть закрыт. Это считается хорошим тоном.
Метод eof() 
Проверяет не достигнут ли конец файла. Т.е. можно ли из него продолжать чтение. Выше пример с считкой слов оператором >> как раз использует такую проверку.
Метод seekg() 
Производит установку текущей позиции в нужную, указываемую числом. В этот метод так же передается способ позиционирования:



ios_base::end – Отсчитать новую позицию с конца файла




ios_base::beg – Отсчитать новую позицию с начала файла (абсолютное позиционирование)


ios_base::cur – Перескочить на n байт начиная от текущей позиции в файле (по умолчанию)

Принцип работы подвески FOUR-C

Monroe CCES-приспосабливающаяся подвеска, обеспечивающая оптимальный баланс комфорта и управляемости. Она постоянно подстраивает уровень демпфирования в зависимости от дорожных условий, динамики автомобиля, поворотов и стиля вождения. Разработанная инженерами компании Tenneco из Европы совместно с Öhlins Racing, Monroe СCES обеспечивает комфорт без ущерба для безопасности и надежности управления.
Компания Volvo использовала систему Monroe® CСES для разработки своего
концепта управляемого шасси, который имеет в стандартной комплектации модели S60 R и V70 R, и в качестве опций модели S60, V70, XC70 и S80. Эта система установлена на автомобилях Audi A6/A6 Avant, Ford Galaxy/Mondeo/S-Max, Mercedes C-Class и на всех моделях AMG, а также на автомобилях компании Volkswagen: Golf/Passat/Scirocco.
Чуть более внятное описание работы системы нашёл в сети на примере Audi magnetic ride и вот что оно гласит (разработка Monroe для Audi, читай для Volvo аналогичныая система):
Контроль жесткости амортизаторов разрешает классический конфликт между спортивной и динамичной настройкой подвески и высоким центром тяжести с большими ходами пружин, что особенно эффективно на автомобилях класса SUV.
Функция контроля жесткости амортизаторов, доступная только в сочетании с системой обеспечения динамики движения -drive select, позволяет водителю выбирать между динамичным, комфортным и автоматическим режимом для изменения характеристик автомобиля в зависимости от личных предпочтений, типа дороги и применяемого стиля вождения. Система определяет дефекты дорожного покрытия, повороты, загрузку автомобиля и перемещения кузова, а также изменения в торможении и ускорении. Данные этих измерений используются для расчета необходимого тока амортизаторов, а характеристики жесткости амортизаторов постоянно корректируются в соответствии с новыми данными измерений.
Используя магнитные поля, Audi magnetic ride за долю секунды изменяет жесткость амортизаторов в зависимости от дорожной ситуации. Система Audi magnetic ride также предоставляет водителю выбор основной настройки либо для более комфортной, либо для более спортивной езды.
Водитель может выбирать между комфортным и спортивным режимом езды в зависимости от дорожной ситуации и личных предпочтений. В обоих режимах жесткость амортизаторов постоянно подстраивается под текущую дорожную ситуацию для обеспечения бескомпромиссного поведения на дороге. Преимущества очевидны как в плане комфорта, так и в плане управляемости.
Спортивный режим обеспечивает прямую обратную связь с дорогой. Автомобиль активно входит в повороты и мгновенно реагирует на действия рулем. Обычный режим больше нацелен на комфорт, помогая уменьшить усталость в дальних путешествиях.
В амортизаторах с переменной, электронно-управляемой жёсткостью жидкость имеет так называемые магнитно-реологические свойства. Мельчайшие магнитные частицы перемещаются внутри обычного масла, которое используется в амортизаторах. Когда возникает магнитное поле, магнитные частицы выстраиваются в ряд против направления хода амортизатора. В результате демпфирующая сила амортизатора увеличивается в зависимости от силы магнитного поля. Это позволяет увеличивать или уменьшать жесткость амортизаторов за доли секунды.
Блок управления рассчитывает оптимальную демпфирующую силу для каждой конкретной дорожной ситуации. При расчетах он использует информацию, получаемую с датчиков положения колес, и обменивается информацией с другими системами, такими как рулевая система и ESP.
Управление системой Audi magnetic ride осуществляется клавишей с символом амортизатора на центральной консоли. Она включает и выключает спортивный режим. Индикатор на панели приборов показывает включение / выключение спортивного режима, а при активном спортивном режиме горит индикатор на клавише управления системой.


Похожие публикации:

Как найти простое число в с
Как удалить расширение у файла
Как удалить элемент из вектора c
Регуляр что это