Опубликован: 10.10.2006 | Доступ: свободный | Студентов: 6134 / 468 | Оценка: 4.26 / 3.88 | Длительность: 31:30:00
Лекция 10:

Потоки

10.5 Файлы и потоки

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

#include <fstream.h>
#include <libc.h>

void error(char* s, char* s2 ="")
{
   cerr << s << ' ' << s2 << '\n';
   exit(1);
}

int main(int argc, char* argv[])
{
    if (argc != 3) error("wrong number of arguments");

    ifstream from(argv[1]);
    if (!from) error("cannot open input file",argv[1]);

    ostream to(argv[2]);
    if (!to) error("cannot open output file",argv[2]);

    char ch;
    while (from.get(ch)) to.put(ch);

    if (!from.eof() || to.bad())
       error("something strange happened");

    return 0;
 }

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

По умолчанию ifstream всегда открывается на чтение, а ofstream открывается на запись. В ostream и в istream можно использовать необязательный второй аргумент, указывающий иные режимы открытия:

class ios {
public:
    //...
    enum open_mode {
       in=1,           // открыть на чтение
       out=2,           // открыть как выходной
       ate=4,           // открыть и переместиться в конец файла
       app=010,         // добавить
       trunc=020,       // сократить файл до нулевой длины
       nocreate=040,    // неудача, если файл не существует
       noreplace=0100   // неудача, если файл существует
    };
    //...
};

Настоящие значения для open_mode и их смысл вероятно будут зависеть от реализации. Будьте добры, за деталями обратитесь к руководству по вашей библиотеке или экспериментируйте. Приведенные комментарии могут прояснить их назначение. Например, можно открыть файл с условием, что операция открытия не выполнится, если файл уже не существует:

void f()
{
    ofstream mystream(name,ios::out|ios::nocreate);

    if (ofstream.bad()) {
        //...
    }
    //...
}

Также можно открыть файл сразу на чтение и запись:

fstream dictionary("concordance", ios::in|ios::out);

Все операции, допустимые для ostream и istream, можно применять к fstream. На самом деле, класс fstream является производным от iostream, который является, в свою очередь, производным от istream и ostream. Причина, по которой информация по буферизации и форматированию для ostream и istream находится в виртуальном базовом классе ios, в том, чтобы заставить действовать всю эту последовательность производных классов. По этой же причине операции позиционирования в istream и ostream имеют разные имена - seekp() и seekg(). В iostream есть отдельные позиции для чтения и записи.

10.5.1 Закрытие потоков

Файл может быть закрыт явно, если вызвать close() для его потока:

mystream.close();

Но это неявно делает деструктор потока, так что явный вызов close() может понадобиться, если только файл нужно закрыть до достижения конца области определенности потока.

Здесь возникает вопрос, как реализация может обеспечить создание предопределенных потоков cout, cin и cerr до их первого использования и закрытие их только после последнего использования. Конечно, разные реализации библиотеки потоков из <iostream.h> могут по-разному решать эту задачу. В конце концов, решение - это прерогатива реализации, и оно должно быть скрыто от пользователя. Здесь приводится только один способ, примененный только в одной реализации, но он достаточно общий, чтобы гарантировать правильный порядок создания и уничтожения глобальных объектов различных типов.

Основная идея в том, чтобы определить вспомогательный класс, который по сути служит счетчиком, следящим за тем, сколько раз <iostream.h> был включен в раздельно компилировавшиеся программные файлы:

class Io_init {
    static int count;
    //...
public:
    Io_init();
    ~Io_init();
};

static Io_init io_init ;

Для каждого программного файла определен свой объект с именем io_init. Конструктор для объектов io_init использует Io_init::count как первый признак того, что действительная инициализация глобальных объектов потоковой библиотеки ввода-вывода сделана в точности один раз:

Io_init::Io_init()
{
   if (count++ == 0) {
       // инициализировать cout
       // инициализировать cerr
       // инициализировать cin
       // и т.д.
   }
}

Обратно, деструктор для объектов io_init использует Io_count, как последнее указание на то, что все потоки закрыты:

Io_init::~Io_init()
{
   if (--count == 0) {
       // очистить cout (сброс, и т.д.)
       // очистить cerr (сброс, и т.д.)
       // очистить cin
       // и т.д.
   }
 }

Это общий прием работы с библиотеками, требующими инициализации и удаления глобальных объектов. Впервые в С++ его применил Д. Шварц. В системах, где при выполнении все программы размещаются в основной памяти, для этого приема нет помех. Если это не так, то накладные расходы, связанные с вызовом в память каждого программного файла для выполнения функций инициализации, будут заметны. Как всегда, лучше, по возможности, избегать глобальных объектов. Для классов, в которых каждая операция значительна по объему выполняемой работы, чтобы гарантировать инициализацию, было бы разумно проверять такие первые признаки (наподобие Io_init::count ) при каждой операции. Однако, для потоков такой подход был бы излишне расточительным.

10.5.2 Строковые потоки

Как было показано, поток может быть привязан к файлу, т.е. массиву символов, хранящемуся не в основной памяти, а, например, на диске. Точно так же поток можно привязать к массиву символов в основной памяти. Например, можно воспользоваться выходным строковым потоком ostrstream для форматирования сообщений, не подлежащих немедленной печати:

char* p = new char[message_size];
ostrstream ost(p,message_size);
do_something(arguments,ost);
display(p);

С помощью стандартных операций вывода функция do_something может писать в поток ost, передавать ost подчиняющимся ей функциям и т.п. Контроль переполнения не нужен, поскольку ost знает свой размер и при заполнении перейдет в состояние, определяемое fail(). Затем функция display может послать сообщение в "настоящий" выходной поток. Такой прием наиболее подходит в тех случаях, когда окончательная операция вывода предназначена для записи на более сложное устройство, чем традиционное, ориентированное на последовательность строк, выводное устройство. Например, текст из ost может быть помещен в фиксированную область на экране.

Аналогично, istrstream является вводным строковым потоком, читающим из последовательности символов, заканчивающейся нулем:

void word_per_line(char v[], int sz)
/*
   печатать "v" размером "sz" по одному слову в строке
*/
{
   istrstream ist(v,sz);  // создать istream для v
   char b2[MAX];          // длиннее самого длинного слова
   while (ist>>b2) cout <<b2 << "\n";
 }

Завершающий нуль считается концом файла.

Строковые потоки описаны в файле <strstream.h>.

Дарья Федотова
Дарья Федотова
Сергей Березовский
Сергей Березовский

В рамках проф. переподготовки по программе "Программирование"

Есть курсы, которые я уже прошел. Но войдя в курс я вижу, что они не зачтены (Язык Ассемблера и архитектура ЭВМ, Программирование на С++ для профессионалов). Это как?

Юрий Пильщиков
Юрий Пильщиков
Россия
Станислав Мешавкин
Станислав Мешавкин
Россия, г. Заречный