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

        typeid static_type_info(type) // получить typeid для имени типа
        typeid ptr_type_info(pointer) // получить typeid для указателя
        typeid ref_type_info(reference) // получить typeid для ссылки
        pointer ptr_cast(type,pointer)  // преобразование указателя
        reference ref_cast(type,reference)  // преобразование ссылки

Пользователь класса может обойтись этими операциями, а создатель
класса должен предусмотреть в описаниях классов определенные
"приспособления", чтобы согласовать операции с реализацией
библиотеки.
   Большинство пользователей, которым вообще нужна динамическая
идентификация типа, может ограничиться операциями приведения
ptr_cast() и ref_cast(). Таким образом пользователь отстраняется от
дальнейших сложностей, связанных с динамической идентификацией
типа. Кроме того, ограниченное использование динамической информации
о типе меньше всего чревато ошибками.
   Если недостаточно знать, что операция приведения прошла успешно,
а нужен истинный тип (например, объектно-ориентированный
ввод-вывод), то можно использовать операции динамических запросов о типе:
static_type_info(), ptr_type_info() и ref_type_info(). Эти операции
возвращают объект класса typeid. Как было показано в примере с
set и slist_set, объекты класса typeid можно сравнивать. Для
большинства задач этих сведений о классе typeid достаточно. Но для
задач, которым нужна более полная информация о типе, в классе
typeid есть функция get_type_info():

          class typeid {
              friend class Type_info;
          private:
              const Type_info* id;
          public:
              typeid(const Type_info* p) : id(p) { }
              const Type_info* get_type_info() const { return id; }
              int operator==(typeid i) const ;
          };

Функция get_type_info() возвращает указатель на неменяющийся (const)
объект класса Type_info из typeid. Существенно, что объект
не меняется: это должно гарантировать, что динамическая информация
о типе отражает статические типы исходной программы. Плохо, если
при выполнении программы некоторый тип может изменяться.
   С помощью указателя на объект класса Type_info пользователь
получает доступ к информации о типе из typeid и, теперь его
программа начинает зависеть от конкретной системы динамических
запросов о типе и от структуры динамической информации о нем.
Но эти средства не входят в стандарт языка, а задать их с помощью
хорошо продуманных макроопределений непросто.

        13.5.2 Класс Type_info

В классе Type_info есть минимальный объем информации для реализации
операции ptr_cast(); его можно определить следующим образом:

          class Type_info {
              const char* n;       // имя
              const Type_info** b; // список базовых классов
          public:
              Type_info(const char* name, const Type_info* base[]);

              const char* name() const;
              Base_iterator bases(int direct=0) const;
              int same(const Type_info* p) const;
              int has_base(const Type_info*, int direct=0) const;
              int can_cast(const Type_info* p) const;

              static const Type_info info_obj;
              virtual typeid get_info() const;
              static typeid info();
          };

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

          const char* Type_info::name() const
          {
            return n;
          }

          int Type_info::same(const Type_info* p) const
          {
            return this==p || strcmp(n,p->n)==0;
          }

          int Type_info::can_cast(const Type_info* p) const
          {
            return same(p) || p->has_base(this);
          }

Доступ к информации о базовых классах обеспечивается функциями
bases() и has_base(). Функция bases() возвращает итератор, который
порождает указатели на базовые классы объектов Type_info, а с
помощью функции has_base() можно определить является ли заданный класс
базовым для другого класса. Эти функции имеют необязательный параметр
direct, который показывает, следует ли рассматривать все базовые классы
(direct=0), или только прямые базовые классы (direct=1). Наконец,
как описано ниже, с помощью функций get_info() и info() можно
получить динамическую информацию о типе для самого класса Type_info.
     Здесь средство динамических запросов о типе сознательно
реализуется с помощью совсем простых классов. Так можно избежать
привязки к определенной библиотеке. Реализация в расчете на
конкретную библиотеку может быть иной. Можно, как всегда, посоветовать
пользователям избегать излишней зависимости от деталей реализации.
    Функция has_base() ищет базовые классы с помощью имеющегося в
Type_info списка базовых классов. Хранить информацию о том, является
ли базовый класс частным или виртуальным, не нужно, поскольку
все ошибки, связанные с ограничениями доступа или неоднозначностью,
будут выявлены при трансляции.

        class base_iterator {
          short i;
          short alloc;
          const Type_info* b;
        public:
          const Type_info* operator() ();
          void reset() { i = 0; }

          base_iterator(const Type_info* bb, int direct=0);
          ~base_iterator() { if (alloc) delete[] (Type_info*)b; }
       };

В следующем примере используется необязательный параметр для указания,
следует ли рассматривать все базовые классы (direct==0) или только прямые
базовые классы (direct==1).

      base_iterator::base_iterator(const Type_info* bb, int direct)
      {
        i = 0;

        if (direct) { // использование списка прямых базовых классов
           b = bb;
           alloc = 0;
           return;
        }

        // создание списка прямых базовых классов:

        // int n = число базовых
        b = new const Type_info*[n+1];
        // занести базовые классы в b

        alloc = 1;
        return;
      }

      const Type_info* base_iterator::operator() ()
      {
        const Type_info* p = &b[i];
        if (p) i++;
        return p;
      }

Теперь можно  задать операции запросов о типе с помощью макроопределений:

      #define static_type_info(T)  T::info()

      #define ptr_type_info(p)   ((p)->get_info())
      #define ref_type_info(r)   ((r).get_info())

      #define ptr_cast(T,p) \
         (T::info()->can_cast((p)->get_info()) ? (T*)(p) : 0)
      #define ref_cast(T,r) \
         (T::info()->can_cast((r).get_info()) \
             ? 0 : throw Bad_cast(T::info()->name()), (T&)(r))

Предполагается, что тип особой ситуации Bad_cast (Ошибка_приведения)
описан так:

      class Bad_cast {
        const char* tn;
        // ...
      public:
        Bad_cast(const char* p) : tn(p) { }
        const char* cast_to() { return tn; }
        //  ...
      };

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

        13.5.3 Как создать систему динамических запросов о типе

Здесь показано, как можно прямо реализовать динамические запросы
о типе, когда в трансляторе таких возможностей нет. Это достаточно
утомительная задача и можно пропустить этот раздел, так как в нем
есть только детали конкретного решения.
    Классы set и slist_set из $$13.3 следует изменить так, чтобы
с ними могли работать операции запросов о типе. Прежде всего, в
базовый класс set нужно ввести функции-члены, которые используют
операции запросов о типе:

       class set {
         public:
           static const Type_info info_obj;
           virtual typeid get_info() const;
           static typeid info();

           // ...
      };

При выполнении программы единственным представителем объекта типа
set является set::info_obj, который определяется так:

      const Type_info set::info_obj("set",0);

С учетом этого определения функции тривиальны:

     typeid set::get_info() const { return &info_obj; }
     typeid set::info() { return &info_obj; }
     typeid slist_set::get_info() const { return &info_obj; }
     typeid slist_set::info() { return &info_obj; }

Виртуальная функция get_info() будет предоставлять операции
ref_type_info() и ptr_type_info(), а статическая функция info()
- операцию static_type_info().
   При таком построении системы запросов о типе основная трудность
на практике состоит в том, чтобы для каждого класса объект типа
Type_info и две функции, возвращающие указатель на этот объект,
определялись только один раз.
    Нужно несколько изменить класс slist_set:

       class slist_set : public set, private slist {
          // ...
       public:
          static const Type_info info_obj;
          virtual typeid get_info() const;
          static typeid info();

          // ...
       };

       static const Type_info* slist_set_b[]
          = { &set::info_obj, &slist::info_obj, 0 };
       const Type_info slist_set::info_obj("slist_set",slist_set_b);

       typeid slist_set::get_info() const { return &info_obj; }
       typeid slist_set::info() { return &info_obj; }

        13.5.4 Расширенная динамическая информация о типе

В классе Type_info содержится только минимум информации, необходимой
для идентификации типа и безопасных операций приведения. Но поскольку
в самом классе Type_info есть функции-члены info() и get_info(),
можно построить производные от него классы, чтобы в динамике
определять, какие объекты Type_info возвращают эти функции. Таким
образом, не меняя класса Type_info, пользователь может получать
больше информации о типе с помощью объектов, возвращаемых функциями
dynamic_type() и static_type(). Во многих случаях дополнительная
информация должна содержать таблицу членов объекта:

           struct Member_info {
             char* name;
             Type_info* tp;
             int offset;
           };

           class Map_info : public Type_info {
              Member_info** mi;
           public:
              static const Type_info info_obj;
              virtual typeid get_info() const;
              static typeid info();

              // функции доступа
           };

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


        13.5.5 Правильное и неправильное использование динамической
       информации о типе

Динамическая информация о типе может использоваться во многих
ситуациях, в том числе для: объектного ввода-вывода,
объектно-ориентированных баз данных,  отладки. В тоже время
велика вероятность ошибочного использования такой информации.
Известно,что в языке Симула использование таких средств,
как правило, приводит к ошибкам. Поэтому эти средства не были
включены в С++. Слишком велик соблазн воспользоваться динамической
информацией о типе, тогда как правильнее вызвать виртуальную
функцию. Рассмотрим в качестве примера класс Shape из $$1.2.5.
Функцию rotate можно было задать так:

        void rotate(const Shape& s)
            // неправильное использование динамической
            // информации о типе

        {
          if (ref_type_info(s)==static_type_info(Circle)) {
             // для этой фигуры ничего не надо
          }
          else if (ref_type_info(s)==static_type_info(Triangle)) {
             // вращение треугольника
          }
          else if (ref_type_info(s)==static_type_info(Square)) {
             // вращение квадрата
          }
          // ...
        }

Если для переключателя по типу поля мы используем динамическую
информацию о типе, то тем самым нарушаем в программе принцип
модульности и отрицаем сами цели объектно-ориентированного программирования.
К тому же это решение чревато ошибками: если в качестве
параметра функции будет передан объект производного от Circle класса,
то она сработает неверно (действительно, вращать круг (Circle)
нет смысла, но для объекта, представляющего производный класс, это
может потребоваться). Опыт показывает, что программистам, воспитанным
на таких языках как С или Паскаль, трудно избежать этой ловушки.
Стиль программирования этих языков требует меньше предусмотрительности,
а при создании библиотеки такой стиль можно просто считать
небрежностью.
   Может возникнуть вопрос, почему в интерфейс с системой динамической
информации о типе включена условная операция приведения ptr_cast(), а не
операция is_base(), которая непосредственно определяется с помощью
операции has_base() из класса Type_info. Рассмотрим такой пример:

            void f(dialog_box& db)
            {
              if (is_base(&db,dbox_w_str)) { // является ли db базовым
                                             // для  dbox_w-str?
                 dbox_w_str* dbws = (dbox_w_str*) &db;
                 // ...
              }

              // ...
            }

Решение с помощью ptr_cast ($$13.5) более короткое, к тому же здесь
явная и безусловная операция приведения отделена от проверки в операторе
if, значит появляется возможность ошибки, неэффективности и даже
неверного результата. Неверный результат может возникнуть в тех
редких случаях, когда система динамической идентификации типа
распознает, что один тип является производным от другого, но
транслятору этот факт неизвестен, например:

            class D;
            class B;

            void g(B* pb)
            {
              if (is_base(pb,D)) {
                 D* pb = (D*)pb;

                 // ...
              }

              // ...
            }

Если транслятору пока неизвестно следующее описание класса D:

            class D : public A, public B {
               // ...
            };

то возникает ошибка, т.к. правильное приведение указателя pb к D*
требует изменения значения указателя. Решение с операцией ptr_cast()
не сталкивается с этой трудностью, поскольку эта операция применима
только при условии, что в области видимости находятся описания
обеих ее параметров. Приведенный пример показывает, что операция
приведения для неописанных классов по сути своей ненадежна, но
запрещение ее существенно ухудшает совместимость с языком С.

        13.6 Обширный интерфейс

Когда обсуждались абстрактные типы ($$13.3) и узловые классы ($$13.4),
было подчеркнуто, что все функции базового класса реализуются
в самом базовом или в производном классе. Но существует и другой
способ построения классов. Рассмотрим, например, списки, массивы,
ассоциативные массивы, деревья и т.д. Естественно желание для всех
этих типов, часто называемых контейнерами, создать обобщающий их
класс, который можно использовать в качестве интерфейса с любым
из перечисленных типов. Очевидно, что пользователь не должен
знать детали, касающиеся конкретного контейнера. Но задача
определения интерфейса для обобщенного контейнера нетривиальна.
Предположим, что такой контейнер будет определен как абстрактный
тип, тогда какие операции он должен предоставлять? Можно предоставить
только те операции, которые есть в каждом контейнере, т.е.
пересечение множеств операций, но такой интерфейс будет слишком
узким. На самом деле, во многих, имеющих смысл случаях такое
пересечение пусто. В качестве альтернативного решения можно
предоставить объединение всех множеств операций и предусмотреть
динамическую ошибку, когда в этом интерфейсе к объекту
применяется "несуществующая" операция. Объединение интерфейсов классов,
представляющих  множество понятий, называется обширным интерфейсом.
Опишем "общий" контейнер объектов типа T:

          class container {
          public:
            struct Bad_operation { // класс особых ситуаций
                const char* p;
                Bad_operation(const char* pp) : p(pp) { }
            };

            virtual void put(const T*)
               { throw Bad_operation("container::put"); }
            virtual T* get()
               { throw Bad_operation("container::get"); }

            virtual T*& operator[](int)
               { throw Bad_operation("container::[](int)"); }
            virtual T*& operator[](const char*)
               { throw Bad_operation("container::[](char*)"); }
            // ...
          };

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

     class slist_container : public container, private slist {
     public:
       void put(const T*);
       T* get();

       T*& operator[](int)
           { throw Bad_operation("slist::[](int)"); }
       T*& operator[](const* char)
           { throw Bad_operation("slist::[](char*)"); }
       // ...
     };

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

      class vector_container : public container, private vector {
      public:
         T*& operator[](int);
         T*& operator[](const char*);
         // ...
      };

Если быть осторожным, то все работает нормально:

      void f()
      {
        slist_container sc;
        vector_container vc;
        // ...
      }

      void user(container& c1, container& c2)
      {
        T* p1 = c1.get();
        T* p2 = c2[3];
        // нельзя использовать c2.get() или c1[3]
        // ...
      }

Все же для избежания ошибок при выполнении программы часто приходится
использовать динамическую информацию о типе ($$13.5) или особые
ситуации ($$9). Приведем пример:

       void user2(container& c1, container& c2)
       /*
          обнаружение ошибки просто, восстановление - трудная задача
       */
       {
         try {
             T* p1 = c1.get();
             T* p2 = c2[3];
             // ...
          }
          catch(container::Bad_operation& bad) {
            // Приехали!
            // А что теперь делать?
          }
        }

или другой пример:

        void user3(container& c1, container& c2)
        /*
          обнаружение ошибки непросто,
          а восстановление по прежнему трудная задача
        */
        {
          slist* sl = ptr_cast(slist_container,&c1);
          vector* v = ptr_cast(vector_container, &c2);

          if (sl && v) {
             T* p1 = c1.get();
             T* p2 = c2[3];
             // ...
          }
          else {
             // Приехали!
             // А что теперь делать?
          }
        }

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

        13.7 Каркас области приложения

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

         class filter {
         public:
           class Retry {
           public:
             virtual const char* message() { return 0; }
           };

         virtual void start() { }
         virtual int retry() { return 2; }
         virtual int read() = 0;
         virtual void write() { }
         virtual void compute() { }
         virtual int result() = 0;
       };

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

       int main_loop(filter* p)
       {
         for (;;) {
             try {
                 p->start();
                 while (p->read()) {
                       p->compute();
                       p->write();
                 }
                 return p->result();
             }
             catch (filter::Retry& m) {
               cout << m.message() << '\n';
               int i = p->retry();
               if (i) return i;
             }
             catch (...) {
               cout << "Fatal filter error\n";
               return 1;
             }
           }
         }

Теперь прикладную программу можно написать так:

         class myfilter : public filter {
            istream& is;
            ostream& os;
            char c;
            int nchar;

         public:
            int read() { is.get(c); return is.good(); }
            void compute() { nchar++; };
            int result()
                { os << nchar
                     << "characters read\n";
                     return 0;
                }

            myfilter(istream& ii, ostream& oo)
              : is(ii), os(oo), nchar(0) { }
         };

и вызывать ее следующим образом:

        int main()
        {
          myfilter f(cin,cout);
          return main_loop(&f);
        }

Настоящий каркас, чтобы рассчитывать на применение в реальных задачах,
должен создавать более развитые структуры и предоставлять больше
полезных функций, чем в нашем простом примере. Как правило, каркас
образует дерево узловых классов. Прикладной программист поставляет
только классы, служащие листьями в этом многоуровневом дереве,
благодаря чему достигается общность между различными прикладными
программами и упрощается повторное использование полезных функций,
предоставляемых каркасом. Созданию каркаса могут способствовать
библиотеки, в которых определяются некоторые полезные классы, например,
такие как scrollbar ($$12.2.5) и dialog_box ($$13.4). После определения
своих прикладных классов программист может использовать эти классы.

        13.8 Интерфейсные классы

Про один из самых важных видов классов обычно забывают - это "скромные"
интерфейсные классы. Такой класс не выполняет какой-то большой
работы, ведь иначе, его не называли бы интерфейсным. Задача
интерфейсном класса приспособить некоторую полезную функцию к
определенному контексту. Достоинство интерфейсных классов в том,
что они позволяют совместно использовать полезную функцию, не загоняя
ее в жесткие рамки. Действительно, невозможно рассчитывать, что функция
сможет сама по себе одинаково хорошо удовлетворить самые разные запросы.
   Интерфейсный класс в чистом виде даже не требует генерации кода.
Вспомним описание шаблона типа Splist из $$8.3.2:

          template<class T>
          class Splist : private Slist<void*> {
          public:
            void insert(T* p) { Slist<void*>::insert(p); }
            void append(T* p) { Slist<void*>::append(p); }
            T* get() { return (T*) Slist<void*>::get(); }
          };

Класс Splist преобразует список ненадежных обобщенных указателей
типа void* в более удобное семейство надежных классов, представляющих
списки. Чтобы применение интерфейсных классов не было слишком накладно,
нужно использовать функции-подстановки. В примерах, подобных
приведенному, где задача функций-подстановок только подогнать
тип, накладные расходы в памяти и скорости выполнения программы
не возникают.
   Естественно, можно считать интерфейсным абстрактный
базовый класс, который представляет абстрактный тип, реализуемый
конкретными типами ($$13.3), также как и управляющие классы
из раздела 13.9. Но здесь мы рассматриваем классы, у которых нет
иных назначений - только задача адаптации интерфейса.
   Рассмотрим задачу слияния двух иерархий классов с помощью
множественного наследования. Как быть в случае коллизии
имен, т.е. ситуации, когда в двух классах используются виртуальные
функции с одним именем, производящие совершенно разные операции?
Пусть есть видеоигра под названием "Дикий запад", в которой диалог
с пользователем организуется с помощью окна общего вида (класс
Window):

          class Window {
             // ...
             virtual void draw();
          };

          class Cowboy {
             // ...
             virtual void draw();
         };

         class CowboyWindow : public Cowboy, public Window {
            // ...
         };

В этой игре класс CowboyWindow представляет движение ковбоя на экране
и управляет взаимодействием игрока с ковбоем. Очевидно, появится
много полезных функций, определенных в классе Window и
Cowboy, поэтому предпочтительнее использовать множественное наследование,
чем описывать Window или Cowboy как члены. Хотелось бы передавать
этим функциям в качестве параметра объект типа CowboyWindow, не требуя
от программиста указания каких-то спецификаций объекта. Здесь
как раз и возникает вопрос, какую функции выбрать для CowboyWindow:
Cowboy::draw() или Window::draw().
    В классе CowboyWindow может быть только одна функция с именем
draw(), но поскольку полезная функция работает с объектами Cowboy
или Window и ничего не знает о CowboyWindow, в классе CowboyWindow
должны подавляться (переопределяться) и функция Cowboy::draw(), и
функция Window_draw(). Подавлять обе функции с помощью одной -
draw() неправильно, поскольку, хотя используется одно имя, все же
все функции draw() различны и не могут переопределяться одной.
    Наконец, желательно, чтобы в классе CowboyWindow наследуемые
функции Cowboy::draw() и Window::draw() имели различные однозначно
заданные имена.
    Для решения этой задачи нужно ввести дополнительные классы для
Cowboy и Window. Вводится два новых имени
для функций draw() и гарантируется, что их вызов
в классах Cowboy и Window приведет к вызову функций с новыми именами:

         class CCowboy : public Cowboy {
            virtual int cow_draw(int) = 0;
            void draw() { cow_draw(i); } // переопределение Cowboy::draw
         };

         class WWindow : public Window {
            virtual int win_draw() = 0;
            void draw() { win_draw(); } // переопределение Window::draw
         };

Теперь с помощью интерфейсных классов CCowboy и WWindow можно
определить класс CowboyWindow и сделать требуемые переопределения
функций cow_draw() и win_draw:

         class CowboyWindow : public CCowboy, public WWindow {
           // ...
           void cow_draw();
           void win_draw();
         };

Отметим, что в действительности трудность возникла лишь потому, что
у обеих функций draw()  одинаковый тип параметров. Если бы типы
параметров различались, то обычные правила разрешения неоднозначности
при перегрузке гарантировали бы, что трудностей не возникнет, несмотря на
наличие различных функций с одним именем.
    Для каждого случая использования интерфейсного класса можно
предложить такое расширение языка, чтобы требуемая адаптация
проходила более эффективно или задавалась более элегантным способом.
Но такие случаи являются достаточно редкими, и нет смысла чрезмерно
перегружать язык, предоставляя специальные средства для каждого
отдельного случая. В частности, случай коллизии имен при слиянии иерархий
классов довольно редки, особенно если сравнивать с
тем, насколько часто программист создает классы. Такие случаи
могут возникать при слиянии иерархий классов из разных
областей (как в нашем примере: игры и операционные системы).
Слияние таких разнородных структур классов всегда непростая задача,
и разрешение коллизии имен является в ней далеко не самой трудной
частью. Здесь возникают проблемы из-за разных стратегий обработки
ошибок, инициализации, управления памятью. Пример, связанный
с коллизией имен, был приведен потому, что предложенное решение:
введение интерфейсных классов с функциями-переходниками, - имеет
много других применений. Например, с их помощью можно менять
не только имена, но и типы параметров и возвращаемых значений,
вставлять определенные динамические проверки и т.д.
   Функции-переходники CCowboy::draw() и WWindow_draw являются
виртуальными, и простая оптимизация с помощью подстановки невозможна.
Однако, есть возможность, что транслятор распознает такие функции
и удалит их из цепочки вызовов.
   Интерфейсные функции служат для приспособления интерфейса к
запросам пользователя. Благодаря им в интерфейсе собираются операции,
разбросанные по всей программе. Обратимся к классу vector из $$1.4.
Для таких векторов, как и для массивов, индекс
отсчитывается от нуля. Если пользователь хочет работать с
диапазоном индексов, отличным от диапазона 0..size-1, нужно сделать
соответствующие приспособления, например, такие:

          void f()
          {
            vector v(10);  // диапазон [0:9]

            // как будто v в диапазоне [1:10]:

            for (int i = 1; i<=10; i++) {
               v[i-1] = ... // не забыть пересчитать индекс

            }
            // ...
          }

Лучшее решение дает класс vec c произвольными границами индекса:

          class vec : public vector {
            int lb;
          public:
            vec(int low, int high)
               : vector(high-low+1) { lb=low; }

            int& operator[](int i)
               { return vector::operator[](i-lb); }

            int low() { return lb; }
            int high() { return lb+size() - 1; }
          };

Класс vec можно использовать без дополнительных операций, необходимых
в первом примере:

          void g()
          {
            vec v(1,10);  // диапазон [1:10]

            for (int i = 1; i<=10; i++) {
                v[i] = ...

            }
            // ...
          }

Очевидно, вариант с классом vec нагляднее и безопаснее.
   Интерфейсные классы имеют и другие важные области применения,
например, интерфейс между программами на С++ и программами на другом
языке ($$12.1.4) или интерфейс с особыми библиотеками С++.

        13.9 Управляющие классы

Концепция абстрактного класса дает эффективное средство для разделения
интерфейса и его реализации. Мы применяли эту концепцию и получали
постоянную связь между интерфейсом, заданным абстрактным типом,
и реализацией, представленной конкретным типом. Так, невозможно
переключить абстрактный итератор с одного класса-источника на
другой, например, если исчерпано множество (класс set), невозможно
перейти на потоки.
    Далее, пока мы работаем с объектами абстрактного типа с помощью
указателей или ссылок, теряются все преимущества виртуальных
функций. Программа пользователя начинает зависеть от конкретных классов
реализации. Действительно, не зная размера объекта, даже при
абстрактном типе нельзя разместить объект в стеке, передать как параметр
по значению или разместить как статический. Если работа с объектами
организована через указатели или ссылки, то задача распределения
памяти перекладывается на пользователя ($$13.10).
   Существует и другое ограничение, связанное с использованием абстрактных
типов. Объект такого класса всегда имеет определенный размер,
но классы, отражающие реальное понятие, могут требовать память
разных размеров.
   Есть распространенный прием преодоления этих трудностей, а именно,
разбить отдельный объект на две части: управляющую, которая определяет
интерфейс объекта, и содержательную, в которой находятся все
или большая часть атрибутов объекта. Связь между двумя частями
реализуется с помощью указателя в управляющей части на содержательную
часть. Обычно в управляющей части кроме указателя есть
и другие данные, но их немного. Суть в том, что состав управляющей
части не меняется при изменении содержательной части, и она
настолько мала, что можно свободно работать с самими объектами,
а не с указателями или ссылками на них.

        управляющая часть           содержательная часть

Простым примером управляющего класса может служить класс string из
$$7.6. В нем содержится интерфейс, контроль доступа и управление
памятью для содержательной части. В этом примере управляющая и
содержательная части представлены конкретными типами, но чаще
содержательная часть представляется абстрактным классом.
   Теперь вернемся к абстрактному типу set из $$13.3. Как можно
определить управляющий класс для этого типа, и какие это даст плюсы
и минусы? Для данного класса set можно определить управляющий
класс просто перегрузкой операции ->:

         class set_handle {
            set* rep;
         public:
            set* operator->() { return rep; }

            set_handler(set* pp) : rep(pp) { }
         };

Это не слишком влияет на работу с множествами, просто передаются
объекты типа set_handle вместо объектов типа set& или set*,
например:

         void my(set_handle s)
         {
           for (T* p = s->first(); p; p = s->next())
           {
              // ...
           }
           // ...
         }

         void your(set_handle s)
         {
           for (T* p = s->first(); p; p = s->next())
           {
             // ...
           }
           // ...
         }

         void user()
         {
           set_handle sl(new slist_set);
           set_handle v(new vector_set v(100));

           my(sl);
           your(v);

           my(v);
           your(sl);
         }

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

         class set {
         friend class set_handle;
         protected:
           int handle_count;
         public:
           virtual void insert(T*) = 0;
           virtual void remove(T*) = 0;

           virtual int is_member(T*) = 0;

           virtual T* first() = 0;
           virtual T* next() = 0;

           set() : handle_count(0) { }
         };

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

         class set_handle {
           set* rep;
         public:
           set* operator->() { return rep; }

         set_handle(set* pp)
            : rep(pp) { pp->handle_count++; }
         set_handle(const set_handle& r)
            : rep(r.rep) { rep->handle_count++; }

         set_handle& operator=(const set_handle& r)
         {
            rep->handle_count++;
            if (--rep->handle_count == 0) delete rep;
            rep = r.rep;
            return *this;
          }

          ~set_handle()
             { if (--rep->handle_count == 0) delete rep; }
        };

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

          class set_handle {
            set* rep;
          public:
            // ...

          set* get_rep() { return rep; }

          void bind(set* pp)
          {
            pp->handle_count++;
            if (--rep->handle_count == 0) delete rep;
            rep = pp;
          }
       };

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

        template<class T> class handle {
           T* rep;
        public:
           T* operator->() { return rep; }
           // ...
        };

Но при таком подходе требуется взаимодействие между
управляющим и "управляемым" классами. Если управляющий и управляемые
классы разрабатываются совместно, например, в процессе создания
библиотеки, то это может быть допустимо. Однако, существуют и другие
решения ($$13.10).
     За счет перегрузки операции -> управляющий класс получает
возможность контроля и выполнения каких-то операций при каждом
обращении к объекту. Например, можно вести подсчет частоты
использования объектов через управляющий класс:

        template<class T>
           class Xhandle {
             T* rep;
             int count;
           public:
             T* operator->() { count++; return rep; }

             // ...
           };

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

           class set_controller {
             set* rep;
             // ...
           public:

             lock();
             unlock();

             virtual void insert(T* p)
               { lock(); rep->insert(p); unlock(); }
             virtual void remove(T* p)
               { lock(); rep->remove(p); unlock(); }

             virtual int is_member(T* p)
               { return rep->is_member(p); }

             virtual T* first() { return rep->first(); }
             virtual T* next() { return rep->next(); }

             // ...
           };

Писать функции-переходники для всего интерфейса утомительно (а значит
могут появляться ошибки), но не трудно и это не ухудшает
характеристик  программы.
   Заметим, что не все функции из set следует блокировать. Как
показывает опыт автора, типичный случай, когда операции до и после
обращения к объекту надо выполнять не для всех, а только для некоторых
функций-членов. Блокировка всех операций, как это делается в
мониторах некоторых операционных систем, является избыточной и может
существенно ухудшить параллельный режим выполнения.
   Переопределив все функции интерфейса в управляющем классе, мы
получили по сравнению с приемом перегруз