Сокрытие метода базового класса

 

В предыдущем примере при обращении к методу Speak() из объекта класса Dog программа выполнялась не так, как было указано при объявлении метода Speak() в базовом классе. Казалось бы, это то, что нам нужно. Если в классе Mammal есть некоторый метод Move(), который замещается в классе Dog, то можно сказать, что метод Move() класса Dog скрывает метод с тем же именем в базовом классе. Однако в некоторых случаях результат может оказаться неожиданным.

Усложним ситуацию. Предположим, что в классе Mammal метод Move() трижды перегружен. В одном варианте метод не требует параметров, в другом используется один целочисленный параметр (дистанция), а в третьем — два целочисленных параметра (скорость и дистанция). В классе Dog замещен метод Move() без параметров. Тем не менее попытка обратиться из объекта класса Dog к двум другим вариантам перегруженного метода класса Mammal окажется неудачной. Суть проблемы раскрывается в листинге 11.6.

Листинг 11.6. Сокрытие методов

1: //Листинг 11.6. Сокрытие методов

2:

3: #include <iostream.h>

4:

5: class Mammal

6: {

7: public:

8: void Move() const { cout << "Mammal move one step\n"; }

9: void Move(int distance) const

10: {

11: cout << "Mammal move ";

12: cout << distance <<" steps.\n";

13: }

14: protected:

15: int itsAge;

16: int itsWeight;

17: };

18:

19: class Dog: public Mammal

20: {

21: public:

22: // Возможно, последует сообщение, что функция скрыта!

23: void Move() const { cout << "Dog move 5 steps.\n"; }

24: };

25:

26: int main()

27: {

28: Mammal bigAnimal;

29: Dog fido;

30: bigAnimal.Move();

31: bigAnimal.Move(2);

32: fido.Move();

33: // fido.Move(10);

34: return 0;

35: }

 

Результат:

Mammal move one step

Mammal move 2 steps.

Dog move 5 steps.

 

Анализ: В данном примере из программы были удалены все другие методы и данные, рассмотренные нами ранее. В строках 8 и 9 в объявлении класса Mammal перегружаются методы Move(). В строке 23 происходит замещение метода Move() без параметров в классе Dog. Данный метод вызывается для объектов разных классов в строках 30 и 32, и информация, выводимая на экран, подтверждает, что замещение метода прошло правильно.

Однако строка 33 заблокирована, так как она вызовет ошибку компиляции. Хотя логично было предположить, что в классе Dog свободно можно использовать метод Move(int), поскольку замещен был только метод Move(), но в действительности в данной ситуации, чтобы использовать Move(int), его также нужно заместить в классе Dog. В случае замещения одного из перегруженных методов скрытыми оказываются все варианты этого метода в базовом классе. Если вы хотите использовать в производном классе другие варианты перегруженного метода, то их также нужно заместить в этом классе.

Часто случается ошибка, когда после попытки заместить метод в производном классе данный метод оказывается недоступным для класса из-за того, что программист забыл установить ключевое слово const, используемое при объявлении метода в базовом классе. Вспомните, что слово const является частью сигнатуры, а несоответствие сигнатур ведет к скрытию базового метода, а не к его замещению.

 

Замещение и сокрытие

В следующем разделе главы будут рассматриваться виртуальные методы. Замещение виртуальных методов ведет к полиморфизму, а сокрытие методов разрушает поли- морфизм. Скоро вы узнаете об этом больше.

 

Вызов базового метода

 

Даже если вы заместили базовый метод, то все равно можете обратиться к нему, указав базовый класс, где хранится исходное объявление метода. Для этого в обращении к методу нужно явно указать имя базового класса, за которым следуют два символа двоеточия и имя метода. Например: Mammal::Move().

Если в листинге 11.6 переписать строку 32 так, как показано ниже, то ошибка во время компиляции больше возникать не будет:

32: fido.Mammal::Move();

Такая запись, реализованная в листинге 11.7, называется явным обрашением к методу базового класса.

Листинг 11.7. Явное обращение к методу базового класса

1: //Листинг 11.7. Явное обращение к методу базового класса

2:

3: #include <iostream.h>

4:

5: class Mammal

6: {

7: public:

8: void Move() const { cout << "Mammal move one step\n"; }

9: void Move(int distance) const

10: {

11: cout << "Mammal move " << distance;

12: cout << " steps.\n";

13: }

14:

15: protected:

16: int itsAge;

17: int itsWeight;

18: };

19:

20: class Dog: public Mammal

21: {

22: public:

23: void Move()const;

24:

25: };

26:

27: void Dog::Move() const

28: {

29: cout << "In dog move...\n";

30: Mammal::Move(3);

31: }

32:

33: int main()

34: {

35: Mammal bigAnimal;

36: Dog fido;

37: bigAnimal.Move(2);

38: fido.Mammal::Move(6);

39: return 0;

40: }

 

Результат:

Mammal move 2 steps.

Mammal move 6 steps.

 

Анализ: В строке 35 создается объект bigAnimal класса Mammal, а в строке 36 — объект fido класса Dog. В строке 37 вызывается метод Move(int) из базового класса для объекта класса Dog.

В предыдущей версии программы мы столкнулись с проблемой из-за того, что в классе Dog доступен только один замещенный метод Move(), в котором не задаются параметры. Проблема была разрешена явным обращением к методу Move(int) базового класса в строке 38.

 

Рекомендуется: Повышайте функциональные возможности класса путем создания новых производных классов. Изменяйте выполнение отдельных функций в производных классах с помощью замещения методов.

 

Не рекомендуется: Не допускайте сокрытие функций базового класса из-за несоответствия сигнатур.

 

 

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

 

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

Полиморфизм в C++ развит настолько, что допускается присвоение указателям на базовый класс адресов объектов производных классов, как в следующем примере:

Mammal* pMammal = new Dog;

Данное выражение создает в области динамической памяти новый объект класса Dog и возвращает указатель на этот объект, который является указателем класса Mammal. Это вполне логично, так как собака — представитель млекопитающих.

 

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

 

Затем этот указатель можно использовать для вызова любого метода класса Mammal. Причем если метод был замещен, скажем, в классе Dog, то при обращении к методу через указатель будет вызываться именно вариант, указанный в данном производном классе. В этом суть использования виртуальных функций. Листинг 11.8 показывает, как работает виртуальная функция и что происходит с не виртуальной функцией.

Листинг 11.8. Использование виртуальных методов

1: //Листинг 11.8. Использование виртуальных методов

2:

3: #include<iostream.h>

4:

5: class Mammal

6: {

7: public:

8: Mammal():itsAge(1) { cout << "Mammal constructor...\n"; }

9: virtual ~Mammal() { cout << "Mammal destructor...\n"; }

10: void Move() const { cout << "Mammal move one step\n"; }

11: virtual void Speak() const { cout << "Mammal speak!\n"; }

12: protected:

13: int itsAge;

14:

15: };

16:

17: class Dog: public Mammal

18: {

19: public:

20: Dog() { cout << "Dog Constructor...\n"; }

21: virtual ~Dog() { cout << "Dog destructor...\n"; }

22: void WagTail() { cout << "Wagging Tail...\n"; }

23: void Speak()const { cout << "Woof!\n"; }

24: void Move()const { cout << "Dog moves 5 steps...\n"; }

25: };

26:

27: int main()

28: {

29:

30: Mammal *pDog = new Dog;

31: pDog->Move();

32: pDog->Speak();

33:

34: return 0;

35: }

 

Результат:

Mammal constructor...

Dog Constructor...

Mammal move one step

Woof!

 

Анализ: В строке 11 объявляется виртуальный метод Speak() класса Mammal. Предполагается, что данный класс должен быть базовым для других классов. Вероятно также, что данная функция может быть замещена в производных классах.

В строке 30 создается указатель класса Mammal (pDog), но ему присваивается адрес нового объекта производного класса Dog. Поскольку собака является млекопитающим, это вполне логично. Данный указатель затем используется для вызова функции Move(). Поскольку pDog известен компилятору как указатель класса Mammal, результат получается таким же, как при обычном вызове метода Move() из объекта класса Mammal.

В строке 32 через указатель pDog делается обращение к методу Speak(). В данном случае метод Speak() объявлен как виртуальный, поэтому вызывается вариант функции Speak(), замещенный в классе Dog.

Это кажется каким-то волшебством. Хотя компилятор знает, что указатель pDog принадлежит классу Mammal, тем не менее происходит вызов версии функции, объявленной в другом производном классе. Если создать массив указателей базового класса, каждый из которых указывал бы на объект своего производного класса, то, обращаясь попеременно к указателям данного массива, можно управлять выполнением всех вариантов замещенного метода. Эта идея реализована в листинге 11.9.

Листинг 11.9. Произвольное обращение к набору виртуальных функций

1: //Листинг 11.9. Произвольное обращение к набору виртуальных функций

2:

3: #include <iostream.h>

4:

5: class Mammal

6: {

7: public:

8: Mammal():itsAge(1) { }

9: virtual ~Mammal() { }

10: virtual void Speak() const { cout << "Mammal speak!\n"; }

11: protected:

12: int itsAge;

13: };

14:

15: class Dog: public Mammal

16: {

17: public:

18: void Speak()const { cout << "Woof!\n"; }

19: };

20:

21:

22: class Cat: public Mammal

23: {

24: public:

25: void Speak()const { cout << "Meow!\n"; }

26: };

27:

28:

29: class Horse: public Mammal

30: {

31: public:

32: void Speak()const { cout << "Whinny!\n"; }

33: };

34:

35: class Pig: public Mammal

36: {

37: public:

38: void Speak()const < cout << "Oink!\n"; }

39: };

40:

41: int main()

42: {

43: Mammal* theArray[5];

44: Mammal* ptr;

45: int choice, i;

46: for (i = 0; i<5; i++)

47: {

48: cout << "(1)dog (2)cat (3)horse (4)pig: ";

49: cin >> choice;

50: switch (choice)

51: {

52: case 1: ptr = new Dog;

53: break;

54: case 2; ptr = new Cat;

55: break;

56: case 3: ptr = new Horse;

57: break;

58: case 4: ptr = new Pig;

59: break;

60: default: ptr = new Mammal;

61: break;

62: }

63: theArray[i] = ptr;

64: }

65: for (i=0;i<5;i++)

66: theArray[i]->Speak();

67: return 0;

68: }

 

Результат:

(1)dog (2)cat (3)horse (4)pig: 1

(1)dog (2)cat (3)horse (4)pig: 2

(1)dog (2)cat (3)horse (4)pig: 3

(1)dog (2)cat (3)horse (4)pig; 4

(1)dog (2)cat (3)horse (4)pjg: 5

Woof!

Meow!

Whinny!

0ink!

Mammal speak!

 

Анализ: Чтобы идея использования виртуальных функций была понятнее, в данной программе этот метод раскрыт наиболее явно и четко. Сначала определяется четыре класса — Dog, Cat, Horse и Pig, которые являются производными от базового класса Mammal.

В строке 10 объявляется виртуальная функция Speak() класса Mammal. В строках 18, 25, 32 и 38 указанная функция замещается во всех соответствующих производных классах.

Пользователю предоставляется возможность выбрать объект любого производного класса, и в строках 46—64 создается и добавляется в массив указатель класса Mammal на вновь созданный объект.

 

Вопросы и ответы

Если функция-член была объявлена как виртуальная в базовом классе, следует ли повторно указывать виртуальность при объявлении этого метода в произ- водном классе?

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

 

Примечание: Во время компиляции неизвестно, объект какого класса захочет создать пользователь и какой именно вариант метода Speak() будет использоваться. Указатель ptr связывается со своим объектом только во время выполнения программы. Такое связывание указателя с объектом называется динамическим, в отличие от статического связывания, происходящего во время компиляции программы.