2.3. Виртуальные функции
К механизму виртуальных функций обращаются в тех случаях, когда в каждом производном классе требуется свой вариант некоторой компонентной функции. Классы, включающие такие функции называются полиморфными и играют особую роль в ООП.
Рассмотрим, как ведут себя при наследовании невиртуальные компонентные функции с одинаковыми именами, типами и сигнатурами параметров.
Пример 2.3.1.
class base
{
public :
void print(){cout<<“\nbase”;}
};
class dir : public base
{
public:
void print(){cout<<“\ndir”;}
};
void main()
{
base B,*bp = &B;
dir D,*dp = &D;
base *p = &D;
bp –>print(); // base
dp –>print(); // dir
p –>print(); // base
}
В последнем случае вызывается функция print базового класса, хотя указатель p настроен на объект производного класса. Дело в том, что выбор нужной функции выполняется при компиляции программы и определяется типом указателя, а не его значением. Такой режим называется ранним или статическим связыванием.
Промер 2.3.2
//птицы
class bird{
//...
public:
void fly()const{cout<<"fly"<<endl;} //может летать
};
//пингвин
class penguin:public bird{
//...
public:
void fly()const{cout<<"nofly"<<endl;} //не летает
};
int main()
{bird b; penguin p;
b.fly(); //летит
p.fly(); //не летит
return 0;
}
Выполним эту программу. Все нормально: птицы летают, но пингвин не летает.
Усложним задание. Добавим функцию alarm() – сигнал «тревога», который поступает всем птицам, в том числе и пингвину. Реакция птиц на сигнал «тревога» : убежать, улететь.
//Сигнал тревоги
void alarm(const bird& b)
{
b.fly();
}
int main()
{
bird b;
penguin p;
b.fly(); //летит
p.fly(); //не летит
alarm(b); //полетела
alarm(p); //как ни странно, и пингвин полетел ???
return 0;
}
Выполним эту программу. Видим, что все птицы, в том
числе и пингвин, летят.
Почему так происходит?
void person::show()
{
cout<<name<<“ “<<age<<endl;
}
void student::show()
{
cout<<name<<“ “<<age<<“ “<<grade<<endl;
}
void teacher::show()
{
cout<<name<<“ “<<age<<“ “<<post<<endl;
}
void main()
{
person* p;
p=new person(“Иванов”,35);
p->show(); // Что будет выведено?
p=new student(“Петров”,21,75.8);
p->show(); // Что будет выведено?
p=new teacher(“Поляков”,51,”Декан”);
p->show(); // Что будет выведено?
return 0;
}
Ожидаем следующее
void main()
{
person* p;
p=new person(“Иванов”,35);
p->show(); // Иванов 25
p=new student(“Петров”,21,75.8);
p->show(); // Петров 21 75.5
p=new teacher(“Поляков”,51,”Декан”);
p->show(); // Поляков 51 Декан
return 0;
}
А на самом деле выведено
void main()
{
person* p;
p=new person(“Иванов”,35);
p->show(); // Иванов 25
p=new student(“Петров”,21,75.8);
p->show(); // Петров 21
p=new teacher(“Поляков”,51,”Декан”);
p->show(); // Поляков 51
return 0;
}
Почему так происходит?
Это происходит потому, что вызывается функция show() базового класса, хотя указатель p настроен на объект производного класса.
void alarm(const bird& b)
{ b.fly(); }
person* p;
p->show();
Дело в том, что выбор нужной функции выполняется при компиляции программы и определяется типом указателя, а не его значением.
Как мы уже знаем, такой режим называется ранним или статическим связыванием.
Большую гибкость обеспечивает позднее (отложенное) или динамическое связывание, которое предоставляется механизмом виртуальных функций. Любая нестатическая функция базового класса может быть сделана виртуальной, для чего используется ключевое слово virtual.
Пример 2.3.3
class base
{
public:
virtual void print(){cout<<“\nbase”;}
. . .
};
// и так далее – см. предыдущий пример.
В этом случае будет напечатано
base
dir
dir
Пример 2.3.4
class person
{
protected:
string name;
int age;
public:
person(string Name=“Noname”,int Age=0): name(Name),age(Age){}
virtual void show();
};
class student:public person
{
protected:
double grade;
public:
student(string Name=“Noname”, int Age=0, double Grade=0.0):
person(Name,Age),grade(Grade){}
virtual void show();
};
Таким образом, интерпретация каждого вызова виртуальной функции через указатель на базовый класс зависит от значения этого указателя, т.е. от типа объекта, для которого выполняется вызов.
Виртуальные функции–это функции, объявленные в базовом классе и переопределенные в производных классах. Иерархия классов, которая определена открытым наследованием, создает родственный набор пользовательских типов, на все объекты которых может указывать указатель базового класса. Выбор того, какую виртуальную функцию вызвать, будет зависеть от типа объекта, на который фактически (в момент выполнения программы) направлен указатель, а не от типа указателя.
Виртуальными могут быть только нестатические функции-члены.
Виртуальность наследуется. После того, как функция определена как виртуальная, ее повторное определение в производном классе (с тем же самым прототипом) создает в этом классе новую виртуальную функцию, причем спецификатор virtual может не использоваться.
Конструкторы не могут быть виртуальными, в отличие от деструкторов. Практически каждый класс, имеющий виртуальную функцию, должен иметь виртуальный деструктор.
Если в производном классе ввести функцию с тем же именем и типом, но с другой сигнатурой параметров, то эта функция производного класса не будет виртуальной.
Виртуальная функция может быть дружественной в другом классе.
Механизм виртуального вызова может быть подавлен с помощью явного использования полного квалифицированного имени.
В Visual Studio C++ .NET для переопределения виртуальной функции вы можете использовать ключевое слово override
class person
{
public:
virtual void show();
};
class student:public person
{
public:
void show()override;
};