Производные Классы

Не надо размножать объекты без необходимости - У. Оккам

7.1 Введение

7.2 Производные Классы

7.2.1 Построение Производного Класса

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

  struct employee {          // служащий
      char*    name;        // имя
      short    age;         // возраст
      short    department;  // подразделение
      int      salary;      //
      employee* next;
      // ...
  };

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

  struct manager {           // менеджер
      employee emp;          // запись о менеджере как о служащем
      employee* group;       // подчиненные люди
      // ...
  };

Менеджер также является служащим; относящиеся к служащему employee данные хранятся в члене emp объекта manager. Для читающего это человека это, может быть, очевидно, но нет ничего выделяющего член emp для компилятора. Указатель на менеджера (manager*) не является указателем на служащего (employee*), поэтому просто использовать один там, где требуется другой, нельзя. В частности, нельзя поместить менеджера в список служащих, не написав для этого специальную программу. Можно либо применить к manager* явное преобразование типа, либо поместить в список служащих адрес члена emp, но и то и другое мало элегантно и довольно неясно. Корректный подход состоит в том, чтобы установить, что менеджер является служащим с некоторой добавочной информацией:

  struct manager : employee {
      employee* group;
      // ...
  };

manager является производным от employee и, обратно, employee есть базовый класс для manager. Класс manager дополнительно к члену group имеет члены класса employee (name, age и т.д.).
Имея определения employee и manager мы можем теперь создать список служащих, некоторые из которых являются менеджерами. Например:

  void f()
  {
      manager m1, m2;
      employee e1, e2;
      employee* elist;
      elist = &m1;     // поместить m1, e1, m2 и e2 в elist
      m1.next = &e1;
      e1.next = &m2;
      m2.next = &e2;
      e2.next = 0;
  }

7.2.2 Функции Члены

Просто структуры данных вроде employee и manager на самом деле не столь интересны и часто не особенно полезны, поэтому рассмотрим, как добавить к ним функции. Например:

  class employee {
      char* name;
      // ...
  public:
      employee* next;
      void print();
      // ...
  };
  class manager : public employee {
      // ...
  public:
      void print();
      // ...
  };

Надо ответить на некоторые вопросы. Как может функция член производного класса manager использовать члены его базового класса employee? Как члены базового класса employee могут использовать функции члены производного класса manager? Какие члены базового класса employee может использовать функция не член на объекте типа manager? Каким образом программист может повлиять на ответы на эти вопросы, чтобы удовлетворить требованиям приложения?
Рассмотрим:

  void manager::print()
  {
      cout << " имя " << name << "\n"; // ... } 

  class employee {
      friend void manager::print();
      // ...
  };

решило бы проблему с manager::print(), и

  class employee {
  friend class manager;
      // ...
  };

сделало бы  доступным каждый  член employee для всех функций класса
manager.   В    частности,   это   сделает   name   доступным   для
manager::print().

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

  void manager::print()
  {
      employee::print();    // печатает информацию о служащем
      // ...                // печатает информацию о  менеджере
  }

Заметьте, что  надо использовать  ::,  потому  что    print()  была
переопределена  в   manager.  Такое  повторное  использование  имен
типично. Неосторожный мог бы написать так:

  void manager::print()
  {
      print();              // печатает информацию о служащем
      // ...                // печатает информацию о  менеджере
  }

7.2.3 Видимость

Класс employee стал открытым (public) базовым классом класса manager в результате описания:

  class manager : public employee {
      // ...
  };

Это означает,  что открытый  член класса  employee является также и
открытым членом класса manager. Например:

  void clear(manager* p)
  {
      p->next = 0;
  }

будет компилироваться,  так как  next -  открытый член и employee и
manager'а.  Альтернатива  -  можно  определить  закрытый  (private)
класс, просто опустив в описании класса слово public:

  class manager : employee {
      // ...
  };

Это означает,  что открытый  член класса employee является закрытым
членом класса  manager. То есть, функции члены класса manager могут
как и  раньше использовать  открытые члены  класса employee, но для
пользователей класса manager эти члены недоступны. В частности, при
таком описании  класса manager  функция clear()  компилироваться не
будет. Друзья  производного класса  имеют к  членам базового класса
такой же доступ, как и функции члены.

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

Когда  описывается   производная  struct,  ее  базовый  класс  по
умолчанию является public базовым классом. То есть,

  struct D : B { ...

означает

  class D : public B { public: ...

Отсюда следует,  что если  вы не  сочли полезным то скрытие данных,
которое  дают   class,  public   и  friend,  вы  можете  просто  не
использовать эти  ключевые слова  и  придерживаться  struct.  Такие
средства  языка,  как  функции  члены,  конструкторы  и  перегрузка
операций, не зависят от механизма скрытия данных.

  Можно также  объявить некоторые,  но не  все,  открытые  $  члены
базового класса открытыми членами производного класса. Например:

  class manager : employee {
      // ...
  public:
      // ...
      employee::name;
      employee::department;
  };

Запись

  имя_класса :: имя_члена ;

7.2.4 Указатели

Если производный класс derived имеет открытый базовый класс base, то указатель на derived можно присваивать переменной типа указатель на base не используя явное преобразование типа. Обратное преобразование, указателя на base в указатель на derived, должно быть явным. Например:

  class base { /* ... */ };
  class derived : public base { /* ... */ };
  derived m;
  base* pb = &m;     // неявное преобразование
  derived* pd = pb;  // ошибка: base* не является derived*
  pd = (derived*)pb; // явное преобразование

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

  Будь  base  закрытым  базовым  классом  класса  derived,  неявное
преобразование  derived*   в  base*   не   делалось   бы.   Неявное
преобразование не  может в этом случае быть выполнено, потому что к
открытому члкну  класса base  можно обращаться  через указатель  на
base, но нельзя через указатель на derived:

  class base {
      int m1;
  public:
      int m2;     // m2 - открытый член base
  };
  class derived : base {
      // m2 НЕ открытый член derived
  };
  derived d;
  d.m2 = 2;       // ошибка: m2 из закрытой части класса
  base* pb = &d;  // ошибка: (закрытый base)
  pb->m2 = 2;     // ok
  pb = (base*)&d; // ok: явное преобразование
  pb->m2 = 2;     // ok

7.2.5 Иерархия Типов

Производный класс сам может быть базовым классом. Например:

  class employee { ... };
  class secretary : employee { ... };
  class manager : employee { ... };
  class temporary : employee { ... };
  class consultant : temporary { ... };
  class director : manager { ... };
  class vice_president : manager { ... };
  class president : vice_president { ... };

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

  class temporary { ... };
  class employee { ... };
  class secretary : employee { ... };
  // не C++:
  class temporary_secretary : temporary : secretary { ... };
  class consultant : temporary : employee { ... };

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

  class temporary { ... };
  class employee { ... };
  class secretary : employee { ... };
  // Альтернатива:
  class temporary_secretary : secretary
  { temporary temp; ... };
  class consultant : employee
  { temporary temp; ... };

7.2.6 Конструкторы и Деструкторы

Для некоторых производных классов нужны конструкторы. Если у базового класса есть конструктор, он должен вызываться, и если для этого конструктора нужны параметры, их надо предоставить. Например:

  class base {
      // ...
  public:
      base(char* n, short t);
      ~base();
  };
  class derived : public base {
      base m;
  public:
      derived(char* n);
      ~derived();
  };

7.2.7 Поля Типа

7.2.8 Виртуальные Функции

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

  struct employee {
      employee* next;
      char*     name;
      short     department;
      // ...
      virtual void print();
  };

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

  void employee::print()
  {
      cout << e->name << "\t" << e->department << "\n"; // ... } 

  struct manager : employee {
      employee* group;
      short     level;
      // ...
      void print();
  };
  void manager::print()
  {
      employee::print();
      cout << "\tуровень" << level << "\n"; // ... } 

  void f(employee* ll)
  {
      for (; ll; ll=ll->next) ll->print();
  }

Каждый служащий  будет  печататься  в  соответствии  с  его  типом.
Например:

  main()
  {
      employee e;
          e.name = "Дж.Браун";
          e.department = 1234;
          e.next = 0;
      manager m;
          m.name = "Дж.Смит";
          e.department = 1234;
          m.level = 2;
          m.next = &e;
      f(&m);
  }

выдаст

  Дж.Смит 1234
          уровень 2
  Дж.Браун 1234

7.3 Альтернативные Интерфейсы

7.3.1 Интерфейс

Рассмотрим такое написание класса slist для однократно связанного списка, с помощью которого можно создавать как однородные, так и неоднородные списки объектов тех типов, которые еще должны быть определены. Сначала мы определим тип ent:

  typedef void* ent;

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

  class slink {
  friend class slist;
  friend class slist_iterator;
      slink* next;
      ent e;
      slink(ent a, slink* p) { e=a; next=p;}
  };

В  одном   звене  может  храниться  один  ent,  и  с  помощью  него
реализуется класс slist:

  class slist {
  friend class slist_iterator;
      slink* last;        // last->next - голова списка
  public:
      int insert(ent a);  // добавить в голову списка
      int append(ent a);  // добавить в хвост списка
      ent get();          // вернуться и убрать голову списка
      void clear();       // убрать все звенья
      slist()      { last=0; }
      slist(ent a) { last=new slink(a,0); last->next=last; }
      ~slist()     { clear(); }
  };

7.3.2 Реализация

7.3.3 Как Этим Пользоваться

Фактически класс slist в написанном виде бесполезен. В конечном счете, зачем можно использовать список указателей void*? Штука в том, чтобы вывести класс из slist и получить список тех объектов, которые представляют интерес в конкретной программе. Представим компилятор языка вроде C++. В нем широко будут использоваться списки имен; имя - это нечто вроде

  struct name {
      char* string;
      // ...
  };

В список  будут помещаться  указатели на  имена, а  не сами объекты
имена. Это  позволяет использовать  небольшое информационное поле e
slist'а, и дает возможность имени находиться одновременно более чем
в одном  списке. Вот определение класса nlist, который очень просто
выводится из класса slist:

  #include "slist.h"
  #include "name.h"
  struct nlist : slist {
      void insert(name* a) { slist::insert(a); }
      void append(name* a) { slist::append(a); }
      name* get()          {}
      nlist(name* a) : (a) {}
  };

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

7.3.5 Обобщенные Классы

7.3.6 Ограниченные Интерфейсы

Класс slist - довольно общего характера. Иногда подобная общность не требуется или даже нежелательна. Ограниченные виды списков, такие как стеки и очереди, даже более обычны, чем сам обобщенный список. Такие структуры данных можно задать, не описав базовый класс как открытый. Например, очередь целых можно определить так:

  #include "slist.h"
  class iqueue : slist {
                 //предполагается sizeof(int)<=sizeof(void*) public: void put(int a) { slist::append((void*)a); } int det() { return int(slist::get()); } iqueue() {} }; 

  #include "slist.h"
  class stack : slist {
  public:
      slist::insert;
      slist::get;
      stack() {}
      stack(ent a) : (a) {}
  };

который потом  используется для  создания типа  "стек указателей на
символы":

  #include "stack.h"
  class cp : stack {
  public:
      void push(char* a) { slist::insert(a); }
      char* pop() { return (char*)slist::get(); }
      nlist() {}
  };

7.4 Добавление к Классу

В предыдущих примерах производный класс ничего не добавлял к базовому классу. Для производного класса функции определялись только чтобы обеспечить преобразование типа. Каждый производный класс просто задавал альтернативный интерфейс к общему множеству программ. Этот специальный случай важен, но наиболее обычная причина определения новых классов как производных классов в том, что кто-то хочет иметь то, что предоставляет базовый класс, плюс еще чуть-чуть.
Для производного класса можно определить данные и функции дополнительно к тем, которые наследуются из его базового класса. Это дает альтернативную стратегию обеспечить средства связанного списка. Заметьте, когда в тот slist, который определялся выше, помещается элемент, то создается slink, содержащий два указателя. На их создание тратится время, а ведь без одного из указателей можно обойтись, при условии, что нужно только чтобы объект мог находиться в одном списке. Так что указатель next на следующий можно поместить в сам объект, вместо того, чтобы помещать его в отдельный объект slink. Идея состоит в том, чтобы создать класс olink с единственным полем next, и класс olist, который может обрабатывать указателями на такие звенья olink. Тогда olist сможет манипулировать объектами любого класса, производного от olink. Буква "o" в названиях стоит для того, чтобы напоминать вам, что объект может находиться одновременно только в одном списке olist:

  struct olink {
      olink* next;
  };

Класс olist  очень напоминает  класс slist.  Отличие состоит в том,
что пользователь  класса olist  манипулирует объектами класса olink
непосредственно:

  class olist {
      olink* last;
  public:
      void insert(olink* p);
      void append(olink* p);
      olink* get();
      // ...
  };

Мы можем вывести из класса olink класс name:

  class name : public olink {
      // ...
  };

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

  Объекты, помещаемы  в olist,  теряют свой  тип. Это означает, что
компилятор знает  только то,  что они olink'и. Правильный тип можно
восстановить с помощью явного преобразования типа объектов, вынутых
из olist. Например:

  void f()
  {
      olist ll;
      name nn;
      ll.insert(&nn);              // тип &nn потерян
      name* pn = (name*)ll.get();  // и восстановлен
  }

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

  class olist : public olist {
      // ...
      name* get() { return (name*)olist::get(); }
  };

7.5 Неоднородные Списки

7.6 Законченная Программа

7.6.1 Администратор Экрана

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

  // файл screen.h
  const XMAX=40, YMAX=24;
  struct point {
      int x,y;
      point() {}
      point(int a, int b) { x=a; y=b; }
  };
  overload put_point;
  extern void put_point(int a, int b);
  inline void put_point(point p) { put_point(p.x,p.y); }
  overload put_line;
  extern void put_line(int, int, int, int);
  inline void put_line(point a, point b)
      { put_line(a.x,a.y,b.x,b.y); }
  extern void screen_init();
  extern void screen_refresh();
  extern void screen_clear();
  #include

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

  #include "screen.h"
  #include
  enum color { black='*', white=' ' };
  char screen[XMAX][YNAX];
  void screen_init()
  {
      for (int y=0; y=a || a<=b) y0 +="dy," eps } } 

  void screen_clear() { screen_init(); }  // очистка
  void screen_refresh()                   // обновление
  {
      for (int y=YMAX-1; 0<=y; y--) { // сверху вниз for (int x="0;" x 

7.6.2 Библиотека Фигур

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

  struct shape {
      shape() { shape_list.append(this); }
      virtual point north() { return point(0,0); } // север
      virtual point south() { return point(0,0); } // юг
      virtual point east() { return point(0,0); }  // восток
      virtual point neast() { return point(0,0); } // северо-восток
      virtual point seast() { return point(0,0); } // юго-восток
      virtual void draw() {};                      // нарисовать
      virtual void move(int, int) {};              // переместить
  };

7.6.3 Прикладная Программа

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

  #include "shape.h"
  class myshape : public rectangle {
      line* l_eye;                   // левый глаз
      line* r_eye;                   // правый глаз
      line* mouth;                   // рот
  public:
      myshape(point, point);
      void draw();
      void move(int, int);
  };

  Глаза и  рот -  отдельные и  независимые объекты, которые создает
конструктор my_shape:

  myshape::myshape(point a, point b) : (a,b)
  {
      int ll = neast().x-swest().x+1;
      int hh = neast().y-swest().y+1;
      l_eye = new line(
          point(swest().x+2,swest().y+hh*3/4),2);
      r_eye = new line(
          point(swest().x+ll-4,swest().y+hh*3/4),2);
      mouth = new line(
          point(swest().x+2,swest().y+hh/4),ll-4);
  }

  Объекты  глаза   и   рот   порознь   рисуются   заново   функцией
shape_refresh(), и  в принципе  могут обрабатываться  независимо из
объекта  my_shape,   которому  они  принадлежат.  Это  один  способ
определять средства  для иерархически  построенных  объектов  вроде
my_shape. Другой  способ демонстрируется  на примере  носа. Никакой
нос не  определяется,  его  просто  добавляет  к  картинке  функция
draw():

  void myshape::draw()
  {
      rectangle::draw();
      put_point(point(
          (swest().x+neast().x)/2,(swest().y+neast().y)/2));
  }

my_shape    передвигается    посредством    перемещения    базового
прямоугольника rectangle  и вторичных объектов l_eye, r_eye и mouth
(левого глаза, правого глаза и рта):

  void myshape::move()
  {
      rectangle::move();
      l_eye->move(a,b);
      r_eye->move(a,b);
      mouth->move(a,b);
  }

Мы  можем,   наконец,  построить   несколько  фигур  и  немного  их
подвигать:

  main()
  {
      shape* p1 = new rectangle(point(0,0),point(10,10));
      shape* p2 = new line(point(0,15),17);
      shape* p3 = new myshape(point(15,10),point(27,18));
      shape_refresh();
      p3->move(-10,-10);
      stack(p2,p3);
      stack(p1,p2);
      shape_refresh();
      return 0;
  }

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

Результатом работы программы будет: 

     ***********
     *         *
     *         *
     *         *
     *         *
     *         *
     *         *
     *         *
     *         *
     *         *
     ***********
  *****************
    *************
    *           *
    * **     ** *
    *           *
    *     *     *
    *           *
    * ********* *
    *           *
    *************

7.7 Свободная Память

7.8 Упражнения

  if (this == 0) this = (derived*)43;

И следовательно,  для d конструктор базового класса base::base() не
вызывался. Программа  была допустимой  и корректно  выполнялась, но
очевидно делала не то, что подразумевал автор. (прим. автора)