current = new Link<K,V>(k,def_val);
              current->pre = p->pre;
              current->suc = p;
              if (p == head)  // текущий элемент становится начальным
                 head = current;
              else
                 p->pre->suc = current;
              p->pre = current;
              return current->value;
            }

            Link<K,V>* s = p->suc;
            if (s == 0) {  // вставить после p (в конец)
               current = new Link<K,V>(k,def_val);
               current->pre = p;
               current->suc = 0;
               p->suc = current;
               return current->value;
            }
            p = s;
          }
        }

 Операция индексации возвращает ссылку на значение, которое
 соответствует заданному как параметр ключу. Если такое значение
 не найдено, возвращается новый элемент со стандартным значением.
 Это позволяет использовать операцию индексации в левой части
 присваивания. Стандартные значения для ключей и значений
 устанавливаются конструкторами Map. В операции индексации определяется
 значение current, используемое итераторами.
     Реализация остальных функций-членов оставлена в качестве
 упражнения:

         template<class K, class V>
         void  Map<K,V>::remove(const K& k)
         {
            // см. упражнение 2 из $$8.10
         }

         template<class K, class V>
         Map<K,V>::Map(const Map<K,V>& m)
         {
            // копирование таблицы Map и всех ее элементов
         }

         template<class K, class V>
         Map& Map<K,V>::operator=(const Map<K,V>& m)
         {
            // копирование таблицы Map и всех ее элементов
         }

    Теперь нам осталось только определить итерацию. В классе Map
 есть функции-члены first(), last() и element(const K&), которые
 возвращают итератор, установленный соответственно на первый, последний
 или задаваемый ключом-параметром элемент. Сделать это можно, поскольку
 элементы хранятся в упорядоченном по ключам виде.
    Итератор Mapiter для Map определяется так:

         template<class K, class V> class Mapiter {
           friend class Map<K,V>;

           Map<K,V>* m;
           Link<K,V>* p;

           Mapiter(Map<K,V>* mm, Link<K,V>* pp)
               { m = mm; p = pp; }
         public:
           Mapiter() { m = 0; p = 0; }
           Mapiter(Map<K,V>& mm);

           operator void*() { return p; }

           const K& key();
           V& value();

           Mapiter& operator--();  // префиксная
           void operator--(int);   // постфиксная
           Mapiter& operator++();  // префиксная
           void operator++(int);   // постфиксная
         };

 После позиционирования итератора функции key() и value() из Mapiter
 выдают ключ и значение того элемента, на который установлен
 итератор.

        template<class K, class V> const K& Mapiter<K,V>::key()
        {
          if (p) return p->key; else return m->def_key;
        }

        template<class K, class V> V& Mapiter<K,V>::value()
        {
          if (p) return p->value; else return m->def_val;
        }

 По аналогии с указателями определены операции ++ и -- для продвижения
 по элементам Map вперед и назад:

      Mapiter<K,V>& Mapiter<K,V>::operator--() //префиксный декремент
      {
        if (p) p = p->pre;
        return *this;
      }

      void Mapiter<K,V>::operator--(int)  // постфиксный декремент
      {
        if (p) p = p->pre;
      }

      Mapiter<K,V>& Mapiter<K,V>::operator++() // префиксный инкремент
      {
        if (p) p = p->suc;
        return *this;
      }

      void Mapiter<K,V>::operator++(int)   // постфиксный инкремент
      {
        if (p) p = p->suc;
      }

 Постфиксные операции определены так, что они не возвращают никакого
 значения. Дело в том, что затраты на создание и передачу нового
 объекта Mapiter на каждом шаге итерации значительны, а польза от
 него будет не велика.
     Объект Mapiter можно инициализировать так, чтобы он был
 установлен на начало Map:

      template<class K, class V> Mapiter<K,V>::Mapiter(Map<K,V>& mm)
      {
          m == &mm; p = m->head;
       }

     Операция преобразования operator void*() возвращает нуль, если
 итератор не установлен на элемент Map, и ненулевое значение иначе.
 Значит можно проверять итератор iter, например, так:

         void f(Mapiter<const char*, Shape*>& iter)
         {
           // ...
           if (iter) {
            // установлен на элемент таблицы
           }
           else {
            // не установлен на элемент таблицы
           }

           // ...
         }

 Аналогичный прием используется для контроля потоковых операций
 ввода-вывода в $$10.3.2.
     Если итератор не установлен на элемент таблицы, его функции
 key() и value() возвращают ссылки на стандартные объекты.
     Если после всех этих определений вы забыли их назначение, можно
 привести еще одну небольшую программу, использующую таблицу Map.
 Пусть входной поток является списком пар значений следующего вида:

           hammer       2
           nail         100
           saw          3
           saw          4
           hammer       7
           nail         1000
           nail         250

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

           hammer        9
           nail          1350
           saw           7
           -------------------
           total         1366

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

           template<class K, class V>
              void readlines(Map<K,V>&key)
              {
                K word;
                while (cin >> word) {
                  V val  = 0;
                  if (cin >> val)
                     key[word] +=val;
                  else
                     return;
                }
              }

 Теперь можно написать простую программу, вызывающую функцию
 readlines() и печатающую получившуюся таблицу:

            main()
            {
              Map<String,int> tbl("nil",0);
              readlines(tbl);

              int total = 0;
              for (Mapiter<String,int> p(tbl); p; ++p) {
                  int val = p.value();
                  total +=val;
                  cout << p.key() << '\t' << val << '\n';
              }

              cout << "--------------------\n";
              cout << "total\t" << total << '\n';
            }

        8.9 Упражнения

 1. (*2) Определите семейство списков с двойной связью, которые
    будут двойниками списков с одной связью, определенных в $$8.3.
 2. (*3) Определите шаблон типа String, параметром которого является
    тип символа. Покажите как его можно использовать не только для
    обычных символов, но и для гипотетического класса lchar, который
    представляет символы не из английского алфавита или расширенный
    набор символов. Нужно постараться так определить String, чтобы
    пользователь не заметил ухудшения характеристик программы по
    памяти и времени или в удобстве по сравнению с обычным строковым
    классом.
 3. (*1.5) Определите класс Record (запись) с двумя членами-данными:
    count (количество) и  price (цена). Упорядочите вектор из таких
    записей по каждому из членов. При этом нельзя изменять функцию
    сортировки и шаблон Vector.
 4. (*2) Завершите определения шаблонного класса Map, написав
    недостающие функции-члены.
 5. (*2) Задайте другую реализацию Map из $$8.8, используя списочный
    класс с двойной связью.
 6. (*2.5) Задайте другую реализацию Map из $$8.8, используя
    сбалансированное дерево. Такие деревья описаны в $$6.2.3 книги
    Д. Кнут "Искусство программирования для ЭВМ" т.1, "Мир", 1978 [K].
 7. (*2) Сравните качество двух реализаций Map. В первой используется
    класс Link со своей собственной функцией размещения, а во второй
    - без нее.
 8. (*3) Сравните производительность программы подсчета слов из
    $$8.8  и такой же программы, не использующей класса Map. Операции
    ввода-вывода должны одинаково использоваться в обеих программах.
    Сравните несколько таких программ, использующих разные варианты
    класса Map, в том числе и класс из вашей библиотеки, если он там
    есть.
 9. (*2.5) С помощью класса Map реализуйте топологическую сортировку.
    Она описана в [K] т.1, стр. 323-332. (см. упражнение 6).
 10. (*2) Модифицируйте программу из $$8.8 так, чтобы она работала
    правильно для длинных имен и для имен, содержащих пробелы
    (например, "thumb back").
 11. (*2) Определите шаблон типа для чтения различных видов строк,
    например, таких (предмет, количество, цена).
 12. (*2) Определите класс Sort из $$8.4.5, использующий сортировку
    по методу Шелла. Покажите как можно задать метод сортировки
    с помощью параметра шаблона. Алгоритм сортировки описан в [K]
    т.3, $$5.2.1 (см. упражнение 6).
 13. (*1) Измените определения Map и Mapiter так, чтобы постфиксные
    операции ++ и -- возвращали объект Mapiter.
 14. (*1.5) Используйте шаблоны типа в стиле модульного
    программирования, как это было показано в $$8.4.5 и напишите
    функцию сортировки, рассчитанную сразу на Vector<T> и T[].





         * ГЛАВА 9

        Я прервал вас, поэтому не прерывайте меня.
          - Уинстон Черчилл

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

        9.1 Обработка ошибок

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

 Ь Только недавно комитетом по стандартизации С++ особые ситуации были
 включены в стандарт языка, но на время написания этой книги они еще
 не вошли в большинство реализаций.

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

               class Vector {
                 int* p;
                 int  sz;
               public:
                 class Range  {  };  // класс для особой ситуации

                 int& operator[](int i);

                 // ...
               };

  Предполагается, что объекты класса Range будут использоваться как
  особые ситуации, и запускать их можно так:

               int& Vector::operator[](int i)
               {
                 if (0<=i && i<sz) return p[i];
                 throw Range();
               }

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

           void f(Vector& v)
           {
            // ...

            try {
             do_something(v);  // содержательная часть, работающая с v
            }
            catch (Vector::Range) {
            // обработчик особой ситуации Vector::Range

            // если do_something() завершится неудачно,
            // нужно как-то среагировать на это

            // сюда мы попадем только в том случае, когда
            // вызов do_something() приведет к вызову Vector::operator[]()
            // из-за недопустимого значения индекса

            }

            // ...
          }

Обработчиком особой ситуации называется конструкция

           catch ( /* ... */ ) {
             // ...
           }

 Ее можно использовать только сразу после блока, начинающегося служебным
 словом try, или сразу после другого обработчика особой ситуации. Служебным
 является и слово catch. После него идет в скобках описание, которое
 используется аналогично описанию формальных параметров функции, а именно,
 в нем задается тип объектов, на которые рассчитан обработчик, и,
 возможно, имена параметров (см. $$9.3). Если в do_something() или в
 любой вызванной из нее функции произойдет ошибка индекса (на любом
 объекте Vector), то обработчик перехватит особую ситуацию и будет
 выполняться часть, обрабатывающая ошибку. Например, определения следующих
 функций приведут к запуску обработчика в f():

          void do_something()
          {
            // ...
            crash(v);
            // ...
          }

          void crash(Vector& v)
          {
             v[v.size()+10];  // искусственно вызываем ошибку индекса
          }

    Процесс запуска и перехвата особой ситуации предполагает просмотр
 цепочки вызовов от точки запуска особой ситуации до функции, в которой
 она перехватывается. При этом восстанавливается состояние стека,
 соответствующее функции, перехватившей ошибку, и при проходе по всей
 цепочке вызовов для локальных объектов функций из этой цепочки вызываются
 деструкторы. Подробно это описано в $$9.4.
    Если при просмотре всей цепочки вызовов, начиная с запустившей
 особую ситуацию функции, не обнаружится подходящий обработчик, то
 программа завершается. Подробно это описано в $$9.7.
    Если обработчик перехватил особую ситуацию, то она будет обрабатываться
 и другие, рассчитанные на эту ситуацию, обработчики не будут
 рассматриваться. Иными словами, активирован будет только тот обработчик,
 который находится в самой последней вызывавшейся функции, содержащей
 соответствующие обработчики. В нашем примере функция f() перехватит
 Vector::Range, поэтому эту особую ситуацию нельзя перехватить ни в
 какой вызывающей f() функции:

          int ff(Vector& v)
          {
            try {
                  f(v);         // в f() будет перехвачена Vector::Range
            }
            catch (Vector::Range) { // значит сюда мы никогда не попадем
               // ...
            }
          }

        9.1.1 Особые ситуации и традиционная обработка ошибок

 Наш способ обработки ошибок по многим параметрам выгодно отличается от
 более традиционных способов. Перечислим, что может сделать операция
 индексации Vector::operator[]() при обнаружении недопустимого значения
 индекса:
     [1] завершить программу;
     [2] возвратить значение, трактуемое как "ошибка";
     [3] возвратить нормальное значение и оставить программу в
         неопределенном состоянии;
     [4] вызвать функцию, заданную для реакции на такую ошибку.
   Вариант [1] ("завершить программу") реализуется по умолчанию в том
 случае, когда особая ситуация не была перехвачена. Для большинства
 ошибок можно и нужно обеспечить лучшую реакцию.
   Вариант [2] ("возвратить значение "ошибка"") можно реализовать
 не всегда, поскольку не всегда удается определить значение "ошибка".
 Так, в нашем примере любое целое является допустимым значением для
 результата операции индексации. Если можно выделить такое особое
 значение, то часто этот вариант все равно оказывается неудобным,
 поскольку проверять на это значение приходится при каждом вызове. Так
 можно легко удвоить размер программы. Поэтому для обнаружения всех
 ошибок этот вариант редко используется последовательно.
    Вариант [3] ("оставить программу в неопределенном состоянии")
 имеет тот недостаток, что вызывавшая функция может не заметить
 ненормального состояния программы. Например, во многих функциях
 стандартной библиотеки С для сигнализации об ошибке устанавливается
 соответствующее значение  глобальной переменной errno. Однако,
 в программах пользователя обычно нет достаточно последовательного
 контроля errno, и в результате возникают наведенные ошибки,
 вызванные тем, что стандартные функции возвращают не то значение.
 Кроме того, если в программе есть параллельные вычисления,
 использование одной глобальной переменной для сигнализации о разных
 ошибках неизбежно приведет к катастрофе.
   Обработка особых ситуаций не предназначалась для тех случаев,
 на которые рассчитан вариант [4] ( "вызвать функцию реакции на
 ошибку"). Отметим, однако, что если особые ситуации не предусмотрены,
 то вместо функции реакции на ошибку можно как раз использовать
 только один из трех перечисленных вариантов. Обсуждение функций
 реакций и особых ситуацией будет продолжено в $$9.4.3.
   Механизм особых ситуаций успешно заменяет традиционные
 способы обработки ошибок в тех случаях, когда последние являются
 неполным, некрасивым или чреватым ошибками решением. Этот механизм
 позволяет явно отделить часть программы, в которой обрабатываются
 ошибки, от остальной ее части, тем самым программа становится более
 понятной и с ней проще работать различным сервисным программам.
 Свойственный этому механизму регулярный способ обработки ошибок
 упрощает взаимодействие между раздельно написанными частями
 программы.
    В этом способе обработки ошибок есть для программирующих на С
 новый момент: стандартная реакция на ошибку (особенно на ошибку
 в библиотечной функции) состоит в завершении программы. Традиционной
 была реакция продолжать программу в надежде, что она как-то
 завершится сама. Поэтому способ, базирующийся на особых ситуациях,
 делает программу более "хрупкой" в том смысле, что требуется
 больше усилий и внимания для ее нормального выполнения. Но это все-таки
 лучше, чем получать неверные результаты на более поздней стадии
 развития программы (или получать их еще позже, когда программу
 сочтут завершенной и передадут ничего не подозревающему пользователю).
 Если завершение программы является неприемлемой реакцией, можно
 смоделировать традиционную реакцию с помощью перехвата всех особых
 ситуаций или всех особых ситуаций, принадлежащих специальному
 классу ($$9.3.2).
    Механизм особых ситуаций можно рассматривать как динамический
 аналог механизма контроля типов и проверки неоднозначности
 на стадии трансляции. При таком подходе более важной становится
 стадия проектирования программы, и требуется большая поддержка
 процесса выполнения программы, чем для программ на С. Однако,
 в результате получится более предсказуемая программа, ее будет проще
 встроить в программную систему, она будет понятнее другим программистам и
 с ней проще будет работать различным сервисным программам. Можно
 сказать, что механизм особых ситуаций поддерживает,
 подобно другим средствам С++, "хороший" стиль программирования,
 который в таких языках, как С, можно применять только не в полном
 объеме и на неформальном уровне.
    Все же надо сознавать, что обработка ошибок остается трудной
 задачей, и, хотя механизм особых ситуаций более строгий,
 чем традиционные способы, он все равно недостаточно структурирован
 по сравнению с конструкциями, допускающими только локальную передачу
 управления.

        9.1.2 Другие точки зрения на особые ситуации

 "Особая ситуация" - одно из тех понятий, которые имеют разный смысл
 для разных людей. В С++ механизм особых ситуаций предназначен для
 обработки ошибок. В частности, он предназначен для обработки ошибок
 в программах, состоящих из независимо создаваемых компонентов.
    Этот механизм рассчитан на особые ситуации, возникающие только при
 последовательном выполнении программы (например, контроль границ
 массива). Асинхронные особые ситуации такие, например, как прерывания
 от клавиатуры, нельзя непосредственно обрабатывать с помощью этого
 механизма. В различных системах существуют другие механизмы,
 например, сигналы, но они здесь не рассматриваются, поскольку зависят
 от конкретной системы.
    Механизм особых ситуаций является конструкцией с нелокальной
 передачей управления и его можно рассматривать как вариант оператора
 return. Поэтому особые ситуации можно использовать для целей, никак
 не связанных с обработкой ошибок ($$9.5). Все-таки основным
 назначением механизма особых ситуаций и темой этой главы будет
 обработка ошибок и создание устойчивых к ошибкам программ.

        9.2 Различение особых ситуаций

 Естественно, в программе возможны несколько различных динамических
 ошибок. Эти ошибки можно сопоставить с особыми ситуациями, имеющими
 различные имена. Так, в классе Vector обычно приходится выявлять
 и сообщать об ошибках двух видов: ошибки диапазона и ошибки,
 вызванные неподходящим для конструктора параметром:

         class Vector {
           int* p;
           int sz;
         public:
           enum { max = 32000 };
           class Range { };  // особая ситуация индекса
           class Size { };   // особая ситуация "неверный размер"
           Vector(int sz);
           int& operator[](int i);

           // ...
        };

 Как было сказано, операция индексации запускает особую ситуацию
 Range, если ей задан выходящий из диапазона значений индекс.
 Конструктор запускает особую ситуацию Size, если ему задан
 недопустимый размер вектора:

        Vector::Vector(int sz)
        {
          if (sz<0 || max<sz) throw Size();
          // ...
        }

 Пользователь класса Vector может различить эти две особые ситуации,
 если в проверяемом блоке (т.е. в блоке оператора try) укажет
 обработчики для обеих ситуаций:

        void f()
        {
          try {
              use_vectors();
          }
          catch (Vector::Range) {
              // ...
          }
          catch (Vector::Size) {
              // ...
          }
        }

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

        void f()
        {
          try {
             use_vectors();
          }
          catch (Vector::Range) {
             // исправить индекс и
             // попробовать опять:
             f();
          }
          catch (Vector::Size) {
             cerr << "Ошибка в конструкторе Vector::Size";
             exit(99);
          }
          // сюда мы попадем, если вообще не было особых ситуаций
          // или после обработки особой ситуации Range
       }

 Список обработчиков напоминает переключатель, но здесь в теле
 обработчика операторы break не нужны. Синтаксис списка обработчиков
 отличен от синтаксиса вариантов case переключателя частично по
 этой причине, частично потому, чтобы показать, что каждый
 обработчик определяет свою область видимости (см. $$9.8).
    Не обязательно все особые ситуации перехватывать в одной функции:

       void f1()
       {
         try {
           f2(v);
         }
         catch (Vector::Size) {
         // ...
         }
       }

       void f2(Vector& v)
       {
         try {
            use_vectors();
         }
         catch (Vector::Range) {
         // ...
         }
       }

 Здесь f2() перехватит особую ситуацию Range, возникающую в
 use_vectors(), а особая ситуация Size будет оставлена для f1().
   С точки зрения языка особая ситуация считается обработанной сразу
 при входе в тело ее обработчика. Поэтому все особые ситуации,
 запускаемые при выполнении этого обработчика, должны обрабатываться
 в функциях, вызвавших ту функцию, которая содержит проверяемый блок.
 Значит в следующем примере не возникнет бесконечного цикла:

        try {
            // ...
        }
        catch (input_overflow) {
           // ...
           throw input_overflow();
        }

 Здесь input_overflow (переполнение при вводе) - имя глобального класса.
   Обработчики особых ситуаций могут быть вложенными:

        try {
           // ...
        }
        catch (xxii) {
          try {
             // сложная реакция
          }
          catch (xxii) {
             // ошибка в процессе сложной реакции
          }
        }

 Однако, такая вложенность редко бывает нужна в обычных программах,
 и чаще всего она является свидетельством плохого стиля.

        9.3 Имена особых ситуаций

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

        class Vector {
           // ...
        public:
           class Range {
           public:
             int index;
             Range(int i) : index(i) { }
          };
          // ...
          int& operator[](int i)
          // ...
       };

       int Vector::operator[](int i)
       {
         if (o<=i && i <sz) return p[i];
         throw Range(i);
       }

 Чтобы исследовать недопустимое значение индекса, в обработчике
 нужно дать имя объекту, представляющему особую ситуацию:

       void  f(Vector& v)
       {
         // ...

        try {
            do_something(v);
        }
        catch (Vector::Range r ) {
           cerr << "недопустимый индекс" << r.index << '\n';
           // ...
        }
        // ...
      }

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

       template<class T> class Allocator {
          // ...
          class Exhausted { }
          // ...
          T* get();
      };

      void f(Allocator<int>& ai, Allocator<double>& ad)
      {
         try {
             // ...
         }
         catch (Allocator<int>::Exhausted) {
            // ...
         }
         catch (Allocator<double>::Exhausted) {
           // ...
         }
       }

 С другой стороны, особая ситуация может быть общей для всех
 созданных по шаблону классов:

       class Allocator_Exhausted { };

       template<class T> class Allocator {
          // ...
          T* get();
       };

       void f(Allocator<int>& ai, Allocator<double>& ad)
       {
         try {
            // ...
         }
         catch (Allocator_Exhausted) {
            // ...
         }
       }

 Какой способ задания особой ситуации предпочтительней, сказать трудно.
 Выбор зависит от назначения рассматриваемого шаблона.

        9.3.1 Группирование особых ситуаций

 Особые ситуации естественным образом разбиваются на семейства.
 Действительно, логично представлять семейство Matherr, в которое
 входят Overflow (переполнение), Underflow (потеря значимости) и
 некоторые другие особые ситуации. Семейство Matherr образуют
 особые ситуации, которые могут запускать математические функции
 стандартной библиотеки.
   Один из способов задания такого семейства сводится к определению
 Matherr как типа, возможные значения которого включают Overflow и
 все остальные:

         enum { Overflow, Underflow, Zerodivide, /* ... */ };

         try {
             // ...
         }
         catch (Matherr m) {
             switch (m) {
             case Overflow:
                  // ...
             case Underflow:
                  // ...
             // ...
             }
             // ...
         }

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

          class Matherr { };
          class Overflow: public Matherr { };
          class Underflow: public Matherr { };
          class Zerodivide: public Matherr { };
          // ...

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

          try {
             // ...
          }
          catch (Overflow) {
             // обработка Overflow или любой производной ситуации
          }
          catch (Matherr) {
              // обработка любой отличной от Overflow ситуации
          }

    В этом примере Overflow разбирается отдельно, а все другие особые
 ситуации из Matherr разбираются как один общий случай. Конечно,
 функция, содержащая catch (Matherr), не будет знать какую именно
 особую ситуацию она перехватывает. Но какой бы она ни была, при
 входе в обработчик передаваемая ее копия будет Matherr. Обычно это
 как раз то, что нужно. Если это не так, особую ситуацию можно
 перехватить по ссылке (см. $$9.3.2).
    Иерархическое упорядочивание особых ситуаций может играть важную
 роль для создания ясной структуры программы. Действительно, пусть
 такое упорядочивание отсутствует, и нужно обработать все особые
 ситуации стандартной библиотеки математических функций. Для этого
 придется до бесконечности перечислять все возможные особые ситуации:

          try {
              // ...
          }
          catch (Overflow) { /* ... */ }
          catch (Underflow) { /* ... */ }
          catch (Zerodivide) { /* ... */ }
          // ...

 Это не только утомительно, но и опасно, поскольку можно забыть
 какую-нибудь особую ситуацию. Кроме того, необходимость перечислить
 в проверяемом блоке все особые ситуации практически гарантирует,
 что, когда семейство особых ситуаций библиотеки расширится, в
 программе пользователя возникнет ошибка. Это значит, что при
 введении новой особой ситуации в библиотеки математических функций
 придется перетранслировать все части программы, которые содержат
 обработчики всех особых ситуаций из Matherr. В общем случае такая
 перетрансляция неприемлема. Часто даже нет возможности найти
 все требующие перетрансляции части программы. Если такая
 возможность есть, нельзя требовать, чтобы всегда был
 доступен исходной текст любой части большой программы, или чтобы у нас
 были права изменять любую часть большой программы, исходный текст
 которой мы имеем. На самом деле, пользователь не должен думать
 о внутреннем устройстве библиотек. Все эти проблемы перетрансляции
 и сопровождения могут привести к тому, что после создания
 первой версии библиотеки будет нельзя вводить в ней новые
 особые ситуации. Но такое решение не подходит практически для всех
 библиотек.
     Все эти доводы говорят за то, что особые ситуации нужно
 определять как иерархию классов (см. также $$9.6.1). Это, в свою
 очередь, означает, что особые ситуации могут быть членами нескольких
 групп:

         class network_file_err  // ошибки файловой системы в сети
           : public network_err, // ошибки сети
             public file_system_err { // ошибки файловой системы
             // ...
         };

 Особую ситуацию network_file_err можно перехватить в функциях,
 обрабатывающих особые ситуации сети:

         void f()
         {
           try {
               // какие-то операторы
           }
           catch (network_err) {
               // ...
           }
         }

 Ее также можно перехватить в функциях, обрабатывающих особые ситуации
 файловой системы:

         void g()
         {
            try {
                // какие-то другие операторы
            }
            catch (file_system_err) {
                // ...
            }
          }

 Это важный момент, поскольку такой системный сервис как работа в
 сети должен быть прозрачен, а это означает, что создатель функции
 g() может даже и не знать, что эта функция будет выполняться
 в сетевом режиме.
     Отметим, что в настоящее время нет стандартного множества
 особых ситуаций для стандартной математической библиотеки и
 библиотеки ввода-вывода. Задача комитетов ANSI и ISO по стандартизации
 С++ решить нужно ли такое множество и какие в нем следует использовать
 имена и классы.
     Поскольку можно сразу перехватить все особые ситуации
 (см. $$9.3.2), нет настоятельной необходимости создавать для этой
 цели общий, базовый для всех особых ситуаций, класс. Однако, если
 все особые ситуации являются производными от пустого класса
 Exception (особая ситуация), то в интерфейсах их использование
 становится более регулярным (см. $$9.6). Если вы используете общий
 базовый класс Exception, убедитесь, что в нем ничего нет кроме
 виртуального деструктора. В противном случае такой класс может
 вступить в противоречие с предполагаемым стандартом.

        9.3.2 Производные особые ситуации

 Если для обработки особых ситуаций мы используем иерархию классов,
 то, естественно, каждый обработчик должен разбираться только с
 частью информации, передаваемой при особых ситуациях. Можно сказать,
 что, как правило, особая ситуация перехватывается обработчиком
 ее базового класса, а не обработчиком класса, соответствующего
 именно этой особой ситуации. Именование и перехват обработчиком особой
 ситуации семантически эквивалентно именованию и получению параметра
 в функции. Проще говоря, формальный параметр инициализируется
 значением фактического параметра. Это означает, что запущенная
 особая ситуация "низводится" до особой ситуации, ожидаемой
 обработчиком. Например:

           class Matherr {
             // ...
             virtual void debug_print();
           };

           class Int_overflow : public Matherr {
           public:
              char* op;
              int opr1, opr2;;
              int_overflow(const char* p, int a, int b)
                 { cerr << op << '(' << opr1 << ',' << opr2 << ')'; }
           };

           void f()
           {
             try {
                 g();
             }
             catch (Matherr m) {
                 // ...
             }
           }

 При входе в обработчик Matherr особая ситуация m является объектом
 Matherr, даже если при обращении к g() была запущена Int_overflow.
 Это означает, что дополнительная информация, передаваемая в
 Int_overflow, недоступна.
     Как обычно, чтобы иметь доступ к дополнительной информации можно
 использовать указатели или ссылки. Поэтому можно было написать так:

           int add(int x, int y)   // сложить x и y с контролем
           {
             if (x > 0 && y > 0 && x > MAXINT - y
              || x < 0 && y < 0 && x < MININT + y)
                 throw Int_overflow("+", x, y);

              // Сюда мы попадаем, либо когда проверка
              // на переполнение дала отрицательный результат,
              // либо когда x и y имеют разные знаки

              return x + y;
            }

            void f()
            {
               try {
                  add(1,2);
                  add(MAXINT,-2);
                  add(MAXINT,2);  // а дальше - переполнение
               }
               catch (Matherr& m) {
                  // ...
                  m.debug_print();
               }
             }

 Здесь последнее обращение к add приведет к запуску особой ситуации,
 который, в свою очередь, приведет к вызову Int_overflow::debug_print().
 Если бы особая ситуация передавалась по значению, а не по ссылке, то
 была бы вызвана функция Matherr::debug_print().
     Нередко бывает так, что перехватив особую ситуацию, обработчик
 решает, что с этой ошибкой он ничего не сможет поделать. В таком
 случае самое естественное запустить особую ситуацию  снова в надежде,
 что с ней сумеет разобраться другой обработчик:

              void h()
              {
                try {
                    // какие-то операторы
                }
                catch (Matherr) {
                  if (can_handle_it) { // если обработка возможна,
                     // сделать ее
                  }
                  else {
                     throw;  // повторный запуск перехваченной
                             // особой ситуации
                  }
                }
              }

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

               void k()
               {
                 try {
                   h();
                   // ...
                 }
                 catch (Int_overflow) {
                   // ...
                 }
               }

     Полезен вырожденный случай перезапуска. Как и для функций,
  эллипсис ... для обработчика означает "любой параметр", поэтому
  оператор catch (...) означает перехват любой особой ситуации:

               void m()
               {
                  try {
                     // какие-то операторы
                  }
                  catch (...) {
                     // привести все в порядок
                     throw;
                  }

               }

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

              try {
                 // ...
              }
              catch (ibuf) {
                 // обработка переполнения буфера ввода
              }
              catch (io) {
                 // обработка любой ошибки ввода-вывода
              }
              catch (stdlib) {
                 // обработка любой особой ситуации в библиотеке
              }
              catch (...) {
                 // обработка всех остальных особых ситуаций
              }

      Тип особой ситуации в обработчике соответствует типу запущенной
 особой ситуации в следующих случаях: если эти типы совпадают, или
 второй тип является типом доступного базового класса запущенной ситуации,
 или он является указателем на такой класс, а тип ожидаемой ситуации
 тоже указатель ($$R.4.6).
      Поскольку транслятору известна иерархия классов, он способен
 обнаружить такие нелепые ошибки, когда обработчик  catch (...) указан
 не последним, или когда обработчик ситуации базового класса
 предшествует обработчику производной от этого класса ситуации
 ($$R15.4). В обоих случая, последующий обработчик (или обработчики)
 не могут быть запущены, поскольку они "маскируются" первым
 обработчиком.


        9.4 Запросы ресурсов

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

            void use_file(const char* fn)
            {
              FILE* f = fopen(fn,"w");

              // работаем с f

              fclose(f);
            }

 Все это выглядит вполне нормально до тех пор, пока вы не поймете,
 что при любой ошибке, происшедшей после вызова fopen() и до вызова
 fclose(), возникнет особая ситуация, в результате которой мы
 выйдем из use_file(), не обращаясь к fclose().Ь

 Ь Стоит сказать, что та же проблема возникает и в языках, не
 поддерживающих особые ситуации. Так, обращение к функции longjump()
 из стандартной библиотеки С может иметь такие же неприятные
 последствия.

 Если вы создаете устойчивую к ошибкам системам, эту проблему
 придется решать. Можно дать примитивное решение:

            void use_file(const char* fn)
            {
              FILE* f = fopen(fn,"w");
              try {
                  // работаем с f
              }
              catch (...) {
                  fclose(f);
                  throw;
              }
              fclose(f);
            }

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

           void acquire()
           {
             // запрос ресурса 1
             // ...
             // запрос ресурса n

             // использование ресурсов

             // освобождение ресурса n
             // ...
             // освобождение ресурса 1
           }

 Как правило бывает важно, чтобы ресурсы освобождались в обратном
 по сравнению с запросами порядке. Это очень сильно напоминает порядок
 работы с локальными объектами, создаваемыми конструкторами и
 уничтожаемыми деструкторами. Поэтому мы можем решить проблему запроса и
 освобождения ресурсов, если будем использовать подходящие объекты
 классов с конструкторами и деструкторами. Например, можно определить
 класс FilePtr, который выступает как тип FILE* :

           class FilePtr {
              FILE* p;
           public:
              FilePtr(const char* n, const char* a)
                { p = fopen(n,a); }
              FilePtr(FILE* pp) { p = pp; }
              ~FilePtr() { fclose(p); }

              operator FILE*() { return p; }
           };

 Построить объект FilePtr можно либо, имея объект типа FILE*, либо,
 получив нужные для fopen() параметры. В любом случае этот
 объект будет уничтожен при выходе из его области видимости, и
 его деструктор закроет файл. Теперь наш пример сжимается до такой
 функции:

           void use_file(const char* fn)
           {
             FilePtr f(fn,"w");
             // работаем с f
           }

 Деструктор будет вызываться независимо от того, закончилась ли функция
 нормально, или произошел запуск особой ситуации.

        9.4.1 Конструкторы и деструкторы

 Описанный способ управления ресурсами обычно называют "запрос ресурсов
 путем инициализации". Это универсальный прием, рассчитанный на
 свойства конструкторов и деструкторов и их взаимодействие с
 механизмом особых ситуаций.
    Объект не считается построенным, пока не завершил выполнение его
 конструктор. Только после этого возможна раскрутка стека,
 сопровождающая вызов деструктора объекта. Объект, состоящий из
 вложенных объектов, построен в той степени, в какой построены
 вложенные объекты.
    Хорошо написанный конструктор должен гарантировать, что объект
 построен полностью и правильно. Если ему не удается сделать это,
 он должен, насколько это возможно, восстановить состояние системы,
 которое было до начала построения. Для простых конструкторов было бы
 идеально всегда удовлетворять хотя бы одному условию - правильности
 или законченности объектов, и никогда не оставлять объект
 в "наполовину построенном" состоянии. Этого можно добиться, если
 применять при построении членов способ "запроса ресурсов путем
 инициализации".
    Рассмотрим класс X, конструктору которого требуется два ресурса:
 файл x и замок y (т.е. монопольные права доступа к чему-либо).
 Эти запросы могут быть отклонены и привести к запуску особой
 ситуации. Чтобы не усложнять работу программиста, можно потребовать,
 чтобы конструктор класса X никогда не завершался тем, что запрос на
 файл удовлетворен, а на замок нет. Для представления двух видов
 ресурсов мы будем использовать объекты двух классов FilePtr и
 LockPtr (естественно, было бы достаточно одного класса, если x и y
 ресурсы одного вида). Запрос ресурса выглядит как инициализация
 представляющего ресурс объекта:

           class X {
             FilePtr aa;
             LockPtr bb;
             // ...
             X(const char* x, const char* y)
                : aa(x),      // запрос `x'
                bb(y)         // запрос `y'
             { }
             // ...
           };

 Теперь, как это было для случая локальных объектов, всю служебную
 работу, связанную с ресурсами, можно возложить на реализацию.
 Пользователь не обязан следить за ходом такой работой. Например,
 если после построения aa и до построения bb возникнет особая
 ситуация, то будет вызван только деструктор aa, но не bb.
      Это означает, что если строго придерживаться этой простой
 схемы запроса ресурсов, то все будет в порядке. Еще более важно
 то, что создателю конструктора не нужно самому писать обработчики
 особых ситуаций.
      Для требований выделить блок в свободной памяти характерен самый
 произвольный порядок запроса ресурсов. Примеры таких запросов уже
 неоднократно встречались в этой книге:

             class X {
               int* p;
               // ...
             public:
               X(int s) { p = new int[s]; init(); }
               ~X() { delete[] p; }
               // ...
             };

 Это типичный пример использования свободной памяти, но в совокупности с
 особыми ситуациями он может привести к ее исчерпанию памяти.
 Действительно, если в init() запущена особая ситуация, то отведенная
 память не будет освобождена. Деструктор не будет вызываться, поскольку
 построение объекта не было завершено. Есть более надежный вариант
 этого примера:

              template<class T> class MemPtr {
              public:
                 T* p;
                 MemPtr(size_t s) { p = new T[s]; }
                 ~MemPtr() { delete[] p; }
                 operator T*() { return p; }
              }

              class X {
                 MemPtr<int> cp;
                 // ...
              public:
                 X(int s):cp(s) { init(); }
                 // ...
              };

 Теперь уничтожение массива, на который указывает p, происходит неявно
 в MemPtr. Если init() запустит особую ситуацию, отведенная память
 будет освобождена при неявном вызове деструктора для полностью
 построенного вложенного объекта cp.
      Отметим также, что стандартная стратегия выделения памяти в С++
 гарантирует, что если функции operator new() не удалось выделить память
 для объекта, то конструктор для него никогда не будет вызываться. Это
 означает, что пользователю не надо опасаться, что конструктор или
 деструктор может быть вызван для несуществующего объекта.
      Теоретически дополнительные расходы, требующиеся для обработки
 особых ситуаций, когда на самом деле ни одна из них не возникла, могут
 быть сведены к нулю. Однако, вряд ли это верно для ранних
 реализациях языка. Поэтому будет разумно в критичных внутренних циклах
 программы пока не использовать локальные переменные классов
 с деструкторами.

        9.4.2 Предостережения

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

        9.4.3 Исчерпание ресурса

 Есть одна из вечных проблем программирования: что делать, если не
 удалось удовлетворить запрос на ресурс? Например, в предыдущем
 примере мы спокойно открывали с помощью fopen() файлы и запрашивали с
 помощью операции new блок свободной памяти, не задумываясь при этом,
 что такого файла может не быть, а свободная память может исчерпаться.
 Для решения такого рода проблем у программистов есть два способа:
     Повторный запрос: пользователь должен изменить свой запрос и
     повторить его.
     Завершение: запросить дополнительные ресурсы от системы, если
     их нет, запустить особую ситуацию.
 Первый способ предполагает для задания приемлемого запроса
 содействие пользователя, во втором пользователь должен быть готов
 правильно отреагировать на отказ в выделении ресурсов. В большинстве
 случаев последний способ намного проще и позволяет поддерживать в
 системе разделение различных уровней абстракции.
     В С++ первый способ поддержан механизмом вызова функций, а
 второй - механизмом особых ситуаций. Оба способа можно
 продемонстрировать на примере реализации и использования операции
 new:

            #include <stdlib.h>

            extern void* _last_allocation;

            extern void* operator new(size_t size)
            {
              void* p;

              while ( (p=malloc(size))==0 ) {
                 if (_new_handler)
                    (*_new_handler)();  // обратимся за помощью
                 else
                    return 0;
              }
              return _last_allocation=p;
            }

 Если операция new() не может найти свободной памяти, она обращается
 к управляющей функции _new_handler(). Если в _new_handler() можно
 выделить достаточный объем памяти, все нормально. Если нет, из
 управляющей функции нельзя возвратиться в операцию new, т.к.
 возникнет бесконечный цикл. Поэтому управляющая функция может
 запустить особую ситуацию и предоставить исправлять положение
 программе, обратившейся к new:

            void my_new_handler()
            {
              try_find_some_memory();   // попытаемся найти
                                        // свободную память
              if (found_some()) return; // если она найдена, все в порядке
              throw Memory_exhausted(); // иначе запускаем особую
                                        // ситуацию "Исчерпание_памяти"
            }

 Где-то в программе должен быть проверяемый блок с соответствующим
 обработчиком:

            try {
                // ...
            }
            catch (Memory_exhausted) {
                // ...
            }

     В функции operator new() использовался указатель на управляющую
 функцию _new_handler, который настраивается стандартной функцией
 set_new_handler(). Если нужно настроиться на собственную управляющую
 функцию, надо обратиться так

           set_new_handler(&my_new_handler);

 Перехватить ситуацию Memory_exhausted можно следующим образом:

           void (*oldnh)() = set_new_handler(&my_new_handler);

           try {
              // ...
           }
           catch (Memory_exhausted) {
              // ...
           }
           catch (...) {
              set_new_handler(oldnh);  // восстановить указатель на
                                       // управляющую функцию
              throw();      // повторный запуск особой ситуации
           }

           set_new_handler(oldnh); // восстановить указатель на
                                   // управляющую функцию

 Можно поступить еще лучше, если к управляющей функции применить
 описанный в $$9.4 метод "запроса ресурсов путем инициализации" и
 убрать обработчик catch (...).
     В решении, использующим my_new_handler(), от точки обнаружения
 ошибки до функции, в которой она обрабатывается, не передается
 никакой информации. Если нужно передать какие-то данные, то
 пользователь может включить свою управляющую функцию в класс.
 Тогда в функции, обнаружившей ошибку, нужные данные можно поместить в
 объект этого класса. Подобный способ, использующий объекты-функции,
 применялся в $$10.4.2 для реализации манипуляторов. Способ, в
 котором используется указатель на функцию или объект-функция для
 того, чтобы из управляющей функции, обслуживающей некоторый ресурс,
 произвести "обратный вызов" функции запросившей этот ресурс,
 обычно называется просто обратным вызовом (callback).
     При этом нужно понимать, что чем больше информации передается
 из обнаружившей ошибку функции в функцию, пытающуюся ее исправить,
 тем больше зависимость между этими двумя функциями. В общем случае
 лучше сводить к минимуму такие зависимости, поскольку всякое
 изменение в одной из функций придется делать с учетом другой функцией,
 а, возможно, ее тоже придется изменять. Вообще, лучше не смешивать
 отдельные компоненты программы. Механизм особых ситуаций позволяет
 сохранять раздельность компонентов лучше, чем обычный механизм вызова
 управляющих функций, которые задает функция, затребовавшая ресурс.
    В общем случае разумный подход состоит в том, чтобы выделение
 ресурсов было многоуровневым (в соответствии с уровнями абстракции).
 При этом нужно избегать того, чтобы функции одного уровня зависели
 от управляющей функции, вызываемой на другом уровне. Опыт создания
 больших программных систем показывает, что со временем удачные
 системы развиваются именно в этом направлении.

        9.4.4 Особые ситуации и конструкторы

 Особые ситуации дают средство сигнализировать о происходящих в
 конструкторе ошибках. Поскольку конструктор не возвращает такое
 значение, которое могла бы проверить вызывающая функция, есть
 следующие обычные (т.е. не использующие особые ситуации) способы
 сигнализации:
     [1] Возвратить объект в ненормальном состоянии в расчете,
         что пользователь проверит его состояние.
     [2] Установить значение нелокальной переменной, которое
         сигнализирует, что создать объект не удалось.
 Особые ситуации позволяют тот факт, что создать объект не удалось,
 передать из конструктора вовне:

         Vector::Vector(int size)
         {
            if (sz<0 || max<sz) throw Size();
            // ...
         }

 В функции, создающей вектора, можно перехватить ошибки, вызванные
 недопустимым размером (Size()) и попытаться на них отреагировать:

         Vector* f(int i)
         {
           Vector* p;
           try {
             p = new Vector v(i);
           }
           catch (Vector::Size) {
             // реакция на недопустимый размер вектора
           }
           // ...
           return p;
         }

    Управляющая созданием вектора функция способна правильно
 отреагировать на ошибку. В самом обработчике особой ситуации можно
 применить какой-нибудь из стандартных способов диагностики и
 восстановления после ошибки. При каждом перехвате особой ситуации
 в управляющей функции может быть свой взгляд на причину ошибки. Если
 с каждой особой ситуацией передаются описывающие ее данные, то объем
 данных, которые нужно анализировать для каждой ошибки, растет. Основная
 задача обработки ошибок в том, чтобы обеспечить надежный и удобный
 способ передачи данных от исходной точки обнаружения ошибки до того
 места, где после нее возможно осмысленное восстановление.
     Способ "запроса ресурсов путем инициализации" - самый надежное
 и красивое решение в том случае, когда имеются конструкторы, требующие
 более одного ресурса. По сути он позволяет свести задачу выделения
 нескольких ресурсов к повторно применяемому, более простому, способу,
 рассчитанному на один ресурс.

        9.5 Особые ситуации могут не быть ошибками

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

         class message { /* ... */ };   // сообщение

         class queue {        // очередь
            // ...
            message* get();   // вернуть 0, если очередь пуста
            // ...
         };

         void f1(queue& q)
         {
           message* m = q.get();
           if (m == 0) {  // очередь пуста
              // ...
           }
           // используем m
         }

 Этот пример можно записать так:

         class Empty { }  // тип особой ситуации "Пустая_очередь"

         class queue {
             // ...
             message* get();  // запустить Empty, если очередь пуста
             // ...
         };

         void f2(queue& q)
         {
           try {
              message* m = q.get();
              // используем m
           }
           catch (Empty) {  // очередь пуста
              // ...
           }
         }

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

           class queue {
             // ...
             message* get();  // запустить Empty, если очередь пуста
             int empty();
             // ...
           };

           void f3(queue& q)
           {
             if (q.empty()) { // очередь пуста
                // ...
             }
             else {
                message* m = q.get();
                // используем m
             }
           }

 Отметим, что вынести из функции get() проверку очереди на пустоту
 можно только при условии, что к очереди нет параллельных обращений.
     Не так то просто отказаться от взгляда, что обработка особой
 ситуации есть обработка ошибки. Пока мы придерживаемся такой точки
 зрения, программа четко подразделяется на две части: обычная часть
 и часть обработки ошибок. Такая программа более понятна. К сожалению,
 в реальных задачах провести четкое разделение невозможно, поэтому
 структура программы должна (и будет) отражать этот факт. Допустим,
 очередь бывает пустой только один раз (так может быть, если функция
 get() используется в цикле, и пустота очереди говорит о конце цикла).
 Тогда пустота очереди не является чем-то странным или ошибочным.
 Поэтому, используя для обозначения конца очереди особую ситуацию,
 мы расширяем представление об особых ситуациях как ошибках. С другой
 стороны, действия, принимаемые в случае пустой очереди, явно отличаются
 от действий, принимаемых в ходе цикла (т.е. в обычном случае).
      Механизм особых ситуаций является менее структурированным,
 чем такие локальные структуры управления как операторы if или for.
 Обычно он к тому же является не столь эффективным, если особая
 ситуация действительно возникла. Поэтому особые ситуации следует
 использовать только в том случае, когда нет хорошего решения с более
 традиционными управляющими структурами, или оно, вообще, невозможно.
 Например, в случае пустой очереди можно прекрасно использовать для
 сигнализации об этом значение, а именно нулевое значение указателя на
 строку message, значит особая ситуация здесь не нужна. Однако, если бы
 из класса queue мы получали вместо указателя значение типа int, то
 то могло не найтись такого значения, обозначающего пустую очередь.
 В таком случае функция get() становится эквивалентной операции
 индексации из $$9.1, и более привлекательно представлять пустую очередь
 с помощью особой ситуации. Последнее соображение подсказывает, что
 в самом общем шаблоне типа для очереди придется для обозначения пустой
 очереди использовать особую ситуацию, а работающая с очередью функция
 будет такой:

          void f(Queue<X>& q)
          {
            try {
               for (;;) {  // ``бесконечный цикл''
                           // прерываемый особой ситуацией
                   X m = q.get();
                   // ...
               }
            }
            catch (Queue<X>::Empty) {
                 return;
            }
          }

 Если приведенный цикл выполняется тысячи раз, то он, по всей
 видимости, будет более эффективным, чем обычный цикл с проверкой
 условия пустоты очереди. Если же он выполняется только несколько
 раз, то обычный цикл почти наверняка эффективней.
     В очереди общего вида особая ситуация используется как способ
 возврата из функции get(). Использование особых ситуаций как способа
 возврата может быть элегантным способом завершения функций поиска.
 Особенно это подходит для рекурсивных функций поиска в дереве. Однако,
 применяя особые ситуации для таких целей, легко перейти грань разумного
 и получить маловразумительную программу. Все-таки всюду, где это
 действительно оправдано, надо придерживаться той точки зрения, что
 обработка особой ситуации есть обработка ошибки. Обработка ошибок по
 самой своей природе занятие сложное, поэтому ценность имеют любые
 методы, которые дают ясное представление ошибок в языке и способ
 их обработки.

        9.6 Задание интерфейса

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

           void f(int a) throw (x2, x3, x4);

 В этом описании указано, что f() может запустить особые ситуации
 x2, x3 и x4, а также ситуации всех производных от них типов, но
 больше никакие ситуации она не запускает. Если функция перечисляет свои
 особые ситуации, то она дает определенную гарантию всякой вызывающей ее
 функции, а именно, если попытается запустить иную особую ситуацию, то
 это приведет к вызову функции unexpected().
 Стандартное предназначение unexpected() состоит в вызове функции
 terminate(), которая, в свою очередь, обычно вызывает abort().
 Подробности даны в $$9.7.
      По сути определение

          void f() throw (x2, x3, x4)
          {
            // какие-то операторы
          }

 эквивалентно такому определению

          void f()
          {
            try {
              // какие-то операторы
            }
            catch (x2) {  // повторный запуск
             throw;
            }
            catch (x3) {  // повторный запуск
             throw;
            }
            catch (x4) {  // повторный запуск
             throw;
            }
            catch (...) {
             unexpected();
            }
          }

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

          int f();  // может запустить любую особую ситуацию

 Если функция не будет запускать никаких особых ситуаций, ее можно
 описать, явно указав пустой список:

          int g() throw (); // не запускает никаких особых ситуаций

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

        9.6.1 Неожиданные особые ситуации

 Если к описанию особых ситуаций относиться не достаточно серьезно, то
 результатом может быть вызов unexpected(), что нежелательно во всех
 случая, кроме отладки. Избежать вызова unexpected() можно, если хорошо
 организовать структуру особых ситуации и описание интерфейса. С
 другой стороны, вызов unexpected() можно перехватить и сделать его
 безвредным.
       Если компонент Y хорошо разработан, все его особые ситуации
 могут быть только производными одного класса, скажем Yerr. Поэтому,
 если есть описание

           class someYerr : public Yerr { /* ... */ };

 то функция, описанная как

           void f() throw (Xerr, Yerr, IOerr);

 будет передавать любую особую ситуацию типа Yerr вызывающей функции.
 В частности, обработка особой ситуации типа someYerr в f() сведется к
 передаче ее вызывающей f() функции.
       Бывает случаи, когда окончание программы при появлении
 неожиданной особой ситуации является слишком строгим решением.
 Допустим функция g() написана для несетевого режима в распределенной
 системе. Естественно, в g() ничего неизвестно об особых ситуациях,
 связанных с сетью, поэтому при появлении любой из них вызывается
 unexpected(). Значит для использования g() в распределенной системе
 нужно предоставить обработчик сетевых особых ситуаций или переписать
 g(). Если допустить, что переписать g() невозможно или нежелательно,
 проблему можно решить, переопределив действие функции unexpected().
 Для этого служит функция set_unexpected(). Вначале мы определим
 класс, который позволит нам применить для функций unexpected()
 метод "запроса ресурсов путем инициализации" :

           typedef void(*PFV)();
           PFV set_unexpected(PFV);

           class STC {   // класс для сохранения и восстановления
             PFV old;    // функций unexpected()
           public:
             STC(PFV f) { old = set_unexpected(f); }
             ~STC() { set_unexpected(old); }
           };

 Теперь мы определим функцию, которая должна в нашем примере заменить
 unexpected():

           void rethrow() { throw; }  // перезапуск всех сетевых
                                      // особых ситуаций

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

           void networked_g()
           {
            STC xx(&rethrow); // теперь unexpected() вызывает rethrow()
            g();
           }

 В предыдущем разделе было показано, что unexpected() потенциально
 вызывается из обработчика catch (...). Значит в нашем случае
 обязательно произойдет повторный запуск особой ситуации. Повторный
 запуск, когда особая ситуация не запускалась, приводит к вызову
 terminate(). Поскольку обработчик catch (...) находится вне той
 области видимости, в которой была запущена сетевая особая ситуация,
 бесконечный цикл возникнуть не может.
     Есть еще одно, довольно опасное, решение, когда на неожиданную
 особую ситуацию просто "закрывают глаза":

          void muddle_on() { cerr << "не замечаем особой ситуации\n"; }
          // ...
          STC xx(&muddle_on);  // теперь действие unexpected() сводится
                               // просто к печати сообщения

 Такое переопределение действия unexpected() позволяет нормально
 вернуться из функции, обнаружившей неожиданную особую ситуацию.
 Несмотря на свою очевидную опасность, это решение используется.
 Например, можно "закрыть глаза" на особые ситуации в одной части
 системы и отлаживать другие ее части. Такой подход может быть
 полезен в процессе отладки и развития системы, перенесенной с языка
 программирования без особых ситуаций. Все-таки, как правило лучше,
 если ошибки проявляются как можно раньше.
     Возможно другое решение, когда вызов unexpected() преобразуется
 в запуск особой ситуации Fail (неудача):

          void fail() { throw Fail; }
          // ...
          STC yy(&fail);

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

        9.7 Неперехваченные особые ситуации

 Если особая ситуация запущена и не перехвачена, то вызывается функция
 terminate(). Она же вызывается, когда система поддержки особых
 ситуаций обнаруживает, что структура стека нарушена, или когда
 в процессе обработки особой ситуации при раскручивании стека вызывается
 деструктор, и он пытается завершить свою работу, запустив особую
 ситуацию.
      Действие terminate() сводится к выполнению самой последней
 функции, заданной как параметр для set_terminate():

            typedef void (*PFV)();
            PFV set_terminate(PFV);

 Функция set_terminate() возвращает указатель на ту функцию, которая
 была задана как параметр в предыдущем обращении к ней.
       Необходимость такой функции как terminate() объясняется тем,
 что иногда вместо механизма особых ситуаций требуются более
 грубые приемы. Например, terminate() можно использовать для
 прекращения процесса, а, возможно, и для повторного запуска системы.
 Эта функция служит экстренным средством, которое применяется, когда
 отказала стратегия обработки ошибок, рассчитанная на особые
 ситуации, и самое время применить стратегию более низкого уровня.
       Функция unexpected() используется в сходных, но не столь
 серьезных случаях, а именно, когда функция запустила особую ситуацию,
 не указанную в ее описании. Действие функции unexpected() сводится
 к выполнению самой последней функции, заданной как параметр для
 функции set_unexpected().
       По умолчанию unexpected() вызывает terminate(), а та, в свою
 очередь, вызывает функцию abort(). Предполагается, что такое соглашение
 устроит большинство пользователей.
       Предполагается, что функция terminate() не возвращается в
 обратившеюся  ней функцию.
       Напомним, что вызов abort() свидетельствует о ненормальном
 завершении программы. Для нормального выхода из программы
 используется функция exit(). Она возвращает значение, которое
 показывает окружающей системе насколько корректно закончилась программа.

        9.8 Другие способы обработки ошибок

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

           int f(int arg)
           {
              try {
                 g(arg);
              }
              catch (x1) {
                 // исправить ошибку и повторить
                 g(arg);
              }
              catch (x2) {
                 // произвести вычисления и вернуть результат
                 return 2;
              }
              catch (x3) {
                 // передать ошибку
                 throw;
              }
              catch (x4) {
                 // вместо x4 запустить другую особую ситуацию
                 throw xxii;
              }
              catch (x5) {
                 // исправить ошибку и продолжить со следующего оператора
              }
              catch (...) {
                 // отказ от обработки ошибки
                 terminate();
              }
              // ...
            }

 Укажем, что в обработчике доступны переменные из области видимости,
 содержащей проверяемый блок этого обработчика. Переменные,
 описанные в других обработчиках или других проверяемых блоках,
 конечно, недоступны:

             void f()
             {
               int i1;
               // ...
               try {
                  int i2;
                  // ...
               }
               catch (x1) {
                  int i3;
                  // ...
               }
               catch (x4) {
                  i1 = 1;   // нормально
                  i2 = 2;   // ошибка: i2 здесь невидимо
                  i3 = 3;   // ошибка: i3 здесь невидимо
               }
             }

 Нужна общая стратегия для эффективного использования обработчиков в
 программе. Все компоненты программы должны согласованно использовать
 особые ситуации и иметь общую часть для обработки ошибок. Механизм
 обработки особых ситуаций является нелокальным по своей сути,
 поэтому так важно придерживаться общей стратегии. Это предполагает,
 что стратегия обработки ошибок должна разрабатываться на самых
 ранних стадиях проектах. Кроме того, эта стратегия должна
 быть простой (по сравнению со сложностью всей программы) и ясной.
 Последовательно проводить сложную стратегию в такой сложной
 по своей природе области программирования, как восстановление после
 ошибок, будет просто невозможно.
      Прежде всего стоит сразу отказаться от того, что одно средство
 или один прием можно применять для обработки всех ошибок. Это
 только усложнит систему. Удачная система, обладающая устойчивостью
 к ошибкам, должна строиться как многоуровневая. На каждом уровне
 надо обрабатывать настолько много ошибок, насколько это возможно
 без нарушения структуры системы, оставляя обработку других ошибок более
 высоким уровням. Назначение terminate() поддержать такой подход,
 предоставляя возможность экстренного выхода из такого положения,
 когда нарушен сам механизм обработки особых ситуаций, или когда
 он используется полностью, но особая ситуация оказалась
 неперехваченной. Функция unexpected() предназначена для выхода из
 такого положения, когда не сработало основанное на описании всех особых
 ситуаций средство защиты. Это средство можно представлять как брандмауер,
 т.е. стену, окружающую каждую функцию, и препятствующую
 распространению ошибки. Попытка проводить в каждой функции полный
 контроль, чтобы иметь гарантию, что функция либо успешно завершится,
 либо закончится неудачно, но одним из определенных и корректных
 способов, не может принести успех. Причины этого могут быть различными
 для разных программ, но для больших программ можно назвать следующие:
   [1] работа, которую нужно провести, чтобы гарантировать надежность
       каждой функции, слишком велика, и поэтому ее не удастся
       провести достаточно последовательно;
   [2] появятся слишком большие дополнительные расходы памяти и времени,
       которые будут недопустимы для нормальной работы системы
       (будет тенденция неоднократно проверять на одну и ту же ошибку,
        а значит постоянно будут проверяться переменные с правильными
        значениями);
   [3] таким ограничениям не будут подчиняться функции, написанные на
       других языках;
   [4] такое понятие надежности является чисто локальным и оно
       настолько усложняет систему, что становится дополнительной
       нагрузкой для ее общей надежности.
    Однако, разбить программу на отдельные подсистемы, которые либо
 успешно завершаются, либо заканчиваются неудачно, но одним из
 определенных и корректных способов, вполне возможно, важно и даже
 выгодно. Таким свойством должны обладать основные библиотеки,
 подсистемы или ключевые функции. Описание особых ситуаций должно
 входить в интерфейсы таких библиотек или подсистем.
    Иногда приходится от одного стиля реакции на ошибку переходить
 на другой. Например, можно после вызова стандартной функции С
 проверять значение errno и, возможно, запускать особую ситуацию,
 а можно, наоборот, перехватывать особую ситуацию и устанавливать
 значение errno перед выходом из стандартной функции в С-программу:

             void callC()
             {
               errno = 0;
               cfunction();
               if (errno) throw some_exception(errno);
             }

             void fromC()
             {
               try {
                  c_pl_pl_function();
               }
               catch (...) {
                  errno = E_CPLPLFCTBLEWIT;
               }
             }

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

        9.9 Упражнения

 1. (*2) Обобщите класс STC до шаблона типа, который позволяет
    хранить и устанавливать функции разных типов.
 2. (*3) Дополните класс CheckedPtrToT из $$7.10 до шаблона типа, в
    котором особые ситуации сигнализируют о динамических ошибках.
 3. (*3) Напишите функцию find для поиска в бинарном дереве узлов
    по значению поля типа char*. Если найден узел с полем, имеющим
    значение "hello", она должна возвращать указатель на него. Для
    обозначения неудачного поиска используйте особую ситуацию.
 4. (*1) Определите класс Int, совпадающий во всем со встроенным
    типом int за исключением того, что вместо переполнения или
    потери значимости в этом классе запускаются особые ситуации.
    Подсказка: см. $$9.3.2.
 5. (*2) Перенесите из стандартного интерфейса С в вашу операционную
    систему основные операции с файлами: открытие, закрытие, чтение и
    запись. Реализуйте их как функции на С++ с тем же назначением,
    что и функций на С, но в случае ошибок запускайте особые
    ситуации.
 6. (*1) Напишите полное определение шаблона типа Vector с особыми
    ситуациями Range и Size. Подсказка: см. $$9.3.
 7. (*1) Напишите цикл для вычисления суммы элементов вектора,
    определенного в упражнении 6, причем не проверяйте размер вектора.
    Почему это плохое решение?
 8. (*2.5) Допустим класс Exception используется как базовый для всех
    классов, задающих особые ситуации. Каков должен быть его вид?
    Какая от него могла быть польза? Какие неудобства может вызвать
    требование обязательного использования этого класса?
 9. (*2) Напишите класс или шаблон типа, который поможет реализовать
    обратный вызов.
 10. (*2) Напишите класс Lock (замок) для какой-нибудь системы,
    допускающей параллельное выполнение.
 11. (*1) Пусть определена функция
         int main() { /* ... */ }
    Измените ее так, чтобы в ней перехватывались все особые ситуации,
    преобразовывались в сообщения об ошибке и вызов abort().
    Подсказка: в функции fromC() из $$9.8 учтены не все случаи.




         * ГЛАВА 10. ПОТОКИ

                "Доступно только то, что видимо"
                           Б. Керниган

    В языке С++ нет средств для ввода-вывода. Их и не нужно, поскольку
такие средства можно просто  и  элегантно  создать  на  самом  языке.
Описанная здесь библиотека потокового ввода-вывода реализует строгий
типовой и вместе с тем гибкий и эффективный способ символьного ввода и
вывода целых, вещественных чисел и символьных строк, а также является
базой для расширения, рассчитанного на работу с пользовательскими типами
данных. Пользовательский интерфейс библиотеки находится в файле
<iostream.h>. Эта глава посвящена самой потоковой библиотеке, некоторым
способам работы с ней и определенным приемам реализации библиотеки.

        10.1  ВВЕДЕНИЕ

Широко известна трудность задачи проектирования и реализации
стандартных средств ввода-вывода для языков программирования.
Традиционно средства ввода-вывода были  рассчитаны  исключительно  на
небольшое  число встроенных типов данных. Однако, в нетривиальных
программах на С++ есть много пользовательских типов данных, поэтому
необходимо предоставить
возможность ввода-вывода значений таких типов. Очевидно, что средства
ввода-вывода должны быть простыми, удобными, надежными в использовании
и, что важнее всего, адекватными. Пока никто не нашел решения, которое
удовлетворило бы всех; поэтому необходимо дать возможность пользователю
создавать иные средства ввода-вывода, а также расширять стандартные
средства ввода-вывода в расчете на определенное применение.
   Цель создания С++ была в том, чтобы пользователь мог определить новые
типы данных, работа с которыми была бы столь же удобна и эффективна как
и со встроенными типами. Таким образом, кажется разумным потребовать,
чтобы средства ввода-вывода для С++ программировались с использованием
возможностей С++, доступных каждому. Представленные здесь потоковые
средства ввода-вывода появились в результате попытки удовлетворить
этим требованиям.
Основная задача потоковых средств ввода-вывода - это процесс
преобразования объектов определенного типа в последовательность символов
и наоборот. Существуют и другие схемы ввода-вывода, но указанная является
основной, и если считать символ просто набором битов, игнорируя его
естественную связь с алфавитом, то многие схемы двоичного ввода-вывода
можно свести к ней. Поэтому программистская суть задачи сводится к
описанию связи между объектом определенного типа и бестиповой (что
существенно) строкой.
  Последующие разделы описывают основные части потоковой библиотеки С++:

10.2 Вывод: То, что для прикладной программы представляется выводом,
     на самом деле является преобразованием таких  объектов  как  int,
     char *, complex или Employee_record в последовательность символов.
     Описываются средства для записи объектов встроенных и
     пользовательских типов данных.
10.3 Ввод: Описаны функции для ввода символов, строк и значений
     встроенных и пользовательских типов данных.
10.4 Форматирование: Часто существуют определенные требования к виду
     вывода, например, int должно печататься десятичными цифрами,
     указатели в шестнадцатеричной записи, а вещественные числа должны
     быть  с явно заданной точностью фиксированного размера.
     Обсуждаются функции форматирования и определенные программистские
     приемы их создания, в частности, манипуляторы.
10.5 Файлы и потоки:  Каждая программа на С++  может  использовать  по
     умолчанию три потока - стандартный вывод (cout), стандартный ввод
     (cin) и стандартный поток ошибок (cerr). Чтобы работать с какими-
     либо устройствами или файлами надо создать потоки и привязать их
     к этим устройствам или файлам. Описывается механизм открытия и
     закрытия файлов и связывания файлов с потоками.
10.6 Ввод-вывод для С: обсуждается функция printf из файла <stdio.h>
     для С а также связь между библиотекой для С и <iostream.h> для
     С++.
Укажем, что существует много независимых реализаций
потоковой библиотеки ввода-вывода и набор средств, описанных здесь, будет
только подмножеством средств, имеющихся в вашей библиотеке. Говорят,
что внутри любой большой программы есть маленькая  программа,  которая
стремится вырваться наружу. В этой главе предпринята попытка описать
как раз маленькую потоковую библиотеку ввода-вывода, которая позволит
оценить основные концепции потокового ввода-вывода и познакомить
с наиболее полезными средствами. Используя только средства,
описанные здесь,  можно написать много программ; если возникнет
необходимость в более сложных средствах, обратитесь за деталями к вашему
руководству по С++. Заголовочный файл <iostream.h> определяет интерфейс
потоковой библиотеки. В ранних версиях потоковой библиотеки использовался
файл <stream.h>. Если существуют оба файла, <iostream.h> определяет полный
набор средств, а <stream.h> определяет подмножество, которое
совместимо с ранними, менее богатыми потоковыми библиотеками.
   Естественно, для пользования потоковой библиотекой вовсе не нужно
знание техники ее реализации, тем более, что техника может быть
различной для различных реализаций. Однако, реализация ввода-вывода
является задачей, диктующей определенные условия, значит приемы, найденные
в процессе ее решения, можно применить и для других задач, а само это
решение достойно изучения.

        10.2 ВЫВОД

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

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

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

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

Здесь cerr обозначает стандартный поток ошибок. Так, если х типа int
со значением 123, то приведенный оператор выдаст

    x = 123

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

    x = (1,2.4)

в поток cerr. Такой подход легко использовать пока x такого типа, для
которого определена операция <<,  а пользователь может просто
доопределить << для новых типов.
    Мы использовали операцию вывода, чтобы избежать многословности,
неизбежной, если применять функцию вывода. Но почему именно символ << ?
Невозможно изобрести новую лексему (см.  7.2).  Кандидатом для ввода и
вывода была операция присваивания, но большинство людей предпочитает,
чтобы операции ввода и вывода были различны. Более того, порядок
выполнения операции = неподходящий, так cout=a=b означает cout=(a=b).
Пробовали использовать операции < и >, но к ним так крепко привязано
понятие "меньше чем" и "больше чем", что операции ввода-вывода с ними
во всех практически случаях не поддавались прочтению.
    Операции << и >> похоже не создают таких проблем. Они асиметричны,
что позволяет приписывать им смысл "в" и "из". Они не относятся к числу
наиболее часто используемых операций над встроенными типами, а
приоритет << достаточно низкий, чтобы писать арифметические выражения в
качестве операнда без скобок:

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

Скобки нужны, если выражение содержит операции с более низким
приоритетом:

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

Операцию сдвига влево можно использовать в операции вывода, но, конечно,
она должна быть в скобках:

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

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

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

     class ostream : public virtual ios {
         // ...
     public:
        ostream& operator<<(const char*);    //строки
        ostream& operator<<(char);
        ostream& operator<<(short i)
          { return *this << int(i); }
        ostream& operator<<(int);
        ostream& operator<<(long);
        ostream& operator<<(double);
        ostream& operator<<(const void*);    // указатели
         // ...
  };

Естественно, в классе ostream должен быть набор функций operator<<()
для работы с беззнаковыми типами.
     Функция operator<< возвращает ссылку на класс ostream, из
которого она вызывалась, чтобы к ней можно было применить еще раз
operator<<. Так, если х типа int, то

       cerr << "x = " << x;

понимается как

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

В частности, это означает, что если несколько объектов выводятся с
помощью одного оператора вывода, то они будут выдаваться в
естественном порядке: слева - направо.
      Функция ostream::operator<<(int) выводит целые значения, а
функция ostream::operator<<(char) - символьные. Поэтому функция

      void val(char c)
      {
        cout << "int('"<< c <<"') = " << int(c) << '\n';
      }

печатает целые значения символов и с помощью программы

      main()
      {
        val('A');
        val('Z');
      }

будет напечатано

      int('A') = 65
      int('Z') = 90

Здесь предполагается кодировка символов ASCII, на вашей машине может быть
иной результат. Обратите внимание, что символьная константа имеет
тип char, поэтому cout<<'Z' напечатает букву Z, а вовсе не целое 90.
      Функция ostream::operator<<(const void*) напечатает значение
указателя в такой записи, которая более подходит для используемой
системы адресации.
Программа

      main()
      {
       int i = 0;
       int* p = new int(1);
       cout << "local " << &i
            << ", free store " << p << '\n';
      }

 выдаст на машине, используемой автором,

      local 0x7fffead0, free store 0x500c

Для других систем адресации могут быть иные соглашения об изображении
значений указателей.
    Обсуждение базового класса ios отложим до 10.4.1.

        10.2.2 Вывод пользовательских типов

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

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

        friend double real(complex& a) { return a.re; }
        friend double imag(complex& a) { return a.im; }

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

Для нового типа complex операцию << можно определить так:

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

и использовать  как operator<< для встроенных типов. Например,

    main()
    {
        complex x(1,2);
        cout << "x = " << x << '\n';
    }

выдаст

    x = (1,2)

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

        10.3 ВВОД

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

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

Класс istream определяется следующим образом:

     class istream : public virtual ios {
         //...
     public:
         istream& operator>>(char*);     // строка
         istream& operator>>(char&);     // символ
         istream& operator>>(short&);
         istream& operator>>(int&);
         istream& operator>>(long&);
         istream& operator>>(float&);
         istream& operator>>(double&);
         //...
     };

Функции ввода operator>> определяются так:

     istream& istream::operator>>(T& tvar)
     {
      // пропускаем обобщенные пробелы
      // каким-то образом читаем T в`tvar'
       return *this;
      }

Теперь можно ввести в VECTOR последовательность целых, разделяемых
пробелами, с помощью функции:

    int readints(Vector<int>& v)
    // возвращаем число прочитанных целых
    {
       for (int i = 0; i<v.size(); i++)
       {
          if (cin>>v[i]) continue;
          return i;
       }
       // слишком много целых для размера Vector
       // нужна соответствующая обработка ошибки
     }

Появление значения с типом, отличным от int, приводит к прекращению
операции ввода, и цикл ввода завершается. Так, если мы вводим

     1 2 3 4 5. 6 7 8.

то функция readints() прочитает пять целых чисел

     1 2 3 4 5

Символ точка останется первым символом, подлежащим вводу. Под пробелом,
как определено в стандарте С, понимается обобщенный пробел, т.е.
пробел, табуляция, конец строки, перевод строки или возврат каретки.
Проверка на обобщенный пробел возможна с помощью функции isspace()
из файла <ctype.h>.
     В качестве альтернативы можно использовать функции get():

    class istream : public virtual ios {
        //...
        istream& get(char& c);                     // символ
        istream& get(char* p, int n, char ='n');   // строка
    };

В них обобщенный пробел рассматривается как любой другой символ и
они предназначены для таких операций ввода, когда не делается никаких
предположений о вводимых символах.
     Функция istream::get(char&) вводит один символ в свой параметр.
Поэтому программу посимвольного копирования можно написать так:

     main()
     {
       char c;
       while (cin.get(c)) cout << c;
     }

Такая запись выглядит несимметрично, и у операции >> для вывода символов
есть двойник под именем put(), так что можно писать и так:

     main()
     {
        char c;
        while (cin.get(c)) cout.put(c);
     }

Функция с тремя параметрами istream::get() вводит в символьный вектор
не менее n символов, начиная с адреса p. При всяком обращении к get()
все символы, помещенные в буфер (если они были), завершаются 0, поэтому
если второй параметр равен n, то введено не более n-1 символов. Третий
параметр определяет символ, завершающий ввод. Типичное использование
функции get() с тремя параметрами сводится к чтению строки в буфер
заданного размера для ее дальнейшего разбора, например так:

     void f()
     {
         char buf[100];
         cin >> buf;                 // подозрительно
         cin.get(buf,100,'\n');      // надежно
         //...
      }

Операция cin>>buf подозрительна, поскольку строка из более чем 99
символов переполнит буфер. Если обнаружен завершающий символ, то он
остается в потоке первым символом подлежащим вводу. Это позволяет
проверять буфер на переполнение:

     void f()
     {
        char buf[100];

        cin.get(buf,100,'\n');   // надежно

        char c;
        if (cin.get(c) && c!='\n') {
           // входная строка больше, чем ожидалось
        }
        //...
      }

Естественно, существует версия get() для типа unsigned char.
     В стандартном заголовочном файле <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 isspace(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; }

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

     (('a'<=c && c<='z') || ('A'<=c && c<='Z')) // буква

которое не только утомительно писать, но оно может быть и ошибочным
(на машине с кодировкой EBCDIC оно задает не только буквы), лучше
использовать вызов стандартной функции isalpha(), который к тому
же более эффективен.
В качестве примера приведем функцию eatwhite(), которая читает из
потока обобщенные пробелы:

     istream& eatwhite(istream& is)
     {
          char c;
          while (is.get(c)) {
              if (isspace(c)==0) {
                  is.putback(c);
                  break;
              }
           }
           return is;
      }

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

        10.3.2 Состояния потока

С каждым потоком (istream или ostream) связано определенное состояние.
Нестандартные ситуации и ошибки обрабатываются с помощью проверки и
установки состояния подходящим образом.
Узнать состояние потока можно с помощью операций над классом ios:

     class ios { //ios является базовым для ostream и istream
         //...
     public:
         int eof() const;     // дошли до конца файла
         int fail() const;    // следующая операция будет неудачна
         int bad() const;     // поток испорчен
         int good() const;    // следующая операция будет успешной
         //...
     };

Последняя операция ввода считается успешной, если состояние задается
good() или eof(). Если состояние задается good(), то последующая
операция ввода может быть успешной, в противном случае она будет
неудачной. Применение операции ввода к потоку в состоянии, задаваемом
не good(), считается пустой операцией. Если произошла неудача при
попытке чтения в переменную v, то значение v не изменилось (оно не
изменится, если v имеет тип, управляемый функциями члена из istream
или ostream). Различие между состояниями, задаваемыми как fail() или
как bad() уловить трудно, и оно имеет смысл только для разработчиков
операций ввода. Если состояние есть fail(), то считается, что поток
не поврежден, и никакие символы не пропали; о состоянии bad() ничего
сказать нельзя.
    Значения, обозначающие эти состояния, определены в классе ios:

     class ios {
         //...
     public:
         enum io_state {
             goodbit=0,
             eofbit=1,
             filebit=2,
             badbit=4,
         };
         //...
     };

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

     switch (cin.rdstate()) {
     case ios::goodbit:
         // последняя операция с cin была успешной
         break;
     case ios::eofbit:
         // в конце файла
         break;
      case ios::filebit:
         // некоторый анализ ошибки
         // возможно неплохой
         break;
       case ios::badbit:
         //  cin возможно испорчен
         break;
       }

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

     const int _good = ios::goodbit;
     const int _bad = ios::badbit;
     const int _file = ios::filebit;
     const int _eof = ios::eofbit;

     typedef ios::io_state state_value ;

Разработчики библиотек должны заботится о том, чтобы не добавлять
новых имен к глобальному пространству именования. Если элементы
перечисления входят в общий интерфейс библиотеки, они всегда
должны использоваться в классе с префиксами, например, как ios::goodbit
и ios::io_state.
      Для переменной любого типа, для которого определены операции
<< и >>, цикл копирования записывается следующим образом:

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

Если поток появляется в условии, то проверяется состояние потока, и
условие выполняется (т.е. результат его не 0) только для состояния
good(). Как раз в приведенном выше цикле проверяется состояние потока
istream, что является результатом операции cin>>z. Чтобы узнать,
почему произошла неудача в цикле или условии, надо проверить состояние.
Такая проверка для потока реализуется с помощью операции
приведения (7.3.2).
   Так, если z является символьным вектором, то в приведенном цикле
читается стандартный ввод и выдается для каждой строки стандартного
вывода по одному слову (т.е. последовательности символов, не являющихся
обобщенными пробелами). Если z имеет тип complex, то в этом цикле
с помощью операций, определенных в 10.2.2 и 10.2.3, будут копироваться
комплексные числа. Шаблонную функцию копирования для потоков со
значениями произвольного типа можно написать следующим образом:

     complex z;
     iocopy(z,cin,cout);    // копирование complex

     double d;
     iocopy(d,cin,cout);    // копирование double
     char c;
     iocopy(c,cin,cout);    // копирование char

    Поскольку надоедает проверять на корректность каждую операцию ввода-
вывода,