Microsoft visual C++ и MFC

Наследование

Пожалуй, самая важная возможность, предоставляемая программисту средствами языка Си++, заключается в механизме наследования XE "наследование" . Вы можете наследовать от определенных ранее классов новые производные классы. Класс, от которого происходит наследование, называется базовым. Новый класс называется производным.

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

Производный класс сам может служить базовым классом XE "базовый класс" . Вы можете наследовать от него другие классы. Полученный в результате такого наследования класс будет включать в себя элементы всех его базовых классов.

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

На рисунке 1.1 мы привели пример структуры наследования классов. От единственного базового класса BaseClass наследуются три класса DerivedClassOne, DerivedClassSecond и DerivedClassThird. Первые два из них сами выступают в качестве базовых классов.

Рис. 1.1. Наследование

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

Можно выделить две основных формы наследования. Когда производный класс наследуется от единственного базового класса - единичное наследование. Наследование, при котором производный класс наследуется сразу от нескольких базовых классов - это множественное наследование.

Единичное наследование

В случае единичного наследования XE "наследование:единичное" порожденный класс наследуется только от одного базового класса. Рисунок 1.1 отражает единичное наследование классов. Единичное наследование является наиболее распространенным методом наследования. Библиотека классов MFC использует только единичное наследование.

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


class [<tag>[:<base>]]
{
	<member-list>
} [<declarators>];

Перед названием базового класса может быть указан спецификатор доступа public, private или protect. Назначение этих спецификаторов мы рассмотрим в разделе “Разграничение доступа к элементам базового класса”. Сейчас же мы скажем только, что если вы не укажите спецификатор доступа, то по умолчанию будет подразумеваться спецификатор private.

Ниже мы определили базовый класс Base, содержащий несколько элементов, а затем наследовали от него два новых класса DerivedFirst и DerivedSecond. В каждом из порожденных классов мы определили различные дополнительные методы и элементы данных.


// Класс Base
class	Base 
{
	// Элементы класса Base
};

// Класс DerivedFirst, наследованный от базового класса Base
class	DerivedFirst : Base 
{
	// Элементы класса DerivedFirst
};

// Класс DerivedSecond, наследованный от базового класса Base
class	DerivedSecond : Base 
{
	// Элементы класса DerivedSecond
};

Классы DerivedFirst и DerivedSecond сами могут выступать в качестве базовых классов.

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

В качестве примера приведем базовый класс Base и производный от него класс Derived. В обоих классах определен элемент данных iNumber. Чтобы получить доступ из порожденного класса к элементу iNumber базового класса указывается его полное имя Base::iNumber.


// Класс Base
class	Base 
{
public:
	int	iNumber;
	// Другие элементы класса 
};

// Класс Derived, наследованный от базового класса Base
class	Derived : Base 
{
public:
	// Это объявление скрывает элемент iNumber базового класса
	int	iNumber;
	int	GetNumber(void) {return iNumber + Base::iNumber; }
};

Указатель на объект базового класса можно присвоить указатель на объект класса порожденного от него. Эта возможность будет широко использоваться в библиотеке классов MFC.

Множественное наследование

Множественное наследование XE "наследование:множественное" выполняется подобно единичному наследованию. В отличие от единичного наследования у порожденного класса может быть несколько базовых классов. На рисунке 1.2 представлен пример множественного наследования классов. Класс DerivedClaass имеет два базовых класса BaseClassOne и BaseClassSecond. Класс DerivedClaass и еще один класс BaseClass используются при множественном наследовании класса DerivedClaassSecond.

Рис. 1.2. Множественное наследование

Вместо имени единственного базового класса указывается список <base-list> имен базовых классов, разделенный запятыми. Непосредственно перед названиями базовых классов могут быть указаны спецификаторы доступа public, private и protect. Их назначение мы рассмотрим в разделе “Разграничение доступа к элементам базового класса”.


class [<tag>[:[<base-list>]]
{
	
} [];

Порядок, в котором вы перечислите базовые классы влияет только на последовательность в которой вызываются конструкторы и деструкторы базовых классов. Конструкторы базовых классов вызываются в том порядке, в котором они перечислены (слева на право). Деструкторы базовых классов вызываются в обратном порядке.

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

В следующем примере определены два базовых класса BaseFirst и BaseSecond. От них наследован один новый класс Derived. Результирующий класс Derived объединяет элементы обоих базовых классов и добавляет к ним собственные элементы.


// Класс BaseFirst
class	BaseFirst 
{
	// Элементы класса BaseFirst
};

// Класс BaseSecond
class	BaseSecond 
{
	// Элементы класса BaseSecond
};
// Класс Derived, наследованный от базового класса Base
class	Derived : BaseFirst, BaseSecond
{
	// Элементы класса Derived
};

Так как библиотека классов MFC XE "библиотека MFC" не использует множественное наследование, мы не станем останавливаться на нем более подробно. При необходимости вы можете получить дополнительную информацию из справочников или учебников по языку Си++ (см. список литературы).

Разграничение доступа к элементам базового класса

Мы уже рассказывали, что можно управлять доступом к элементам класса, указывая спецификаторы доступа для элементов класса. Элементы класса, объявленные с спецификаторами protected XE "protected" и private XE "private" доступны только из методов самого класса. Элементы с спецификаторами public XE "public" доступны не только из методов класса, но и извне.

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

По следующей таблице вы можете определить как будут доступны элементы базового класса в зависимости от спецификатора доступа базового класса и спецификаторов доступа элементов базового класса.

	Спецификатор доступа базового класса
Спецификатор доступа элемента базового класса	public	protected	private
public	Доступны как public	Доступны как protected	Доступны как private
protected	Доступны как protected	Доступны как protected	Доступны как private
private	Недоступны	Недоступны	Недоступны

Переопределение методов базового класса

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

Виртуальные методы XE "виртуальные методы"

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

В Си++ вы можете указать, что некоторые методы базового класса, которые будут переопределены в порожденных классах, являются виртуальными. Для этого достаточно указать перед описанием метода ключевое слово virtual. Статический метод не может быть виртуальным. Методы, объявленные в базовом классе виртуальными считаются виртуальными и в порожденных классах.

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

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

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

Следующая программа демонстрирует разницу между виртуальными и невиртуальными методами класса. В базовом классе Figure определены два метода PrintName и PrintDimention, причем метод PrintName определен как виртуальный. От класса Figure наследуется класс Rectangle, в котором методы PrintName и PrintDimention переопределяются.

В программе создается объект класса Rectangle, а затем несколько раз вызываются методы PrintName и PrintDimention. В зависимости от того, как вызывается метод, будет работать метод, определенный в классе Figure или Rectangle.


#include 
// Базовый класс Figure
class	Figure 
{
public:
	// Виртуальный метод
	virtual void PrintName(void) 
		{cout << Figure PrintName << '\n'};
	// Невиртуальный метод
	void	PrintDimention(void) 
		{cout << Figure PrintDimention << '\n'};
};

// Порожденный класс Rectangle
class	Rectangle : public Figure
{
	// Переопределяем виртуальный метод базового класса
	virtual void PrintName(void)
		{cout << Rectangle PrintName << '\n'};

	// Переопределяем невиртуальный метод базового класса
	void	PrintDimention(void);
		{cout << Rectangle PrintDimention << '\n'};
};

// Главная функция
void main(void)
{
	// Определяем объект порожденного класса
	Rectangle	rectObject;

	// Определяем указатель на объект порожденного класса
	// и инициализируем его 
	*Rectangle	ptrRectObject = &rectObject;

	// Определяем указатель на объект базового класса Figure
	// и записываем в него адрес объекта порожденного класса.
	*Figure		ptrFigObject = &rectObject;

	// Вызываем методы класса Rectangle, используя имя объекта
	rectObject.PrintName;
	rectObject.PrintDimention;
	cout << '\n';

	// Вызываем методы класса базового класса Figure
	rectObject.Figure::PrintName;
	rectObject.Figure::PrintDimention;
	cout << '\n';

	// Вызываем методы класса Rectangle, используя указатель на 
	// объекты класса Rectangle
	ptrRectObject->PrintName;
	ptrRectObject->PrintDimention;
	cout << '\n';

	// Вызываем методы класса Rectangle, используя указатель на 
	// объекты класса Figure
	ptrFigObject->PrintName;
	ptrFigObject->PrintDimention;
}

Если вы запустите приведенную выше программу, она выведет на экран следующую информацию:


Rectangle PrintName 
Rectangle PrintDimention

Figure PrintName 
Figure PrintDimention

Rectangle PrintName 
Rectangle PrintDimention

Figure PrintName 
Figure PrintDimention

Абстрактные классы

Виртуальные методы могут быть объявлены как чисто виртуальные. Для этого после описания метода указывается специальный спецификатор (= 0). Он означает, что описанные методы не определены.

Класс в котором определен хотя бы один чисто виртуальный метод называется абстрактным XE "абстрактные классы" . Нельзя создавать объекты абстрактного класса. Абстрактный класс может использоваться только в качестве базового класса для построения других классов.

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

В качестве примера абстрактного класса мы приведем класс Abstract, в котором описан чисто виртуальный метод PureFunc. Обратите внимание, что этот метод не определен в классе Abstract. Определение метода содержится только в порожденном классе Fact.


// Абстрактный класс Abstract
class	Abstract 
{
public:
	// Чисто виртуальный метод, не имеет определения
	virtual int	PureFunc(void) = 0;
	void	SetValue(int i) {iValue = i;}
	int	iValue;
};

// Класс Fact
class	Fact : public Abstract
{
	int	PureFunc(void) {return iValue * iValue;}
};