Глава 8

Потоки

8.1 Введение

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

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

Тип параметра определяет то, какая из функций put будет вызываться для каждого параметра. Это решение применялось в нескольких языках. Однако ему недостает лаконичности. Перегрузка операции << значением "поместить в" дает более хорошую запись и позволяет программисту выводить ряд объектов одним оператором. Например:

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

  x = 123

и символ новой строки. Аналогично, если X принадлежит определенному пользователем типу complex и имеет значение (1,2.4), то приведенный выше оператор напечатает в cerr

  x = 1,2.4)

8.2 Вывод

8.2.1 Вывод Встроенных Типов

Класс 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  

Для таких операторов непросто выдать хорошие
сообщения об ошибках. 

Операции << и>> к такого рода проблемам не приводят,
они асимметричны в том смысле, что их можно
проассоциировать с "в" и "из", а
приоритет << достаточно низок, чтобы можно было не использовать скобки для арифметических выражений в роли операндов. Например: 
 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) << ")"; 

Если x==15, то в результате получится:

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

  Можно также использовать строку в общем формате:

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

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

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

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

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 Ввод

8.4.1 Ввод Встроенных Типов

Класс 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;
  }

  Пропуск определяется  как стандартный  пропуск в  C, через  вызов
isspase() в  том виде,  как она  определена  в    (пробел,
табуляция, символ новой строки, перевод формата и возврат каретки).

  В качестве альтернативы можно использовать функции get():

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

Они обрабатывают  символы пропуска  так же,  как остальные символы.
Функция istream::get(char)  читает один  и тот  же  символ  в  свой
параметр; другая  istream::get читает  не более n символов в вектор
символов,  начинающийся   в  p.   Необязательный  третий   параметр
используется для  задания символа остановки (иначе, терминатора или
ограничителя), то  есть этот  символ читаться  не будет. Если будет
встречен  символ  ограничитель,  он  останется  как  первый  символ
потока. По  умолчанию вторая функция get будет читать самое большее
n  символов,   но  не   больше  чем   одну  строку,  '\n'  является
ограничителем по  умолчанию. Необязательный  третий параметр задает
символ, который читаться не будет. Например:

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

будет читать  в buf  не  более  256  символов,  а  если  встретится
табуляция ('\t'),  то это приведет к возврату из get. В этом случае
следующим символом, который будет считан из cin, будет '\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 };

Если состояние  _good или  _eof, значит  последняя  операция  ввода
прошла успешно.  Если состояние  _good, то следующая операция ввода
может пройти  успешно, в  противном случае она закончится неудачей.
Другими словами,  применение операции  ввода к  потоку, который  не
находится  в  состоянии  _good,  является  пустой  операцией.  Если
делается попытка  читать в  переменную v,  и  операция  оканчивается
неудачей,  значение   v  должно   остаться  неизменным  (оно  будет
неизменным, если  v имеет один из тех типов, которые обрабатываются
функциями членами  istream или  ostream). Отличия между состояниями
_fail и  _bad очень  незначительно и представляет интерес только для
разработчиков операций ввода. В состоянии _fail предполагается, что
поток не  испорчен и  никакие символы не потеряны. В состоянии _bad
может быть все что угодно.

  Состояние потока можно проверять например так:

switch (cin.rdstate()) {
  case _good:
      // последняя операция над cin прошла успешно
      break;
  case _eof:
      // конец файла
      break;
  case _fail:
      // некоего рода ошибка форматирования
      // возможно, не слишком плохая
      break;
  case _bad:
      // возможно, символы cin потеряны
      break;
  }

  Для любой  переменной z типа, для которого определены операции << и>>, копирующий цикл можно написать так:

  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);
  };

Параметр sk  задает, должны пропускаться пропуски или нет. Параметр
t  (необязательный)   задает  указатель   на  ostream,  к  которому
прикреплен istream.  Например, cin  прикреплен к  cout; это значит,
что перед  тем, как  попытаться читать символы из своего файла, cin
выполняет

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

  С помощью функции istream::tie() можно прикрепить (или открепить,
с помощью tie(0)) любой ostream к любому istream. Например:

  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() { /* ... */}
  };

  Обратите внимание,  что здесь определяются указатели, необходимые
для работы  с буфером,  поэтому обычные посимвольные действия можно
определить (только один раз) в виде максимально эффективных inline-
функций. Для  каждой конкретной  стратегии  буферизации  необходимо
определять только  функции переполнения  overflow() и  underflow().
Например:

  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 Эффективность

8.8 Упражнения