Глава 8

Потоки

Разработка и реализация стандартных средств ввода/вывода для языка программирования зарекомендовала себя как заведомо трудная работа. Традиционно средства ввода/вывода разрабатывались исключительно для небольшого числа встроенных типов данных. Однако в C++ программах обычно используется много типов, определенных пользователем, и нужно обрабатывать ввод и вывод также и значений этих типов. Очевидно, средство ввода/вывода должно быть простым, удобным, надежным в употреблении, эффективным и гибким, и ко всему прочему полным. Ничье решение еще не смогло угодить всем, поэтому у пользователя должна быть возможность задавать альтернативные средства ввода/вывода и расширять стандартные средства ввода/вывода применительно к требованиям приложения.
C++ разработан так, чтобы у пользователя была возможность определять новые типы столь же эффективные и удобные, сколь и встроенные типы. Поэтому обоснованным является требование того, что средства ввода/вывода для C++ должны обеспечиваться в C++ с применением только тех средств, которые доступны каждому программисту. Описываемые здесь средства ввода/вывода представляют собой попытку ответить на этот вызов.
Средства ввода/вывода связаны исключительно с обработкой преобразования типизированных объектов в последовательности символов и обратно. Есть и другие схемы ввода/вывода, но эта является основополагающей в системе UNIX, и большая часть видов бинарного ввода/вывода обрабатывается через рассмотрение символа просто как набор бит, при этом его общепринятая связь с алфавитом игнорируется. Тогда для программиста ключевая проблема заключается в задании соответствия между типизированным объектом и принципиально не типизированной строкой.
Обработка и встроенных и определенных пользователем типов однородным образом и с гарантией типа достигается с помощью одного перегруженного имени функции для набора функций вывода. Например:

  put(cerr,"x = "); // cerr - поток вывода ошибок

  put(cerr,x);

  put(cerr,"\n");

  cerr << "x = " << x << "\n";

  x = 123

  x = 1,2.4)

8.2 Вывод

Класс ostream определяется вместе с операцией << ("поместить в") для обработки вывода встроенных типов:

  class ostream {

      // ...

  public:

      ostream& operator<<(char*);

      ostream& operator<<(int i) { return *this<

8.2.2 Некоторые Подробности Разработки

Операция вывода используется, чтобы избежать той многословности, которую дало бы использование функции вывода. Но почему < Возможности изобрести новый лексический символ нет (#6.2). Операция присваивания была кандидатом одновременно и на ввод, и на вывод, но оказывается, большинство людей предпочитают, чтобы операция ввода отличалась от операции вывода. Кроме того, = не в ту сторону связывается (ассоциируется), то есть cout=a=b означает cout=(a=b).
Делались попытки использовать операции < и >, но значения "меньше" и "больше" настолько прочно вросли в сознание людей, что новые операции ввода/вывода во всех реальных случаях оказались нечитаемыми. Помимо этого, "<" находится на большинстве клавиатур как раз на ",", и у людей получаются операторы вроде такого:

  cout < x , y , z;

  cout << "a*b+c=" << a*b+c << "\n";

  cout << "a^b|c=" << (a^b|c) << "\n";

  cout << "a<

8.2.3 Форматированный Вывод

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

  char* oct(long, int =0);    // восьмеричное представление

  char* dec(long, int =0);    // десятичное представление

  char* hex(long, int =0);    // шестнадцатиричное представление

  char* chr(int, int =0);     // символ

  char* str(char*, int =0);   // строка

  cout << "dec(" << x

       << ") = oct(" << oct(x,6)

       << ") = hex(" << hex(x,4)

       << ")";

  dec(15) = oct(    17) = hex(   f);

  char* form(char* format ...);

  cout<

8.2.4 Виртуальная Функция Вывода

8.3 Файлы и Потоки

ostream имеет конструкторы:

  class ostream {

      // ...

      ostream(streambuf* s);      // связывает с буфером потока

      ostream(int fd);            // связывание для файла

      ostream(int size, char* p); // связывет с вектором

  };

8.3.2 Закрытие Потоков Вывода

Деструктор для ostream сбрасывает буфер с помощью открытого члена функции ostream::flush():

  ostream::~ostream()

  {

      flush();       // сброс

  }

  cout.flush();

8.3.3 Открытие Файлов

Точные детали того, как открываются и закрываются файлы, различаются в разных операционных системах и здесь подробно не описываются. Поскольку после включения становятся доступны cin, cout и cerr, во многих (если не во всех) программах не нужно держать код для открытия файлов. Вот, однако, программа, которая открывает два файла, заданные как параметры командной строки, и копирует первый во второй:

  #include



  void error(char* s, char* s2)

  {

      cerr << s << " " << s2 << "\n";

      exit(1);

  }



  main(int argc, char* argv[])

  {

      if (argc != 3) error("неверное число параметров","");



      filebuf f1;

      if (f1.open(argv[1],input) == 0)

          error("не могу открыть входной файл",argv[1]);

      istream from(&f1);



      filebuf f2;

      if (f2.open(argv[2],output) == 0)

          error("не могу создать выходной файл",argv[2]);

      ostream to(&f2);



      char ch;

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



      if (!from.eof() !! to.bad())

          error("случилось нечто странное","");

  }

  enum open_mode { input, output };

8.3.4 Копирование Потоков

Есть возможность копировать потоки. Например:

  cout = cerr;

8.4 Ввод

Класс istream определяется так:

class istream {

      // ...

  public:

      istream& operator>>(char*);      // строка

      istream& operator>>(char&);      // символ

      istream& operator>>(short&);

      istream& operator>>(int&);

      istream& operator>>(long&);

      istream& operator>>(float&);

      istream& operator>>(double&);

      // ...

  };

  istream& istream::operator>>(char& c);

  {

          // пропускает пропуски

      int a;

          // неким образом читает символ в "a"

      c = a;

  }

  class istream {

      // ...

      istream& get(char& c);                    // char

      istream& get(char* p, int n, int ='\n');  // строка

  };

  cin.get(buf,256,'\t');

  int isalpha(char)    // 'a'..'z' 'A'..'Z'

  int isupper(char)    // 'A'..'Z'

  int islower(char)    // 'a'..'z'

  int isdigit(char)    // '0'..'9'

  int isxdigit(char)   // '0'..'9' 'a'..'f' 'A'..'F'

  int isspase(char)    // ' ' '\t' возврат новая строка

                       // перевод формата

  int iscntrl(char)    // управляющий символ

                       // (ASCII 0..31 и 127)

  int ispunct(char)    // пунктуация: ниодин из вышеперечисленных

  int isalnum(char)    // isalpha() | isdigit()

  int isprint(char)    // печатаемый: ascii ' '..'-'

  int isgraph(char)    // isalpha() | isdigit() | ispunct()

  int isascii(char c)  { return 0<=c &&c<=127; }

  (('a'<=c && c<='z') || ('A'<=c && c<='Z')) // алфавитный

  isalpha(c)

8.4.2 Состояния Потока

Каждый поток (istream или ostream) имеет ассоциированное с ним состояние, и обработка ошибок и нестандартных условий осуществляется с помощью соответствующей установки и проверки этого состояния.
Поток может находиться в одном из следующих состояний:

  enum stream_state { _good, _eof, _fail, _bad };

switch (cin.rdstate()) {

  case _good:

      // последняя операция над cin прошла успешно

      break;

  case _eof:

      // конец файла

      break;

  case _fail:

      // некоего рода ошибка форматирования

      // возможно, не слишком плохая

      break;

  case _bad:

      // возможно, символы cin потеряны

      break;

  }

  while (cin>>z) cout << z << "\n";

8.4.3 Ввод Типов, Определяемых Пользователем

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

  istream& operator>>(istream& s, complex& a)

  /*

      форматы ввода для complex; "f" обозначает float:

      f

      ( f )

      ( f , f )

  */

  {

      double re = 0, im = 0;

      char c = 0;



      s >> c;

      if (c == '(') {

          s >> re >> c;

          if (c == ',') s >> im >> c;

          if (c != ')') s.clear(_bad);    // установить state

      }

      else {

          s.putback(c);

          s >> re;

      }



      if (s) a = complex(re,im);

      return s;

  }

8.4.4 Инициализация Потоков Ввода

Естественно, тип istream, так же как и ostream, снабжен конструктором:

  class istream {

      // ...

      istream(streambuf* s, int sk =1, ostream* t =0);

      istream(int size, char* p, int sk =1);

      istream(int fd, int sk =1, ostream* t =0);

  };

  cout.flush(); // пишет буфер вывода

  int y_or_n(ostream& to, istream& from)

  /*

       "to", получает отклик из "from"

  */

  {

      ostream* old = from.tie(&to);

      for (;;) {

          cout << "наберите Y или N: ";

          char ch = 0;

          if (!cin.get(ch)) return 0;



          if (ch != '\n') { // пропускает остаток строки

              char ch2 = 0;

              while (cin.get(ch2) && ch2 != '\n') ;

          }

          switch (ch) {

          case 'Y':

          case 'y':

          case '\n':

              from.tie(old);        // восстанавливает старый tie

              return 1;

          case 'N':

          case 'n':

              from.tie(old);        // восстанавливает старый tie

              return 0;

          default:

              cout << "извините, попробуйте еще раз: ";

          }

      }

  }

8.5 Работа со Строками

Можно осуществлять действия, подобные вводу/выводу, над символьным вектором, прикрепляя к нему istream или ostream. Например, если вектор содержит обычную строку, завершающуюся нулем, для печати слов из этого вектора можно использовать приведенный выше копирующий цикл:

  void word_per_line(char v[], int sz)

  /*

      печатет "v" размера "sz" по одному слову на строке

  */

  {

      istream ist(sz,v); // сделать istream для v

      char b2[MAX];      // больше наибольшего слова

      while (ist>>b2) cout << b2 << "\n";

  }

  char* p = new char[message_size];

  ostream ost(message_size,p);

  do_something(arguments,ost);

  display(p);

8.6 Буферизация

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

  struct streambuf {      // управление буфером потока



      char* base;         // начало буфера

      char* pptr;         // следующий свободный char

      char* qptr;         // следующий заполненный char

      char* eptr;         // один из концов буфера

      char  alloc;        // буфер, выделенный с помощью new



          // Опустошает буфер:

          // Возвращает EOF при ошибке и 0 в случае успеха

      virtual int overflow(int c =EOF);



          // Заполняет буфер

          // Возвращет EOF при ошибке или конце ввода,

          // иначе следующий char

      virtual int underflow();



      int snextc()        // берет следующий char

      {

          return (++qptr==pptr) ? underflow() : *qptr&0377;

      }



      // ...



      int allocate()      // выделяет некоторое пространство буфера



      streambuf() { /* ... */}

      streambuf(char* p, int l) { /* ... */}

      ~streambuf() { /* ... */}

  };

  struct filebuf : public streambuf {



      int fd;              // дескриптор файла

      char opened;         // файл открыт



      int overflow(int c =EOF);

      int underflow();



      // ...



          // Открывает файл:

          // если не срабатывает, то возвращает 0,

          // в случае успеха возвращает "this"

      filebuf* open(char *name, open_mode om);

      int close() { /* ... */ }



      filebuf() { opened = 0; }

      filebuf(int nfd) { /* ... */ }

      filebuf(int nfd, char* p, int l) : (p,l) { /* ... */ }

      ~filebuf() { close(); }

  };



  int filebuf::underflow()         // заполняет буфер из fd

  {

      if (!opened || allocate()==EOF) return EOF;



      int count = read(fd, base, eptr-base);

      if (count < 1) return EOF;



      qptr = base;

      pptr = base + count;

      return *qptr & 0377;

  }

8.7 Эффективность