С ДЛЯ НАЧИНАЮЩИХ М 2006 24 С 102

{
inFile.open( fileTabl[ix].c_str() );
// ... проверить успешность открытия
// ... обработать файл
inFile.close();
}
}
Объект класса fstream (производного от iostream) может открывать файл для ввода или вывода. В следующем примере файл word.out сначала считывается, а затем записывается с помощью объекта типа fstream. Созданный ранее в этом разделе файл word.out содержит объект WordCount:
#include
#include "WordCount.h"

int main()
{
WordCount wd;
fstream file;

file.open( "word.out", ios::in );
file >> wd;
file.close();

cout << "Прочитано: " << wd << endl;

// операция ios_base::out стерла бы текущие данные
file.open( "word.out", ios::app );
file << endl << wd << endl;
file.close();
}
Объект класса fstream может также открывать файл одновременно для ввода и вывода. Например, приведенная инструкция открывает файл word.out для ввода и дозаписи:
fstream io( "word.out", ios_base::in|ios_base::app );
Для задания нескольких режимов используется оператор побитового ИЛИ. Объект класса fstream можно позиционировать с помощью функций-членов seekg() или seekp(). Здесь буква g обозначает позиционирование для чтения (getting) символов (используется с объектом класса ofstream), а p – для записи (putting) символов (используется с объектом класса ifstream). Эти функции делают текущим тот байт в файле, который имеет указанное абсолютное или относительное смещение. У них есть два варианта:
// установить абсолютное смещение в файле
seekg( pos_type current_position )

// смещение от текущей позиции в том или ином направлении
seekg( off_type offset_position, ios_base::seekdir dir );
В первом варианте текущая позиция устанавливается в некоторое абсолютное значение, заданное аргументом current_position, причем значение 0 соответствует началу файла. Например, если файл содержит такую последовательность символов:

abc def ghi jkl

то вызов
io.seekg( 6 );
позиционирует io на шестой символ, т.е. на f. Второй вариант устанавливает указатель рабочей позиции файла на заданное расстояние от текущей, от начала файла или от его конца в зависимости от аргумента dir, который может принимать следующие значения:
ios_base::beg – от начала файла;
ios_base::cur – от текущей позиции;
ios_base::end – от конца файла.
В следующем примере каждый вызов seekg() позиционирует файл на i-ую запись:
for ( int i = 0; i < recordCnt; ++i )
readFile.ssekg( i * sizeof(Record), ios_base::beg );
С помощью первого аргумента можно задавать отрицательное значение. Переместимся на 10 байтов назад от текущей позиции:
readFile.seekg( -10, ios_base::cur );
Текущая позиция чтения в файле типа fstream возвращается любой из двух функций-членов tellg() или tellp(). Здесь 'p' означает запись (putting) и используется с объектом ofstream, а 'g' говорит о чтении (getting) и обслуживает объект ifstream:
// сохранить текущую позицию
ios_base::pos_type mark = writeFile.tellp();

// ...
if ( cancelEntry )
// вернуться к сохраненной позиции
writeFile.seekp( mark );
Если необходимо сместиться вперед от текущей позиции на одну запись типа Record, то можно воспользоваться любой из данных инструкций:
// эквивалентные вызовы seekg
readFile.seekg( readFile.tellg() + sizeof(Record) );

// данный вызов считается более эффективным
readFile.seekg( sizeof(Record), ios_base::cur );
Разберем реальный пример. Дан текстовый файл, нужно вычислить его длину в байтах и сохранить ее в конце файла. Кроме того, каждый раз при встрече символа новой строки требуется сохранить текущее смещение в конце файла. Вот наш текстовый файл:

abcd
efg
hi
j

Программа должна создать файл, модифицированный следующим образом:

abcd
efg
hi
j
5 9 12 14 24

Так выглядит первая попытка реализации:
#include
#include

main() {
// открыть файл для ввода и дозаписи
fstream inOut( "copy.out", ios_base::in|ios_base::app );
int cnt = 0; // счетчик байтов
char ch;

while ( inOut.get( ch ))
{
cout.put( ch ); // скопировать на терминал
++cnt;
if ( ch == '\n' ) {
inOut << cnt ;
inOut.put( ' ' ); // пробел
}
}

// вывести окончательное значение счетчика байтов
inOut << cnt << endl;
cout << "[ " << cnt << " ]" << endl;
return 0;
}
inOut – это объект класса fstream, связанный с файлом copy.out, открытым для ввода и дозаписи. Если файл открыт в режиме дозаписи, то все новые данные записываются в конец.
При чтении любого (включая пробельные) символа, кроме конца файла, мы увеличиваем переменную cnt на 1 и копируем прочитанный символ на терминал, чтобы вовремя заметить ошибки в работе программы.
Встретив символ новой строки, мы записываем текущее значение cnt в inOut. Как только будет достигнут конец файла, цикл прекращается. Окончательное значение cnt выводится в файл и на экран.
Программа компилируется без ошибок и кажется правильной. Но если подать на вход несколько фраз из романа “Моби Дик” Германа Мелвилла:

Call me Ishmael. Some years ago, never mind
how long precisely, having little or no money
in my purse, and nothing particular to interest
me on shore, I thought I would sail about a little
and see the watery part of the world. It is a
way I have of driving off the spleen, and
regulating the circulation.

то получим такой результат:

[ 0 ]

Программа не вывела ни одного символа, видимо, полагая, что файл пуст. Проблема в том, что файл открыт для дозаписи и потому позиционирован на конец. При выполнении инструкции
inOut.get( ch );
мы читаем конец файла, цикл while завершается и выводится значение 0.
Хотя мы допустили серьезную ошибку, исправить ее совсем несложно, поскольку причина понятна. Надо лишь перед чтением переустановить файл на начало. Это делается с помощью обращения:
inOut.seekg( 0 );
Запустим программу заново. На этот раз она печатает:

Call me Ishmael. Some years ago, never mind
[ 45 ]

Как видим, выводится лишь первая строка текста и счетчик для нее, а оставшиеся шесть строк проигнорированы. Ну что ж, исправление ошибок – неотъемлемая часть профессии программиста. А проблема опять в том, что файл открыт в режиме дозаписи. Как только мы в первый раз вывели cnt, файл оказался позиционирован на конец. При следующем обращении к get() читается конец файла, и цикл while снова завершается преждевременно.
Нам необходимо встать на ту позицию в файле, где мы были перед выводом cnt. Для этого понадобятся еще две инструкции:
// запомнить текущую позицию
ios_base::pos_type mark = inOut.tellg();
inOut << cnt << sp;
inOut.seekg( mark ); // восстановить позицию
После повторной компиляции программа выводит на экран ожидаемый результат. Но посмотрев на выходной файл, мы обнаружим, что она все еще не вполне правильна: окончательное значение счетчика есть на экране, но не в файле. Оператор вывода, следующий за циклом while, не был выполнен.
Дело в том, что inOut находится в состоянии “конец файла”, в котором операции ввода и вывода не выполняются. Для решения проблемы необходимо сбросить это состояние с помощью функции-члена clear():
inOut.clear(); // обнулить флаги состояния
Окончательный вариант программы выглядит так:
#include
#include

int main()
{
fstream inOut( "copy.out", ios_base::in|ios_base::app );
int cnt=0;
char ch;

inOut.seekg(0);

while ( inOut.get( ch ))
{
cout.put( ch );
cnt++;

if ( ch == '\n' )
{
// запомнить текущую позицию
ios_base::pos_type mark = inOut.tellg();
inOut << cnt << ' ';
inOut.seekg( mark ); // восстановить позицию
}
}
inOut.clear();
inOut << cnt << endl;

cout << "[ " << cnt << " ]\n";

return 0;
}
Вот теперь – наконец-то! – все правильно. При реализации этой программы было необходимо явно сформулировать поведение, которое мы собирались поддержать. А каждое наше исправление было реакцией на выявившуюся ошибку вместо анализа проблемы в целом.
Упражнение 20.12
Пользуясь операторами вывода для класса Date, которые вы определили в упражнении 20.7, или для класса CheckoutRecord из упражнения 20.8 (см. раздел 20.4), напишите программу, позволяющую создать файл и писать в него.
Упражнение 20.13
Напишите программу для открытия и чтения файла, созданного в упражнении 20.12. Выведите содержимое файла на стандартный вывод.
Упражнение 20.14
Напишите программу для открытия файла, созданного в упражнении 20.12, для чтения и дозаписи. Выведите экземпляр класса Date или CheckoutRecord:
(a) в начало файла
(b) после второго из существующих объектов
(c) в конец файла
20.7. Состояния потока
Пользователей библиотеки iostream, разумеется, интересует, находится ли поток в ошибочном состоянии. Например, если мы пишем
int ival;
cin >> ival;
и вводим слово "Borges", то cin переводится в состояние ошибки после неудачной попытки присвоить строковый литерал целому числу. Если бы мы ввели число 1024, то чтение прошло бы успешно и поток остался бы в нормальном состоянии.
Чтобы выяснить, в каком состоянии находится поток, достаточно проверить его значение на истину:
if ( !cin )
// операция чтения не прошла или встретился конец файла
Для чтения заранее неизвестного количества элементов мы обычно пишем цикл while:
while ( cin >> word )
// операция чтения завершилась успешно ...
Условие в цикле while будет равно false, если достигнут конец файла или произошла ошибка при чтении. В большинстве случаев такой проверки потокового объекта достаточно. Однако при реализации оператора ввода для класса WordCount из раздела 20.5 нам понадобился более точный анализ состояния.
У любого потока есть набор флагов, с помощью которых можно следить за состоянием потока. Имеются четыре предикатные функции-члена:
eof() возвращает true, если достигнут конец файла:
if ( inOut.eof() )
// отлично: все прочитано ...
bad() возвращает true при попытке выполнения некорректной операции, например при установке позиции за концом файла. Обычно это свидетельствует о том, что поток находится в состоянии ошибки;
fail() возвращает true, если операция завершилась неудачно, например не удалось открыть файл или передан некорректный формат ввода:
ifstream iFile( filename, ios_base::in );

if ( iFile.fail() ) // не удалось открыть
error_message( ... );
good() возвращает true, если все вышеперечисленные условия ложны:
if ( inOut.good() )
Существует два способа явно изменить состояние потока iostream. С помощью функции-члена clear() ему явно присваивается указанное значение. Функция setstate() не сбрасывает состояние, а устанавливает один из флагов, не меняя значения остальных. Например, в коде оператора ввода для класса WordCount при обнаружении неверного формата мы используем setstate() для установки флага fail в состоянии объекта istream:
if ((ch = is.get()) != '<' )
{
is.setstate( ios_base::failbit );
return is;
}
Имеются следующие значения флагов состояния:
ios_base::badbit
ios_base::eofbit
ios_base::failbit
ios_base::goodbit
Для установки сразу нескольких флагов используется побитовый оператор ИЛИ:
is.setstate( ios_base::badbit | ios_base::failbit );
При тестировании оператора ввода в классе WordCount (см. раздел 20.5) мы писали:
if ( !cin ) {
cerr << "Ошибка ввода WordCount" << endl;
return -1;
}
Возможно, вместо этого мы предпочли бы продолжить выполнение программы, предупредив пользователя об ошибке и попросив повторить ввод. Но перед чтением нового значения из потока cin необходимо перевести его в нормальное состояние. Это можно сделать с помощью функции-члена clear():
cin.clear(); // сброс ошибок
В более общем случае clear() используется для сброса текущего состояния и установки одного или нескольких флагов нового. Например:
cin.clear( ios_base::goodbit );
восстанавливает нормальное состояние потока. (Оба вызова эквивалентны, поскольку goodbit является для clear() аргументом по умолчанию.)
Функция-член rdstate() позволяет получить текущее состояние объекта:
ios_base::iostate old_state = cin.rdstate();

cin.clear();
process_input();

// перевести поток cin в прежнее состояние
cin.clear( old_state );
Упражнение 20.15
Измените один (или оба) оператор ввода для класса Date из упражнения 20.7 и/или класса CheckoutRecord из упражнения 20.8 (см. раздел 20.4) так, чтобы они устанавливали состояние объекта istream. Модифицируйте программы, которыми вы пользовались для тестирования этих операторов, для проверки явно установленного состояния, вывода его на печать и сброса в нормальное. Протестируйте программы, подав на вход правильные и неправильные данные.
20.8. Строковые потоки
Библиотека iostream поддерживает операции над строковыми объектами в памяти. Класс ostringstream вставляет символы в строку, istringstream читает символы из строкового объекта, а stringstream может использоваться как для чтения, так и для записи. Чтобы работать со строковым потоком, в программу необходимо включить заголовочный файл
#include
Например, следующая функция читает весь файл alice_emma в объект buf класса ostringstream. Размер buf увеличивается по мере необходимости, чтобы вместить все символы:
#include
#include
#include

string read_file_into_string()
{
ifstream ifile( "alice_emma" );
ostringstream buf;

char ch;
while ( buf && ifile.get( ch ))
buf.put( ch );
return buf.str();
}
Функция-член str() возвращает строку – объект класса string, ассоциированный со строковым потоком ostringstream. Этой строкой можно манипулировать так же, как и “обычным” объектом класса string. Например, в следующей программе text почленно инициализируется строкой, ассоциированной с buf:
int main()
{
string text = read_file_into_string();

// запомнить позиции каждого символа новой строки
vector< string::size_type > lines_of_text;
string::size_type pos = 0;

while ( pos != string::npos )
{
pos = text.find( '\n' pos );
lines_of_text.push_back( pos );
}

// ...
}
Объект класса ostringstream можно использовать для автоматического форматирования составной строки, т.е. строки, составленной из данных разных типов. Так, следующий оператор вывода автоматически преобразует любой арифметический тип в соответствующее строковое представление, поэтому заботиться о выделении нужного количества памяти нет необходимости:
#include
#include

int main()
{
int ival = 1024; int *pival = &ival;
double dval = 3.14159; double *pdval = &dval;

ostringstream format_message;

// преобразование значений в строковое представление
format_message << "ival: " << ival
<< " адрес ival: " << pival << 'n'
<< "dval: " << dval
<< " адрес dval: " << pdval << endl;

string msg = format_message.str();
cout << " размер строки сообщения: " << msg.size()
<< " сообщение: " << msg << endl;
}
Иногда лучше собрать все диагностические сообщения об ошибках, а не выводить их по мере возникновения. Это легко сделать с помощью перегруженного множества функций форматирования:
string
format( string msg, int expected, int received )
{
ostringstream message;

<< Пред. стр. 102 (из 121) След. >>

Список литературы по разделу