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

Заголовок
функции
template
... , type Ik]>
return_type funcn_name (arguments)
Тело
функции
{
}
В результате шаблонные функции можно вызывать как обычные функции, например, как показано в следующем программном коде. Результат его работы приведен на рисунке 3.1.

27 1 #include using namespace std; template
// Шаблон для вычисления квадрата
T Pow(T x){ return x*x;
} template
// Шаблон перестановки элементов
T* Swap(int I1, int I2, T* t) {
// здесь параметры
намеренно расположены в нерекомендуемом порядке для
демонстрации такой функциональности
T tmp = t[I1]; t[I1] = t[I2]; t[I2] = tmp; return t;
} int main( ){ int n=10, i = 2, j = 5; double d = 10.21; float arr[5] = {1.1, 2.2, 3.3, 4.4, 5.5}; string ss = "Template"; char* aa = &ss[0]; cout<< "The value of the n = " << n << endl << "The square of the n = " << Pow(n) << endl<< "The value of d
= " << d << endl << "The square of d = " << Pow(d) << endl << "The initial string = " << aa << endl << "The modified string = " << Swap(i, j, aa) << endl << "The initial array = "; for(auto i: arr) cout << i << " ";
cout << endl << "The modified array = ";
2 3
4 5
6 7
8 9
10 11 12 13 14 15 16 17 18 19 20 21 22 23

28 24 float * parr = Swap(0,4,arr); for(auto i: arr) cout << i << " ";
return 0;
}
25 26 27 28
The value of the n = 10
The square of the n = 100
The value of d = 10.21
The square of d = 104.244
The initial string = Template
The modified string = Template
The initial array = 1.1 2.2 3.3 4.4 5.5
The modified array = 5.5 2.2 3.3 4.4 1.1
Рис. 3.1 – Результат работы шаблонных функций
В приведенном примере вызовы шаблонной функции Sqr() и Sqr() для n и d приводят к построению двух порожденных функций для параметри- зованных типов, в данном случае это int и double соответственно. Аналогич- ное происходит и с шаблонной функцией Swap() с параметризованными ти- пами char* и float*. Поэтому процесс построения компилятором порожден- ной функции иногда называют конкретизацией шаблонной функции.
Стоит обратить внимание на то, что в приведенном примере при вызове шаблонных функций явно не были указаны параметризованные типы, поскольку компилятор по типу данных аргументов самостоятельно «выбрал» требуемые ре- ализации. Однако это не всегда возможно, поэтому рекомендуется явно указывать параметризованные типы при вызове шаблонных функций. В рассмотренном примере это соответствует
Pow (n),
Pow (d),
Swap (i, j, aa) и Swap (i, j, aa).
Как и для обычных функций, можно создать прототип шаблона функции в виде его предварительного объявления. Например:
«template < class T> Т* Swap(int I1, int I2 , T* t);».

29
При этом рекомендуется и объявление, и реализацию шаблонной функции помещать в заголовочный файл.
Важно помнить, что каждый параметризованный тип, указанный в списке параметров, должен использоваться в теле функции. Например, объявление
«template Т2 func (T2);» приведет к ошибке во время компиляции, т. к. тип T1 не используется в теле функции. (Подробное описание шаблонов дано в учебном пособии по дисци- плине [3].)
3.2.2 Вариативные шаблоны
До этого момента были рассмотрены шаблоны, принимающие строго опре- делённое число параметров, однако иногда требуется, чтобы это число могло из- мениться в зависимости от контекста выполнения программы. Для этого исполь- зуются вариативные шаблоны.
Так, вариативный шаблон (англ. variadic tempate) – это шаблон функции
(или класса), который поддерживает произвольное число параметров функции.
Набор таких параметров называется пакетом параметров (parameter pack).
Есть два вида пакетов параметров: пакет параметров шаблона (template
parameter pack), представляющий любое число параметров шаблона, и пакет па- раметров функции (function parameter pack), представляющий любое число пара- метров функции.
Для указания, что шаблону или функции представлен пакет параметров, используется оператор многоточие (...). При этом он используется в двух кон- текстах. Так, если он помещен слева от имени параметра, то он обозначает пакет
параметров,а справа – распаковку пакета параметров на отдельные имена. По- этому положение многоточия очень важно:
1 template void func1(std::vector v1);
// v1 НЕ является
пакетом параметров функции
2

30 3 template
// v2 ЯВЛЯЕТСЯ пакетом
параметров функции
void func2(std::vector... v2); template
// v3 ЯВЛЯЕТСЯ пакетом параметров
функции
void func3(const T&... v3);
4 5
6
Здесь, в записях vector... v2 и const T&... v3, много- точия обозначают пакеты параметров v2 и v3 соответственно.
Одна из сложностей использования вариативных шаблонов заключается в работе с его параметрами. Привычные механизмы индексации ([]) здесь не ра- ботают. Поэтому рассмотрим распаковку пакета с использованием рекурсии.
Так, вариативные шаблоны функций (как и аналогичные вариативные шаб- лоны классов) могут устанавливать требование о том, что должен быть передан по крайней мере один параметр. По сути, нужно подсказать компилятору, что первый параметр функции – это тип данных, а остальная часть – пакет. Их опре- деление имеет следующий вид:
template return_type func_name(const T& first, const U& ... rest);
Здесь параметр first является обязательным, а rest, обобщающий воз- можные остальные параметры, нет. Отметим, что в функции могут передаваться большие объекты, поэтому рекомендуется ее аргументы передавать по ссылке
(T&) или, что еще лучше, по константной ссылке (const T& и const U&).
Следующий программный код демонстрирует работы вариативного шаб- лона функции. Для его работы требуется сначала переопределить функцию с од- ним параметром. (Если по логике программы надо, чтобы функция также рабо- тала и без параметров, то необходимо сделать еще одну перегрузку функции под этот случай.) Результат работы приведен на рисунке 3.2.

31 1 #include using namespace std; template void func(const T& val){
// функция для обработки случая
с одним параметром
cout << val << endl;
} template
// U — это пакет
параметров шаблона
void func(const T& first, const U& ... rest){
// rest -
это пакет параметров функции
cout << first << ", "; func(rest...);
// распаковка пакета параметров за
счет рекурсивных вызовов функции с одним параметром
} int main(){ func(100); func("first", 1); func(2 , "second", 2); func("third", 3);
}
2 3
4 5
6 7
8 9
10 11 12 13 14 15 16 17 first, 1 2, second, 2 third, 3
Рис. 3.2 – Результат работы вариативной шаблонной функции
Стоит отметить, что в вариативных шаблонах используется опера- тор sizeof...(), который отличается от привычного оператора sizeof().

32 1 template void func(T ... arg) { cout << sizeof...(T) << endl;
// число параметров
пакета шаблона
cout << sizeof...(args) << endl;
// число параметров
пакета функции
}
2 3
4 5
3.2.3 Недостатки шаблонов
Шаблоны предоставляют определенные выгоды при программировании, связанные с широкой применимостью кода и легким его сопровождением. Этот механизм позволяет решать те же задачи, для которых используется полимор- физм. С другой стороны, в отличие от макросов, они позволяют обеспечить без- опасное использование типов данных.
Однако с использованием шаблонов связаны и некоторые недостатки:
 программа содержит полный код для всех порожденных представителей шаблонного класса или функций;
 не для всех типов данных предусмотренная реализация класса или функ- ции оптимальна.
Преодоление второго недостатка возможно с помощью специализации шаблонов или использования концептов (начиная с C++ 20). Отметим, что спе- циализация шаблонов подробно рассмотрена в учебном пособии по дисциплине
[3], а изучение концептов отводится на самостоятельное изучение.
3.3
Задание на работу
Разработать шаблонную функцию и продемонстрировать корректность ее работы для типов данных int, double и char. При необходимости использо- вать вариативные шаблоны. Разрабатываемая функция должна выполнять с за- данной матрицей (двумерного массива) произвольного размера совместно два

33 из нижеследующих действий (параметры, не указанные в задании, но необходи- мые для функции, выбираются на усмотрение обучающегося):
 транспонировать матрицы;
 менять местами заданные i-ю строку и j-й столбец;
 определять, существуют ли в матрице повторяющиеся строки;
 определять элемент, который встречается в массиве максимальное число раз;
 упорядочивать строки матрицы по возрастанию значения первого эле- мента в строке;
 переставлять i-ю и j-ю строки;
 вычислять максимальное значение элемента в массиве;
 менять элементы главной и побочной диагоналей местами;
 заменять все элементы, меньшие введенного значения, на это значение;
 проверять матрицу на диагональное преобладание.

34
4
ЛАБОРАТОРНАЯ РАБОТА № 2 «НАСЛЕДОВАНИЕ
И ВИРТУАЛЬНЫЕ ФУНКЦИИ»
Нам с вами надо работать конструктивнее.
Надо, так сказать, начинать уже поэтапно, планомерно ломать вот эти, устоявшиеся стереотипы. А нам их с вами досталось, так сказать, в наследство... не мне вам не говорить.
Х/ф «Какраки»
4.1
Цели и задачи работы
Цель работы – приобрести практические навыки по использованию меха- низмов наследования и виртуальных функций при разработке объектно-ориен- тированных программ.
Для достижения поставленной цели надо решить следующие главные за- дачи:
 ознакомиться с теоретическими сведениями;
 программно реализовать иерархию классов;
 выполнить тестирование программного кода;
 оформить отчет по проделанной работе.
4.2
Теоретические сведения
4.2.1 Простое наследование
Язык C++ позволяет классу наследовать члены (поля и методы) одного или нескольких других классов. При этом новый класс называют производным (или классом-потомком). Класс, члены которого наследуются, называется базовым
(родительским классом или классом-предком) для своего производного класса.
Наследование дает возможность абстрагировать некоторые общие черты поведения классов в одном базовом классе. Производные классы, наследуя это общее поведение, могут его несколько видоизменять, переопределяя некоторые методы базового класса, или дополнять, вводя новые поля и методы. В результате

35 определение производного класса может быть значительно сокращено, т. к. нужно определить только эти новые члены, отличающие его от производных классов.
Если у производного класса имеется всего один базовый класс, то говорят о простом (или одиночном) наследовании. Синтаксис объявления производного класса имеет следующий вид:
1 class <имя класса> : [<спецификатор доступа>] <имя базового класса> {
<тело класса>
};
2 3
Спецификатор доступа – это одно из ключевых слов private, protected или public. Он не является обязательным и по умолчанию прини- мает значение private для классов (public для структур). Рассмотрим пример:
1 #include using namespace std; class Base{
// базовый класс
public: intSetX(int _x=0){ return x=_x;
} intGetX( ) { return x;
} protected:
// обозначает, что
int x;
// данное поле доступно данному классу и
всем его потомкам
}; class Derived : public Base{
// производный класс
2 3
4 5
6 7
8 9
10 11 12 13 14

36 15
// требуемый код
}; int main(){ int x;
Derived ob;
// создание объекта производного класса
x = ob.GetX( );
// обращение через этот объект к
полю и методу базового класса
return 0;
}
16 17 18 19 20 21 22
Спецификатор доступа при наследовании определяет уровень доступа к членам базового класса, который получают члены производного класса. В таб- лице 4.1 описаны возможные варианты наследуемого доступа. Из таблицы сле- дует, что при наследовании, как правило, происходит понижение доступа к эле- ментам базового класса.
Таблица 4.1 – Спецификаторы доступа в рамках иерархии наследования
Доступ в базовом классе
Спецификатор наследуемого доступа
Доступ в производном классе public protected private public public protected
Нет доступа public protected private protected protected protected
Нет доступа public protected private private private private
Нет доступа
Стоит помнить, что не все члены базового класса могут наследоваться. Так, не подлежат наследованию: конструкторы, в том числе конструкторы копирова- ния; деструкторы; перегруженные операторы присваивания; дружественные функции.

37
4.2.2 Переопределение методов
В производном классе обычно добавляются новые поля и методы, отсут- ствующие в базовом классе. Кроме того, можно переопределять методы базового класса. При этом очевидно, что определения таких методов в базовом и произ- водном классах должны совпадать, как это сделано в следующем программном коде на примере геттеров.
1 #include using namespace std; class MyInt{ public:
MyInt(int _x) {x = _x;}
MyInt( ){x = 0;} intGetX( ){returnx;}
// геттер базового класса
voidSetX(int _x) {x = _x;}
// сеттер базового класса
protected: int x;
}; class IncMyInt : public MyInt{ public:
IncMyInt(int _x) : MyInt(_x) {} intGetX( ) {return ++x;}
// переопределенный геттер
базового класса
voidSetX(int _x) {x = _x+900;}
// переопределенный
сеттер базового класса
void ShowX( ) {cout << GetX() << ' ';}
}; int main( ){
IncMyInt* ptr; ptr = newIncMyInt(10);
// создание объекта в куче
2 3
4 5
6 7
8 9
10 11 12 13 14 15 16 17 18 19 20 21

38 22 ptr->ShowX( ); delete ptr;
// освобождение памяти
return 0;
}
23 24 25
Здесь создается объект класса IncMyInt при помощи конструктора
(x = 10). Далее метод ShowX() этого объекта использует для получения зна- чения поля x переопределенный вариант метода (геттера) базового класса
GetX()
. В результате в консоль будет выведено инкрементированное значение поля x (x = 11).
Для того чтобы вызывать метод базового класса, а не его переопределен- ный вариант, используется оператор разрешения области видимости (::):
«<имя_класса>::<имя_метода>».
Это дает возможность компилятору «видеть» за пределами текущей области ви- димости. Так, переопределенный метод может вызывать соответствующий ме- тод базового класса, а затем выполнять некоторую дополнительную работу (или наоборот). Например, в предыдущем примере можно было переопределить ме- тод GetX() с помощью следующего кода:
1 intIncMyInt::GetX(){
// метод производного класса,
являющийся переопределенным методом базового класса
intz ; z = MyInt::GetX{);
// вызов метода базового
класса
return ++z;
}
2 3
4 5

39
4.2.3 Конструкторы и деструкторы
Как уже упоминалось ранее, конструкторы не наследуются, поэтому про- изводный класс должен объявить свой конструктор или предоставить возмож- ность компилятору генерировать конструктор по умолчанию. Поскольку произ- водный класс должен унаследовать все члены базового класса, то при его опре- делении должна быть обеспечена инициализация унаследованных полей, причем она должна быть выполнена до инициализации полей производного класса, так как последние могут использовать значения первых. Поэтому при определении конструктора производного класса применяется следующая конструкция:
«<имя класса>([<список аргументов>]): <имя базового класса>([<список аргументов>]){
// тело конструктора про-
изводного класса
}
».
Так, часть аргументов, переданных конструктору производного класса, ис- пользуется в качестве аргументов конструктора базового класса. Затем в теле конструктора производного класса выполняется инициализация его полей.
В приведенном выше примере указанная конструкция использована для опреде- ления конструктора класса IncMyInt:
«IncMyInt (int _x): MyInt (_x) {}».
Здесь тело конструктора оставлено пустым, так как класс IncMyInt не имеет собственных полей. При этом аргументы конструктора этого производ- ного класса переданы конструктору базового класса для инициализации его поля x.
В случае если реализованный конструктор производного класса не имеет аргументов (конструктор по умолчанию), то при создании его объекта автомати- чески вызывается конструктор базового класса. После того как объект создан, конструктор базового класса становится недоступным.
В отношении деструкторов производных классов также действуют опреде- ленные правила. Так, деструктор производного класса должен вызываться раньше деструктора базового класса (иначе деструктор базового класса мог бы разрушить данные полей, которые используются и в производном классе). После

40 того как деструктор производного класса выполнит свою часть работы по уни- чтожению объекта, вызывается деструктор базового класса. Причем вся работа по организации соответствующего вызова возлагается на компилятор.
4.2.4 Виртуальные методы
Работа с объектами класса чаще всего производится через указатели. Ука- зателю на базовый класс («MyInt *p;») можно присвоить адрес объекта лю- бого производного от него класса («р = new IncMyInt;»).
Продемонстрируем сказанное на примере следующего кода, в котором ис- пользованы описанные выше базовый класс MyInt и производный класс
IncMyInt
, не имеющие виртуальных методов. Результат работы этого про- граммного кода приведен на рисунке 4.1.
1 int main( ){
MyInt*p;
// указатель на базовый класс
p = new MyInt(0);
cout<
GetX() <// метод базового класса,
здесь результат 0
p->SetX(111);
// метод базового класса
cout<
GetX() <// метод базового класса,
здесь результат 111
p = newIncMyInt(100);
// здесь указатель ссылается на
производный класс
cout<
GetX() <// метод базового класса,
здесь результат 100
p->SetX(222); cout<
GetX() <// метод базового класса,
здесь результат 222
static_cast(p)->SetX(33333333);
//
(в стиле языка С – (IncMyInt* p)->SetX(33333333);) метод
ПРОИЗВОДНОГО класса
2 3
4 5
6 7
8 9
10 11

41 12 cout<
GetX() <// метод базового класса,
здесь результат 33334233
cout<(p)->GetX() <//метод ПРОИЗВОДНОГО класса, здесь результат 33334234
return 0;
}
13 14 15
Дадим некоторые пояснения по представленному коду. Для некоторого класса вызов методов через указатель происходит в соответствии с типом, ис- пользованным при создании этого указателя, а не фактическим (присвоенным) типом, поэтому при выполнении оператора разыменования (строки 4–6, а также
8–10 и 12) вызываются методы класса MyInt, а не класса IncMyInt. Это свя- зано с тем, что ссылки на методы устанавливаются во время компоновки про- граммы. Такой процесс основан на механизме раннего связывания. Тогда, чтобы вызвать методы класса IncMyInt, следует использовать явное приведение типа указателя (строки 11 и 13).
0 111 100 222 33334233 33334234
Рис. 4.1 – Результат работы без использования виртуальных методов
Механизм раннего связывания не всегда может быть корректно применим, поскольку в разное время работы программы (по задумке программиста) указа- тель может ссылаться на разные классы в иерархии наследования. Тогда, напри- мер, во время компиляции программы конкретный класс может быть неизвестен.
В качестве примера можно привести функцию, параметром которой является указатель на базовый класс. Тогда во время выполнения программы в функцию мо- жет быть передан указатель на один из производных классов. Другой пример –

42 это связный список указателей на различные классы, с которым требуется рабо- тать единообразно. Поэтому в C++ реализован также механизм позднего связы- вания, используемый, когда задание ссылок (через инициализацию указателя) на метод происходит не на этапе компиляции, а на этапе выполнения программы в зависимости от конкретного типа объекта, вызвавшего метод. Этот механизм ре- ализован с помощью виртуальных методов (иногда называемых виртуальными функциями).
Метод, который может быть переопределен в каждом производном классе так, что конкретная его реализация будет определяться во время исполнения про- граммы, называется виртуальным. Другими словами, виртуальный метод – это метод, который гарантирует, что для объекта класса будет вызван требуемый ме- тод независимо от того, какое выражение используется для осуществления его вызова. Для объявления виртуального метода используется ключевое слово virtual
, например:
«virtual void draw(int, int, int, int);».
Основные правила использования виртуальных методов:
1. Если в базовом классе метод объявлен как виртуальный, то метод, опре- деленный в производном классе с тем же именем и набором аргументов, также автоматически становится виртуальным, а с отличающимся набором аргумен- тов – обычным.
2. Виртуальные методы наследуются, поэтому переопределять их в произ- водном классе следует только при необходимости задания отличающихся дей- ствий. При этом спецификаторы доступа при переопределении изменять запре- щено.
3. Если виртуальный метод переопределен в производном классе, то объ- екты этого класса могут получить доступ к методу базового класса с помощью операции расширения области видимости (::).
4. Если в классе есть виртуальный метод, то, как минимум, он должен быть определен как чисто виртуальный (т. е. иметь только прототип), о чем сигнали- зирует признак «= 0», используемый вместо тела метода:

43
«virtual void method(int) = 0;».
Чисто виртуальный метод должен быть переопределен в каждом производном классе, минимально как виртуальный.
5. Виртуальный метод нельзя объявлять статическим (ключевое слово static), но можно – дружественным (ключевое слово friend).
Таким образом, виртуальным называется метод, ссылка (инициализация ука- зателя) на который определяется на этапе выполнения программы, т. е. по факту вызова метода (слово virtual следует понимать как «фактический»).
Для демонстрации работы виртуальных методов модернизируем про- граммный код класса MyInt, определив его метод GetX() как виртуальный
(строка 5). Тогда результат работы (рис. 4.2) будет значительно отличаться от представленного на рисунке 4.1, так как после инициализации указателя адресом объекта производного класса IncMyInt будет вызываться его метод GetX(), что позволяет отказаться от явного приведения типа, использованного ранее.
1 class MyInt{ public:
MyInt(int _x) {x = _x;}
MyInt( ){x = 0;} virtualintGetX( ){returnx;}
// геттер базового класса
voidSetX(int _x) {x = _x;}
// сеттер базового класса
protected: int x;
};
2 3
4 5
6 7
8 9
Рис. 4.2 – Результат работы с использованием виртуальных методов

44
Кратко поясним, как работает механизм позднего связывания. Для каждого класса (не объекта!), содержащего хотя бы один виртуальный метод, компилятор создает таблицу виртуальных методов (vtbl), в которую для каждого виртуаль- ного метода записан его адрес памяти. Адреса методов содержатся в таблице в порядке их объявления в классах. Адрес любого виртуального метода имеет в таблице vtbl одно и то же смещение для каждого класса в пределах иерархии.
Каждый объект класса содержит скрытое дополнительное поле, содержащее ссылку на таблицу vtbl и называемое vptr. Оно инициализируется конструк- тором при создании объекта (для этого компилятор добавляет в начало тела кон- структора соответствующие инструкции). На этапе компиляции ссылки на вир- туальные методы заменяются на обращения к таблице vtbl через поле vptr объекта, а при выполнении программы при обращении к методу его адрес выби- рается из таблицы. В результате вызов виртуального метода, в отличие от обыч- ных методов и функций, выполняется через дополнительный этап получения его адреса из таблицы vtbl. Очевидно, что это ведет к повышению затрат памяти и снижению быстродействия программы. Поэтому, работая с небольшим клас- сом, не являющимся базовым для других классов, использовать виртуальные функции не целесообразно.
Для того чтобы гарантировать правильное освобождение памяти под дина- мически созданные объекты, рекомендуется деструкторы классов делать вирту- альными, т. к. это позволяет гарантировать, что в любой момент времени будет выбран деструктор, соответствующий фактическому типу объекта. Деструктор передает операции delete размер объекта. Если удаляемый объект является эк- земпляром производного класса, то в нем не определен виртуальный деструктор и передаваемый размер объекта может оказаться некорректным.
Далее укажем особенности использования виртуальных деструкторов. Так, при удалении объекта производного класса, на который ссылается указатель ба- зового класса, если деструктор объявлен как виртуальный, будет вызван деструк- тор соответствующего производного класса. Затем деструктор производного

45 класса вызовет деструктор базового класса, и объект будет корректно удален (вся занятая память будет освобождена), иначе будет вызван только деструктор базо- вого класса, что в конечном счете приведет к утечке памяти. Для демонстрации сказанного модернизируем показанный выше программный код, добавив де- структоры в классы. Результат работы кода приведен на рисунке 4.3.
1 #include using namespace std; class MyInt{ public:
MyInt(int _x) {x = _x;}
MyInt( ){x = 0;} virtualintGetX( ){returnx;}
// геттер базового
класса
voidSetX(int _x){x=_x;}
// сеттер базового класса
MyInt( ){cout<< "destructor of base class Myint"
<// virtual MyInt( ){cout<< "destructor of base class
Myint" <
protected: int x;
}; class IncMyInt : public MyInt{ public:
IncMyInt(int _x) : MyInt(_x) {} intGetX( ) {return ++x;}
// переопределенный геттер
базового класса
voidSetX(int _x) {x = _x+900
;}// переопределенный
сеттер базового класса
void ShowX( ) {cout<2 3
4 5
6 7
8 9
10 11 12 13 14 15 16 17 18 19

46 20 IncMyInt(){cout<< "destructor of derived class
IncMyint" <}; int main( ){
MyInt* ptr = new IncMyInt(10); delete ptr; return 0;
}
21 22 23 24 25 26
Так как объявленный в производном классе IncMyInt деструктор не яв- ляется виртуальным, то при освобождении памяти (строка 24) вызывается только деструктор базового класса MyInt. При этом очевидно, что память под объект производного класса не освобождается (утечка памяти). destructor of base class Myint
Рис. 4.3 – Результат удаления только объекта базового класса
Если объявить деструктор базового класса виртуальным (закомментиро- вать строку 9 и раскомментировать строку 10), то деструктор производного класса также станет виртуальным. Тогда при освобождении памяти сначала от- работает деструктор производного класса, а затем базового (рис. 4.4). (При этом можно не использовать явное удаление объекта, т. к. компилятор сделает это са- мостоятельно, а результат будет один и тот же.) destructor of derived class IncMyint destructor of base class Myint
Рис. 4.4 – Результат удаления объектов базового и производного классов
Основные правила использования виртуальных методов:
 виртуальные методы следует использовать только при организации наследования, т. е. при наличии базового и производных классов;
 если в базовом классе имеются виртуальные методы, то следует исполь- зовать виртуальные деструкторы;

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

1   2   3   4   5

4.2.5 Абстрактные классы
Класс, содержащий хотя бы один чисто виртуальный метод, называется аб- страктным. Абстрактные классы предназначены для выявления (определения) общих понятий, которые предполагается конкретизировать в производных клас- сах. Абстрактный класс может использоваться только в качестве базового для других классов.
Общие правила работы с абстрактными классами:
 абстрактный класс не может использоваться в качестве типов аргумен- тов функций и методов;
 абстрактный класс не может использоваться в качестве типов возвраща- емых значений функций и методов;
 явное преобразование типа объекта к абстрактному классу запрещено;
 создавать объект абстрактного класса запрещено;
 создавать указатель или ссылку на абстрактный класс разрешено;
 объявлять деструктор абстрактного класса чисто виртуальным запре- щено, т. к. после вызова деструктора производного класса должен быть вызван деструктор базового класса, поэтому последний не может быть чисто виртуаль- ным. Тогда решение данной проблемы надо возложить на компилятор, используя следующее определение этого деструктора:
«virtual