C++ для начинающих Виртуальные функции Поверхностное знакомство
Знакомство с виртуальными функциями у начинающих программистов может быть слегка проблематичным. Возникает много простых вопросов, на которые сходу трудно дать полноценные ответы.
Первый такой вопрос: "Зачем использовать виртуальные функции?"
Чтобы ответить на этот вопрос, для начала нужно понять, что существует два механизма определения поведения функций:
- Переопределение методов базового класса в производном классе.
- Использование виртуальных функций.
С переопределением функции вы скорее всего уже знакомы.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
//Листинг #1 Переопределение #include <iostream> using std::cout; class Alphabet{ public: void print(); //Функция базового класса и потомка имеет одно название }; class A:public Alphabet{ public: void print(); }; void Alphabet::print(){ //Определяем поведение функции базового класса for (char i='A'; i<='Z'; i++){ cout << i << ' '; } } void A::print(){ //Определяем поведение функции класса-потомка cout << 'A'; } int main() { Alphabet alphabet; //Создали объект от базового класса A a; //Создали объект от наследника cout << '\n'; cout << "Alphabet print:\t"; alphabet.print(); cout << "\n\n"; cout << "A print:\t"; a.print(); cout << '\n'; } |
В листинге #1 и у объекта, зарождённого от базового класса, и у объекта зарождённого от наследника имеется функция, названная print. Поскольку функция описана и для базового класса (класса Alphabet) и для потомка того класса (класса A), то при запросе конкретного объекта воспроизводится соответствующая непосредственному типу объекта. Это называется переопределением по одной простой причине. Если бы мы не описывали поведение функции в наследнике, то несмотря на видимость отсутствия функции внутри наследника, функция в наследнике всё равно имела бы место, но поведение её соответствовало бы поведению базового класса. Добавим в основной объект функцию info, а в объекте-наследнике ничего дописывать не станем.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
//Листинг #2 #include <iostream> using std::cout; class Alphabet{ public: void print(); void info(); //Добавили в родительский класс функцию }; class A:public Alphabet{ public: void print(); //Тут нет функции info }; void Alphabet::print(){ cout << '\n'; for (char i='A'; i<='Z'; i++){ cout << i << ' '; } cout << '\n'; } void A::print(){ cout << '\n'; cout << 'A'; cout << '\n'; } void Alphabet::info(){ cout << "information\n"; } int main() { Alphabet alphabet; //Создали объект от базового класса A a; //Создали объект от наследника alphabet.info(); a.info(); //Это работает, несмотря на то, что в классе А явным образом функция info не присутствует } |
Функция осного класса была унаследована потомком, и поэтому несмотря на то что никакого обозначения функции info() в классе A нет, объекты класса A умеют вызывать функцию, определённую для родительского по отношению к себе класса, и поведение той функции будет таким же как оно у родительского класса. Поскольку в листинге #1 подобное поведение функции print() перекрыто дополнительным описанием функции print() непосредственно внутри класса-потомка (класса A), то в листинге #1 происходит переопределение функции. Т. е. переопределением мы переиначиваем поведение одноимённой функции, распологающейся в родительском классе. Функция info() не переиначивается, следовательно переопределения её нет.
Переопределение в некоторой степени похоже на перегрузку функций, но это принципиально разные понятия. В противовес перегрузке в переопределении в объявлении функции совпадает всё: и название, и количество параметров, и тип каждого параметра.
Теперь, когда мы понимаем, что такое переопределение функции, нам проще понять, что дают виртуальные функции. Но для начала перепишем листинг #1 задействуя указательные переменные. Изменений будет мало:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
//Листинг #3 #include <iostream> using std::cout; class Alphabet{ public: void print(); void info(); }; class A:public Alphabet{ public: void print(); }; void Alphabet::print(){ cout << '\n'; for (char i='A'; i<='Z'; i++){ cout << i << ' '; } cout << '\n'; } void A::print(){ cout << '\n'; cout << 'A'; cout << '\n'; } void Alphabet::info(){ cout << "information\n"; } int main() { Alphabet alphabet; //Создали объект от базового класса A a; //Создали объект от наследника Alphabet *ptr; //Создали указательную переменную, тип обязательно базовый класс cout << "\nalphabet.print():\t"; ptr = &alphabet; //Направили указательную переменную на объект базового класса ptr -> print(); //Вызвали метод с помощью указателя cout << "\na.print():\t"; ptr = &a; //Перенаправили указатель адрес объекта-потомка ptr -> print(); //Попытка вызвать метод Show для объекта B } |
Как вы можете догадаться, поскольку тип у указательной переменной Alphabet, то и вызывает она функцию print() из класса Alphabet, отчего несмотря на то, что указательная переменная перенаправляется в объект-потомок, переопределение не срабатывает.
Для решения вот такой проблемы как раз и нужны виртуальные функции. Если используем обычные функции, то компилятор использует первую встреченную сверху по иерархии классов. Если иерархия классов достаточно глубокая, то, как выше было уже пояснено, откуда-то наследством вполне могла прийти обычная функция. Внесём изменение, допишем, что в классе-родителе функция виртуальная:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
//Листинг #4 //Листинг #3 #include <iostream> using std::cout; class Alphabet{ public: virtual void print(); //Внесли изменение, обозначив функцию как виртуальную void info(); }; class A:public Alphabet{ public: void print(); }; void Alphabet::print(){ cout << '\n'; for (char i='A'; i<='Z'; i++){ cout << i << ' '; } cout << '\n'; } void A::print(){ cout << '\n'; cout << 'A'; cout << '\n'; } void Alphabet::info(){ cout << "information\n"; } int main() { Alphabet alphabet; //Создали объект от базового класса A a; //Создали объект от наследника Alphabet *ptr; //Создали указательную переменную, тип обязательно базовый класс cout << "\nalphabet.print():\t"; ptr = &alphabet; //Направили указательную переменную на объект базового класса ptr -> print(); //Вызвали метод с помощью указателя cout << "\na.print():\t"; ptr = &a; //Перенаправили указатель адрес объекта-потомка ptr -> print(); //Попытка вызвать метод Show для объекта B } |
Теперь при перенаправлении указателя на потомка, компилятор выбирает функцию именно того потомка, на который указатель указывает. Сколько бы потомков у класса Alphabet не было, для каждого из них будет происходить именно тот вызов функции, который ближе всех выбранному указателем потомку.
- Если в базовом классе есть функция с ключевым словом virtual, то такой класс называется полиморфным, а все функции внутри потомков (которые предполагается переопределить) называются виртуальными.
- То, какая виртуальная функция будет вызвана, определяется во время выполнения программы.
- Виртуальная функция должна быть членом класса для которого определяется, а не "другом", но в то же время виртуальная функция может быть другом иного класса.
- Функциям деструкторов разрешается быть виртуальными, а функциям конструкторов нет.
Один комментарий на «“C++ для начинающих Виртуальные функции Поверхностное знакомство”»
Добавить комментарий
Случайная книга в электронном формате
Очень помогло, для новичков сложно что-то найти на эту тему, спасибо!