Язык С++ не обеспечивает средств для ввода/вывода. Ему это и не нужно. Такие средства легко и элегантно можно создать с помощью самого языка. Описанная здесь стандартная библиотека потокового ввода/вывода обеспечивает гибкий и эффективный, с гаран

8.1 Введение

Разработка и реализация стандартных средств ввода/вывода для языка программирования зарекомендовала себя как заведомо трудная работа. Традиционно средства ввода/вывода разрабатывались исключительно для небольшого числа встроенных типов данных. Однако в

С++ разработан так, чтобы у пользователя была возможность определять новые типы столь же эффективные и удобные, сколь и встроенные типы. Поэтому обоснованным является требование того, что средства ввода/вывода для С++ должны обеспечиваться в С++

Средства ввода/вывода <stream.h> связаны исключительно с обработкой преобразования типизированных объектов в последовательности символов и обратно. Есть и другие схемы ввода/вывода, но эта является основополагающей в системе UNIX, и большая ч

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

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

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

  x = 123

  x = (1,2.4)

8.2 Вывод

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

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

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

  class ostream {
      // ...
  public:
      ostream& operator<<(char*);
      ostream&  operator<<(int  i){return *this<<long(i);}
      ostream& operator<<(long); ostream&
      operator<<(double);

      ostream& put(char);
  };

  cerr << "x = " << x;

  (cerr.operator<<("x = ")).operator<<(x);

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

Рассмотрим определяемый пользователем тип:

  class complex { double re, im;
  public:
      complex(double r = 0, double i = 0) { re=r; im=i; }

      friend double real(complex& a) { returna.re;  }
      friend double real(complex& a) { returna.re; }

      friend complex operator+(complex, complex);
      friend complex operator-(complex, complex);
      friend complex operator*(complex, complex);
      friend complex operator/(complex, complex);
      // ...
  };

  ostream& operator<<(ostream&s, complex z) {
      return s << "(" << real(z) << "," << imag(z) << ")";
  }

  complex x(1,2);
  // ...
  cout << "x = " << x << "\n";

  x = (1,2)

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

Операция вывода используется, чтобы избежать той многословности, которую дало бы использование функции вывода. Но почему <Возможности изобрести новый лексический символ нет (#6.2). Операция присваивания была кандидатом одновременно и на ввод, и на вывод, но оказывается, большинство людей предпочитают, чтобы операция ввода отличалась от операции вывода. Кроме того, = н

Делались попытки использовать операции < и >, но значения "меньше" и "больше" настолько прочно вросли в сознание людей, что новые операции ввода/вывода во всех реальных случаях оказались нечитаемыми. Помимо этого, "<" находится на большинстве клавиа

  cout < x , y , z;

Операции << и >> к такого рода проблемам не приводят, они асимметричны в том смысле, что их можно проассоциировать с "в" и "из", а приоритет << достаточно низок, чтобы можно было не использовать скобки для арифметических выражений в роли операндо

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

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

  cout << "a<<b=" << (a<<b) << "\n";

  cout << "x = " << x << '\n';

  #define sp << " "
  #define ht << "\t"
  #define nl << "\n"

  cout << "x = " << x nl;

Рассмотрим примеры:

  cout << x << " " << y << " " << z << "\n";
  cout << "x = " << x << ", y = " << y << "\n";

  cout << x sp << y sp << z nl;
  cout << "x = " << x  << ", y = " << y nl;

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

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

  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<<form("there were %d members present",no_of_members);

  there were 127 members present

* Объяснение того, как применяются строки формата, - это слегка отредактированный вариант спецификации printf(). (прим. автора)

Множество спецификаций преобразования довольно велико и обеспечивает высокую степень гибкости. После % может стоять:

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

d необязательная строка цифр, задающая ширину поля. Если преобразованное значение имеет меньше цифр, чем ширина поля, оно будет дополняться пробелами слева (или справа, если был задан индикатор выравнивания влево) до заполнения всей ширины

. необязательная точка, для отделения ширины поля от следующей строки цифр;

d необязательная строка цифр, специфицирующая точность, которая задает число цифр после десятичной точки для преобразований e и f или печатаемых символов для строки;

* в ширине поля или точности вместо строки цифр может стоять *. В этом случае ширина поля и точность задается целым параметром;

h необязательный символ h; указывает на то, что идущие за ним d, o, x или y соответствуют параметру короткое целое;

l необязательный символ h; указывает на то, что идущие за ним d, o, x или y соответствуют параметру длинное целое;

% указывает, что должен быть напечатан символ %, никакие параметры при этом не затрагиваются;

c символ, указывающий, какой тип преобразования должен применяться. Символы преобразования и их значения таковы:

• d целый параметр преобразуется в десятичную запись;
• o целый параметр преобразуется в восьмеричную запись;
• x целый параметр преобразуется в шестнадцатиричную запись;
• f параметр float или double преобразуется в десятичную запись вида [-]ddd.ddd, где число, задаваемое цифрами d после десятичной точки, эквивалентно спецификации точности для параметра. Если точность опущена, дается шесть цифр; если точнос
• e параметр float или double преобразуется в десятичную запись вида [-]d.ddde+dd, где перед десятичной точкой стоит одна цифра, а число, задаваемое цифрами после десятичной точки, эквивалентно спецификации точности для параметра; когда то
• g параметр float или double печатается в том из видов d,f или e, который обеспечивает полную точность при минимальной затрате места;
• c печатается символьный параметр, пустые символы игнорируются;
• s параметр воспринимается как строка (указатель на символ), и печатаются символы из строки до пустого символа или до тех пор, пока не будет достигнуто число символов, указанное спецификацией точности; но если точность равна нулю, печатают
• u беззнаковый целый параметр преобразуется в десятичную запись.

Вот более сложный пример:

  char* src_file_name;
  int  line;
  char* line_format = "\n#line %d \"%s\"\n";
  //...
  cout << "int a;\n";
  cout << form(line_format,line,src_file_name);
  cout << "int b;\n";

  int a;

  #line 13 "С++/main.c"
  int b;

  char x;
  // ...
  cout << form("bad input char: %s",x);

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

  class complex { float re,im;
  public:
      // ...
      char* string(char* format) { return form(format,re,im); }
  };
  // ...
  cout << z.string("(%.3f,%.3f)");

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

Иногда функция вывода должна быть virtual. Рассмотрим пример класса shape, который дает понятие фигуры (#1.18):

  class shape {
      // ...
  public:
      // ...
      virtual void draw(ostream& s); // рисует "this" на "s"
  };

  class circle : public shape { int radius;
  public:
      // ...
      void draw(ostream&);
  };

Чтобы поддерживать для таких классов стандартную парадигму вывода, операция << определяется так:

  ostream& operator <<(ostream& s, shape* p) {
      p->draw(s); return s;
  }

  while ( p = next() ) cout << p;

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

Потоки обычно связаны с файлами. Библиотека потоков создает стандартный поток ввода cin, стандартный поток вывода cout и стандартный поток ошибок cerr. Программист может открывать другие файлы и создавать для них потоки.

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

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

  class ostream {
      // ...
      ostream(streambuf* s);  //   связывает   с   буфером   потока
      ostream(int  fd);  //  связывание для файла
      ostream(int size, char* p); // связывает с вектором
  };

Описание стандартных потоков вывода cout и cerr, которое находится в исходных кодах библиотеки потоков ввода/вывода, выглядит так:

      // описать подходящее пространство буфера
  char cout_buf[BUFSIZE]

      // сделать "filebuf" для управления этим пространством
      // связать его с UNIX'овским потоком вывода 1 (уже открытым)
  filebuf cout_file(1,cout_buf,BUFSIZE);

      // сделать ostream, обеспечивая пользовательский интерфейс
  ostream cout(&cout_file);

  char cerr_buf[1];

      // длина 0, то есть, небуферизованный
      // UNIX'овский поток вывода 2 (уже открытый)
  filebuf cerr_file(2,cerr_buf,0);

  ostream cerr(&cerr_file);

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

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

  ostream::~ostream() {
      flush(); // сброс
  }

  cout.flush();

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

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

  #include <stream.h>

  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.4.2). При завершении программы открытые файлы неявно закрываются.

Файл можно также открыть одновременно для чтения и записи, но в тех случаях, когда это оказывается необходимо, парадигма потоков редко оказывается идеальной. Часто лучше рассматривать такой файл как вектор (гигантских размеров). Можно определ

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

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

  cout = cerr;

8.4 Ввод

Ввод аналогичен выводу. Имеется класс istream, который предоставляет операцию >> ("взять из") для небольшого множества стандартных типов. Функция operator>> может определяться для типа, определяемого пользователем.

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

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

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

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

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

Стандартный заголовочный файл <ctype.h> определяет несколько функций, которые могут оказаться полезными при осуществлении ввода:

  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";

Когда в качестве условия используется поток, происходит проверка состояния потока, и эта проверка проходит успешно (то есть, значение условия не ноль) только если состояние _good. В частности, в предыдущем цикле проверялось состояние istream, ко

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

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

Операция установки состояния названа clear() (очистить), потому что она чаще всего используется для установки состояния потока заново как _good. _good является значением параметра по умолчанию и для istream::clear(), и для ostream::clear().

Над операциями ввода надо поработать еще. Было бы, в частности, замечательно, если бы можно было задавать ввод в терминах образца (как в языках Snobol и Icon), а потом проверять, прошла ли успешно вся операция ввода. Такие операции должны были бы

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 << "извините, попробуйте еще раз: ";
    }
   }
  }

Символ можно вернуть в поток с помощью функции istream::putback(char). Это позволяет программе "заглядывать вперед" в поток ввода.

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

В помощью ostream можно отформатировать сообщения, которые не нужно печатать тотчас же:

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

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

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

Описание буфера потока в <stream.h> выглядит так:

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

Можно было бы ожидать, что раз ввод/вывод <stream.h> определен с помощью общедоступных средств языка, он будет менее эффективен, чем встроенное средство. На самом деле это не так. Для действий вроде "поместить символ в поток" используются inline

8.8 Упражнения

1. (*1.5) Считайте файл чисел с плавающей точкой, составьте из пар считанных чисел комплексные числа и выведите комплексные числа.
2. (*1.5) Определите тип name_and_address (имя_и_адрес). Определите для него << и >>. Скопируйте поток объектов name_and_address.
3. (*2) Постройте несколько функций для запроса и чтения различного вида информации. Простейший пример - функция y_or_n() в #8.4.4. Идеи: целое, число с плавающей точкой, имя файла, почтовый адрес, дата, личные данные и т.д. Постарайтесь сделать их
4. (*1.5) Напишите программу, которая печатает (1) все буквы в нижнем регистре, (2) все буквы, (3) все буквы и цифры, (4) все символы, которые могут встречаться в идентификаторах С++ на вашей системе, (5) все символы пунктуации, (6) целые значени
5. (*4) Реализуйте стандартную библиотеку ввода/вывода C (<stdio.h>) с помощью стандартной библиотеки ввода/вывода С++ (<stream.h>).
6. (*4) Реализуйте стандартную библиотеку ввода/вывода С++ (<stream.h>) с помощью стандартной библиотеки ввода/вывода C (<stdio.h>).
7. (*4) Реализуйте стандартные библиотеки C и С++ так, чтобы они могли использоваться одновременно.
8. (*2) Реализуйте класс, для которого [] перегружено для реализации случайного чтения символов из файла.
9. (*3) Как Упражнение 8, только сделайте, чтобы [] работало и для чтения, и для записи. Подсказка: сделайте, чтобы [] возвращало объект "дескрипторного типа", для которого присваивание означало бы присвоить файлу через дескриптор, а неявное преобра
10. (*2) Как Упражнение 9, только разрешите [] индексировать записи некоторого вида, а не символы.
11. (*3) Сделайте обобщенный вариант класса, определенного в Упражнении 10.
12. (*3.5) Разработайте и реализуйте операцию ввода по сопоставлению с образцом. Для спецификации образца используйте строки формата в духе printf. Должна быть возможность попробовать сопоставить со вводом несколько образцов для нахождения фактическо
13. (*4) Придумайте (и реализуйте) вид образцов, которые намного лучше.

<--НАЗАД 

Copyright © by Alex Skums

Сайт создан в системе uCoz