Классы как средство создания больших программных комплексов

15.1.3. Динамическое создание и удаление объектов

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

class A {...};    //объявление класса
..............
A *ps=new A;      //объявление указателя и создание объекта типа A
A* *pa=new A[20]; //объявление указателя и создание массива объектов
...............
delete ps;        //удаление объекта по указателю ps
delete [] pa;     //удаление массива объектов по указателю pa

Фактически, выполнение оператора new эквивалентно вызову конструктора класса, а обращение к оператору delete на автомате означает вызов деструктора. Создание одиночных объектов может быть совмещено с инициализацией объекта, если в классе предусмотрен соответствующий конструктор:

A *ptr1=new A(5);//создание объекта и вызов конструктора инициализации

Массив создаваемых объектов проинициализировать таким же образом нельзя.

В ранних версиях C++ для создания и уничтожения динамических объектов использовали обращения к функциям malloc ( запрос памяти ) и free ( освобождение памяти ). Неудобство применения этих функций по сравнению с операторами new/delete заключается в том, что для запроса памяти нужно знать количество байт, занимаемых объектом в оперативной памяти. Конечно, это не так уж и сложно – существует функция sizeof, с помощью которой длину объекта можно определить. Второе неудобство заключается в том, что функция malloc выдает указатель типа void* и его еще надо преобразовать к типу указателя на объект класса.

Довольно распространенная ситуация, которая может оказаться потенциальным источником ошибок, возникает в процессе создания и удаления динамических объектов. Она заключается в том, что после уничтожения объекта, связанного, например, с указателем ps, этот указатель не чистится. Если после удаления объекта сделать попытку что-то прочитать или записать по этому указателю, то поведение программы предсказать трудно. Поэтому достаточно разумным правилом является засылка нуля в указатель разрушаемого объекта:

delete ps;
  ps=NULL; 	//или ps=0;

15.1.4. Виртуальные функции

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

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

Рассмотрим пример, в котором базовый класс B содержит защищенное поле n и отображает его содержимое на экране. Производный класс D1 отображает квадрат доставшегося по наследству поля. Еще один класс D2, порожденный тем же родителем B, отображает куб своего наследства.

#include <iostream.h>
#include <conio.h>
class B {
public:
  B(int k):n(k){}	//конструктор инициализации
  virtual void show(){cout<<n<<endl;}	//виртуальная функция
protected:
  int n;
};
class D1: public B {
public:
  D1(int k):B(k){}	// конструктор инициализации
  virtual void show(){cout<<n*n<<endl;}
};
class D2: public B {
public:
  D2(int k):B(k){}	// конструктор инициализации
  virtual void show(){cout<<n*n*n<<endl;}
};
void main()
{ B bb(2),*ptr;
  D1 dd1(2);
  D2 dd2(2);
  ptr=bb;
  ptr->show();
  ptr=dd1;
  ptr->show();
  ptr=dd2;
  ptr->show();
  getch();
}
//=== Результат работы ===
2	//результат работы функции B::show
4	//результат работы функции D1::show
8	//результат работы функции D2::show

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

B *bptr;
  D1 dd1(2);
  bptr=dd1;        //вниз по иерархии классов без преобразования
  D1 *dptr;
  dptr=(D1 *)bptr;  //вверх по иерархии с преобразованием типа

15.1.5. Виртуальные деструкторы

Когда существует иерархия производных классов, и мы создаем массив динамических указателей на объекты разных производных классов, то при уничтожении такого рода объектов могут возникнуть проблемы. Продемонстрируем это на примере иерархии геометрических фигур: Shape (фигура базового класса), Circle (окружность, производная от Shape ) и Rectangle (прямоугольник, производный от Shape ):

#include <iostream.h>
class Shape {
public:
  Shape();		//конструктор по умолчанию
  ~Shape();	//стандартный деструктор
  virtual void show() {cout <<"Shape"<<endl;
};
class Circle: public Shape {
  int xc,yc,r;	//координаты центра и радиус
public:
  Circle(int x,int y,int R):xc(x),yc(y),r(R) {}	//конструктор
  ~Circle();	//стандартный деструктор
  void show() {cout<<"x="<<xc<<" 
    y="<<yc<<" r="<<r<<endl;
};
class Rectangle: public Shape {
  int x1,y1,x2,y2;	//координаты противоположных вершин
public:
  Rectangle(int ix1,int iy1,int ix2,int iy2):
		 x1(ix1),y1(iy1),x2(ux2),y2(iy2) {}	//конструктор
  ~Rectangle();	//стандартный деструктор

Создаем массив указателей на объекты базового класса и присваиваем им адреса динамически создаваемых объектов:

Shape *ptr_s[2];
  ptr_s[0]=new Circle(20,20,10)
  ptr_s[1]=new Rectangle(20,40,50,50);

Поработали с временно созданными объектами, и пришла пора их удалить. Попытка сделать это следующим способом ни к чему хорошему не приведет:

for(int i=0; i<2; i++) delete ptr_s[i];

Причина заключается в том, что для удаления этих фигур будет вызван деструктор класса Shape (именно на объекты этого класса был объявлен массив указателей ptr_s ). А ресурсы, занятые окружностью и прямоугольником, при этом не будут освобождены. Выход из создавшегося положения довольно простой – надо объявить деструктор базового класса виртуальным ( virtual ~Shape(); ). Тогда автоматически виртуальными станут и деструкторы производных классов (хотя деструкторы и не наследуются). И все проблемы, связанные с утечкой памяти, будут решены.

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

15.1.6. Чистые виртуальные функции и абстрактные классы

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

virtual тип name_f(тип1 a1,тип2 a2,...)=0;

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

Объявим абстрактным класс Shape (Геометрическая Фигура), в состав которого включим две чистые виртуальные функции – определение площади фигуры ( Get_Area ) и определение периметра фигуры ( Get_Perim ).

class Shape {
public:
  Shape(){}	//конструктор
  virtual double Get_Area()=0;
  virtual double Get_Perim()=0;
};
class Rectangle: public Shape {
  double w,h;	//ширина и высота
public:
  Rectangle(double w1,double h1):w(w1),h(h1) {}
  double Get_Area() {return w*h;}
  double Get_Perim() {return 2*w+2*h);}
};
class Circle: public Shape {
  double r;	//радиус
public:
  Circle(double r1):r(r1) {}
  double Get_Area() {return M_PI*r*r;}
  double Get_Perim() {return 2*M_PI*r;}
};

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

15.2. Множественное наследование и виртуальные классы

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

class B1 {//первый базовый класс
  int x;
public:
  B1(int n):x(n) {cout<<"Init_B1"<<endl;}      //конструктор B1
  int get_x(){return x;}
  ~B1() {cout<<"Destr_B1"<<endl;}              //деструктор B1
};
class B2 {//второй базовый класс
  int y;
public:
  B2(int n):y(n) {cout<<"Init_B2"<<endl;}      // конструктор B2
  int get_y(){return y;}
  ~B2() {cout<<"Destr_B2"<<endl;}              //деструктор B2
};
class D: public B1, public B2 {
  int z;
public:
  D(int a,int b,int c):B1(a),B2(b),z(c) 
   {cout<<"Init_D"<<endl;}                     //конструктор D
  void show() {cout<<"x="<<get_x()<<" y="<<get_y()<<" z="<<z<<endl;}
  ~D() {cout<<"Destr_D"<<endl;}                //деструктор D
};
#include <iostream.h>
void main()
{ D qq(1,2,3);
  qq.show();
}
//=== Результат работы ===
Init_B1
Init_B2
Init_D
x=1 y=2 z=3
Destr_D
Destr_B2
Destr_B1

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

При множественном наследовании может возникнуть некоторая неопределенность, связанная с тем, что родительские данные могут попытаться попасть в производный класс несколькими путями. Например, классы A и B являются родителями класса C. Если в формировании класса D участвуют классы A и C, то данные-потомки класса A попадают в класс D и прямым путем, и в составе наследства класса C. И тогда перед компилятором возникает неразрешимая проблема – с какой веточкой унаследованных данных надо работать и методы какого класса надо вызывать. Для разрешения такой двойственности класс A должен быть объявлен виртуальным:

class B: virtual public A {
...//описание класса B
};
class C: virtual public A, public B {
   //описание класса C
};

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

15.3. Объектно-ориентированный подход к созданию графической системы

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

Поэтому мы ограничимся лишь демонстрацией простейшей графической системы, имеющей в своем распоряжении минимальное число графических объектов – точки, окружности и залитые окружности. Эти объекты можно будет создавать в оперативной памяти, отображать на экране, делать невидимыми и перемещать по экрану в заданное место. Более того, для манипуляций с этими объектами мы воспользуемся существующей в среде BC 3.1 библиотекой процедур BGI (Borland Graphics Interface), обеспечивающих перевод экрана в простейший графический режим (режим VGA с разрешением 640x480) и отображение на нем графических примитивов. Однако детали работы с этой библиотекой мы постараемся скрыть от пользователя. Основная цель нашей демонстрации – показать главные аспекты объектно-ориентированного подхода на достаточно наглядном примере.

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

#include <graphics.h>
int gs;
void open_gs()
{ int gd=0,gm;
  initgraph(gd,gm,"");
  gs=1;
}
void close_gs()
{ closegraph(); gs=0; }

Заголовочный файл graphics.h содержит заголовки функций и описания констант библиотеки BGI. Переменная gs, может быть, понадобится в будущем для индикации готовности графической системы к работе (при gs=1 система открыта для работы с графическими объектами, закрытие системы сопровождается засылкой нуля в переменную gs ). Для приведения библиотеки BGI в состояние готовности используется процедура initgraph и графический драйвер egavga.bgi, который мы из соображений удобства разместим в своем текущем каталоге. Восстановление текстового режима работы дисплея осуществляется процедурой closegraph из библиотеки BGI. Однако пользователь о деталях работы с процедурами BGI ничего знать не должен. Для "открытия" графической системы он должен обратиться к процедуре open_gs, а для закрытия – к процедуре close_gs (почти полная аналогия открытия и закрытия файлов).

Описание нашей графической системы мы начнем с абстрактного класса GO (от Graphics Object).

class GO {
protected: 
  int x,y,is_v,fc,bc;
public:
  GO():x(0),y(0),is_v(0),bc(15),fc(0)
    { setcolor(fc);setbkcolor(bc); }
  GO(int x1,int y1,int c=0):x(x1),y(y1),is_v(0),fc(c),bc(15)
    { setcolor(fc);setbkcolor(bc); }
  virtual void hide()=0;
  virtual void show()=0;
  void move(int x1,int y1);
};

Защищенными данными в этом классе являются:

Конструктор по умолчанию считает, что точкой привязки графического объекта является начало координат (верхний левый угол экрана). С помощью процедуры setcolor устанавливается черный цвет рисования ( fc=0 ), а с помощью процедуры setbkcolor – белый цвет фона ( bc=15 ).

В классе GO объявлены два чисто виртуальных метода – hide (стереть изображение объекта) и show (отобразить объект). Метод move осуществляет перемещение объекта в новую точку привязки и не является виртуальным. Поэтому мы его определим за пределами описания класса:

void GO::move(int x1,int y1)
{ hide();       //стереть прежнее изображение объекта
  x=x1; y=y1;   //изменить координаты точки привязки
  show();       //отобразить объект в новом месте
}

Теперь определим производный класс point, с помощью которого вводятся объекты типа "точка" и манипуляции с объектами этого типа. Новый класс наследует от класса GO все данные (повторять их в классе point не надо). Конструкторы класса point явно вызывают конструкторы родителя, передавая им в случае необходимости недостающие параметры.

class point: public GO {
public:
  point():GO() {}
  point(int x1,int y1,int c=0):GO(x1,y1,c) {}
  void hide();
  void show();
};

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

void point::hide()	//стирание точки
{ if(is_v) { putpixel(x,y,bc); is_v=0; } }
void point::show()	//отображение точки
{ if(!is_v) { putpixel(x,y,fc); is_v=1; } }

Для перемещения точки сохраняется родительская процедура move, которая теперь обращается не к виртуальным, а реальным методам класса point – hide и show.

Добавим класс circ, производный от класса GO и предназначенный для работы с объектами типа "окружность". В дополнение к данным, унаследованным от родителя, здесь понадобится еще и радиус окружности (переменная r )

class circ: public GO {
  int r;
public:
  circ():GO(),r(1){ }
  circ(int x1,int y1,int r1,int c=0): GO(x1,y1,c),r(r1) { }
  void hide();
  void show();
};

Унаследованные виртуальные методы hide и show здесь также придется переопределить. Для стирания видимой окружности используем процедуру построения объекта, задав в качестве цвета рисования цвет фона.

void circ::hide()       //стирание окружности
{ if(is_v==0) return;
  int fc1=getcolor();   //запоминание цвета рисования
  setcolor(bc);         //замена цвета рисования на цвет фона
  circle(x,y,r);        //построение окружности
  setcolor(fc1);        //восстановление цвета рисования
  is_v=0;
}
void circ::show()       //отображение окружности
{ if(is_v) return;
  int fc1=getcolor();   //запоминание цвета рисования
  setcolor(fc);         //замена на цвет объекта
  circle(x,y,r);        //построение окружности
  setcolor(fc1);        //восстановление цвета рисования
  is_v=1;
}

Класс circf для работы с залитыми окружностями тоже образуем из класса GO.

class circf: public GO {
  int r;
public:
  circf():GO(),r(1){}
  circf(int x1,int y1,int r1,int c=0):r(r1),GO(x1,y1,c) {}
  void show();
  void hide();
};

Для реализации метода show воспользуемся процедурой построения залитого эллипса – fillellipse. Но предварительно потребуется задать шаблон заливки, соответствующий сплошному заполнению замкнутой области (графическая константа SOLID_FILL=1 ), и цвет заливки, равный цвету объекта (значение переменной fc ). Обе эти установки выполняются библиотечной процедурой setfillstyle.

void circf::show()
{ if(is_v) return;
  setfillstyle(1,fc);     //установка стиля и цвета заливки
  fillellipse(x,y,r,r);   //построение залитой окружности
  is_v=1;
}

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

void circf::hide()
{ if(!is_v) return;
  setfillstyle(1,bc);     //установка стиля и цвета заливки
  fillellipse(x,y,r,r);   //стирание залитой окружности
  setcolor(bc);           //замена цвета рисования на цвет фона
  circle(x,y,r);          //стирание границы окружности
  setcolor(fc);           //восстановление цвета рисования
  is_v=0;
}

А теперь настало время апробировать нашу графическую систему. Если забыть о содержимом файла gs.h и о времени, затраченном на его создание, то работа с допустимым набором графических объектов выглядит абсолютно прозрачно. После каждой графической манипуляции организована пауза в работе программы до нажатия любой клавиши. Это дает возможность рассмотреть на экране результат очередной операции.

#include "gs.h"
#include <conio.h>
void main()
{ open_gs();		//открытие графической системы
//Объявление графических объектов
  point P1(21,10,2);		//зеленая точка (21,10)
  circ C1(21,50,20,4);		//красная окружность радиуса 20
  circf CF1(21,100,20,12);	//залитая окружность
//Отображение графических объектов 
  P1.show();  getch();		//показ точки
  C1.show();  getch();		//показ окружности
  CF1.show(); getch();		//показ залитой окружности
//Перемещение графических объектов
  P1.move(121,10);   getch();	//сдвиг точки
  C1.move(121,50);   getch();	//сдвиг окружности
  CF1.move(121,100); getch();	//сдвиг залитой окружности
//Стирание графических объектов
  P1.hide();  getch();		//стирание точки
  C1.hide();  getch();		//стирание окружности
  CF1.hide(); getch();		//стирание залитой окружности
// Перемещение графических объектов
  P1.move(221,10);   getch();	//сдвиг точки
  C1.move(221,50);   getch();	//сдвиг окружности
  CF1.move(221,100); getch();	//сдвиг залитой окружности
  close_gs();		//закрытие графической системы
}

Можно создать массив указателей на объекты класса GO и заполнить его адресами графических объектов разного типа. Применение к этим указателям методов с одними и теми же названиями, приводит к вызовам методов тех классов, чей тип совпадает с типом адресуемого объекта. Это и есть демонстрация одного из важнейших принципов объектно- ориентированного подхода – полиморфизма:

#include "gs.h"
#include <conio.h>
void main()
{ open_gs();
  point P1(21,10,2);
  circ C1(21,50,20,4);
  circf CF1(21,100,20,12);
  GO *m[3]={P1,C1,CF1};             //массив указателей
  for(int i=0;i<3;i++) m[i]->show();   //отображение объектов
  getch();
  m[0]->move(121,10); getch();         //сдвиг точки
  m[1]->move(121,50); getch();         //сдвиг окружности
  m[2]->move(121,100); getch();        //сдвиг залитой окружности
  close_gs();
}