Виртуальные функции. Ещё один пример

Опубликовано 28.09.2012 | Автор: admin

    //Листинг #1
#include <iostream>

using  std::cout;

class Sport{        //Общий класс, от которого унаследуются подвиды спортивных игр
public:
    virtual void show_info(){   //Виртуальная функция "Показать информацию"
        cout << "ALL";
    }

	virtual ~Sport(){} //Виртуальный деструктор
};

class Football:public Sport{ //Наследуем вид спорта "футбол"
public:
    void show_info(){
        cout<<"Football"; //Показываем, что это футбол
    }
};

class Basketball:public Sport{ //Наследуем вид спорта "баскетбол"
public:
    void show_info(){
        cout<<"Basketball"; //Показываем, что это баскетбол
    }
};

int main(){
    Football *football = new Football;  //Выделяем память для объекта типа "футбол"
    Basketball *basketball = new Basketball; //Выделяем память для объета, типа "баскетбол"

        Sport *sport = new Sport; //Создаём общую переменную, которую будем соотносить с видом спорта
		Sport *temp = sport; //запоминаем адрес

        sport->show_info(); //Показываем информацию по этой переменной

           sport = football;    //Меняем значение общей переменной, навязываем её футбол
            sport->show_info(); //Смотрим информацию
              cout <<'\n';
            sport = basketball; //Меняем значение общей переменной, навязываем ей баскетбол
            sport->show_info(); //Смотрим информацию
              cout <<'\n';


      //  delete sport; //В данном примере спровоцирует двойное delete



    sport = temp; //Для корректного удаления sport возвращаем в исходное состояние после выделения
	delete sport;
    delete football; //Чистим память
    delete basketball;
}

//Листинг #1

#include <iostream>

using std::cout;

class Sport{ //Общий класс, от которого унаследуются подвиды спортивных игр

public:

virtual void show_info(){ //Виртуальная функция "Показать информацию"

cout << "ALL";

}

virtual ~Sport(){} //Виртуальный деструктор

};

class Football:public Sport{ //Наследуем вид спорта "футбол"

public:

void show_info(){

cout<<"Football"; //Показываем, что это футбол

}

};

class Basketball:public Sport{ //Наследуем вид спорта "баскетбол"

public:

void show_info(){

cout<<"Basketball"; //Показываем, что это баскетбол

}

};

int main(){

Football *football = new Football; //Выделяем память для объекта типа "футбол"

Basketball *basketball = new Basketball; //Выделяем память для объета, типа "баскетбол"

Sport *sport = new Sport; //Создаём общую переменную, которую будем соотносить с видом спорта

Sport *temp = sport; //запоминаем адрес

sport->show_info(); //Показываем информацию по этой переменной

sport = football; //Меняем значение общей переменной, навязываем её футбол

sport->show_info(); //Смотрим информацию

cout <<'\n';

sport = basketball; //Меняем значение общей переменной, навязываем ей баскетбол

sport->show_info(); //Смотрим информацию

cout <<'\n';

// delete sport; //В данном примере спровоцирует двойное delete

sport = temp; //Для корректного удаления sport возвращаем в исходное состояние после выделения

delete sport;

delete football; //Чистим память

delete basketball;

}

Если от класса наследуются потомки, а внутри класса есть виртуальные функции, то нужно в класс добавлять виртуальный деструктор.

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

Смысл показанной программы в том, что есть общее понятие "спорт". Что такое спорт, мы, наверное, все знаем. Я разложил спорт на две игры. Был создан общий класс Sport, от него были унаследованы две спортивные игры: футбол и баскетбол. Всего получилось три класса: Общий родитель, два его наследника. Во всех трёх классах присутствует одноимённая функция show_info(), показывающая информацию. Сейчас неважно, что там написано, важно только увидеть, что за класс срабатывает, поэтому выбраны простые обозначения для наглядности. Различаются эти функции только тем, что внутри базового класса функции предшествуют ключевое слово virtual.

Виртуальная функция — это функция, объявленная с ключевым словом virtual в базовом классе и переопределенная в одном или в нескольких производных классах.

Это вы и наблюдаете. Внутри потомков одноимённость функции переопределяет функцию родительского класса. Немного напоминает перегрузку функций, но в то же время отличается. Для нас сейчас основной интерес представляют унаследованные классы. Как можно видеть в примере, сначала созданы экземпляры от унаследованных классов.

Если объект производного класса вызывается с помощью указателя или ссылки на него, С++ определяет какую функцию вызвать, основываясь на типе объекта.

По этой причине использованы указатели. После того, как почва для работы с экземплярами объектов подготовлена, можно создать указатель на родительский класс. Так, в примере создан указатель на общий класс "Sport". Этим указателем удобно манипулировать, указывая им на любой свой производный класс (на любое своё дитя). После навязывания указателю нужного детёныша можно работать с этим указателем как будто это и не указатель основного типа, а непосредственно указатель на экземпляр того самого детёныша. Если же детёныш указателю на родительский класс не навязан, то будет вызвана функция из родительского класса.

В показанном коде детёныша мы навязать не успели на момент первого вывода информации на экран.

Вот ещё один пример:

     //Листинг #2
#include <iostream>
using namespace std;

class Sport {
public:
   virtual void NameOf() {   cout << "Sport\n";}   // Виртуальная функция
   void InvokingClass() {   cout << "Invoked by Sport\n";}  // Не виртуальная функция
};


class Football : public Sport {
public:
   void NameOf(){  cout << "Derived::Football\n";}   // Виртуальная функция
   void InvokingClass(){  cout << "Invoked by Football\n";};   // Не виртуальная функция
};


int main() {
   Football football;

   Football *pFootball = &football;
   Sport    *pSport    = &football;

   // Вызов функций
   pSport->NameOf();           // Вызывается виртуальная функция
   pSport->InvokingClass();    // вызывается не виртуальная функция.

   pFootball->NameOf();        // Вызывается виртуальная функция
   pFootball->InvokingClass(); // Вызывается не виртуальная функция
}

//Листинг #2

#include <iostream>

using namespace std;

class Sport {

public:

virtual void NameOf() { cout << "Sport\n";} // Виртуальная функция

void InvokingClass() { cout << "Invoked by Sport\n";} // Не виртуальная функция

};

class Football : public Sport {

public:

void NameOf(){ cout << "Derived::Football\n";} // Виртуальная функция

void InvokingClass(){ cout << "Invoked by Football\n";}; // Не виртуальная функция

};

int main() {

Football football;

Football *pFootball = &football;

Sport *pSport = &football;

// Вызов функций

pSport->NameOf(); // Вызывается виртуальная функция

pSport->InvokingClass(); // вызывается не виртуальная функция.

pFootball->NameOf(); // Вызывается виртуальная функция

pFootball->InvokingClass(); // Вызывается не виртуальная функция

}

В листинге #2 создаётся переменная, тип который соответствует типу дитя. Без указателя, обычная переменная. Далее уже создаётся два указателя, которые указывают на эту созданную переменную. Фактически два разных типа, но тем не менее указателем на родительский класс можно указывать на детей.

В первом случае в листинге #2 происходит два обращения к основному классу. Логично, что там, где есть virtual, там вызывается виртуальная функция, а там, где нет — там вызывается не виртуальная.

Во втором случае в листинге #2 в начале идёт обращение к дитя. К классу, унаследованному от класса Sport. Здесь функции не предшествует ключевое слово virtual, но тем не менее вызывается виртуальная функция. На это стоит обратить внимание. Связано это с тем, что virtual присутствует в породившем классе. В главном классе, от которого текущий класс происходит. Этого достаточно, чтобы во всех детях такого класса одноимённые функции стали виртуальными. В конце уже вызывается не виртуальная функция. Здесь всё просто: virtual нету ни в самом классе перед функцией, ни в породившем его классе.

Нельзя объявить глобальные статические функции виртуальными.

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

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

Механизм вызова виртуальной функции может быть подавлен путём явного указания имени функции с помощью оператора разрешения области действия (::).

   //Листинг #3         Подавление вызова виртуальной функции операцей разрешения области действия
#include <iostream>

using  std::cout;

class Sport{        //Общий класс, от которого унаследуются подвиды спортивных игр
public:
    virtual void show_info(){   //Виртуальная функция "Показать информацию"
        cout << "ALL";
    }

	virtual ~Sport(){}
};

class Football:public Sport{ //Наследуем вид спорта "футбол"
public:
    void show_info(){
        cout << "Football"; //Показываем, что это футбол
    }
};

class Basketball:public Sport{ //Наследуем вид спорта "баскетбол"
public:
    void show_info(){
        cout << "Basketball"; //Показываем, что это баскетбол
    }
};

int main(){
    Football *football = new Football;
    Basketball *basketball = new Basketball;

        Sport *sport = new Sport;
		Sport *temp = sport;
        sport->show_info();

           sport = football;
            sport->show_info();
              cout <<'\n';
            sport = basketball;
            sport->show_info();
              cout <<'\n';


            football->Sport::show_info(); //<---- От наследника через его родителя обращаемся к родительской функции

	sport = temp;
	delete sport;
    delete football; //Чистим память
    delete basketball;
}

//Листинг #3 Подавление вызова виртуальной функции операцей разрешения области действия

#include <iostream>

using std::cout;

class Sport{ //Общий класс, от которого унаследуются подвиды спортивных игр

public:

virtual void show_info(){ //Виртуальная функция "Показать информацию"

cout << "ALL";

}

virtual ~Sport(){}

};

class Football:public Sport{ //Наследуем вид спорта "футбол"

public:

void show_info(){

cout << "Football"; //Показываем, что это футбол

}

};

class Basketball:public Sport{ //Наследуем вид спорта "баскетбол"

public:

void show_info(){

cout << "Basketball"; //Показываем, что это баскетбол

}

};

int main(){

Football *football = new Football;

Basketball *basketball = new Basketball;

Sport *sport = new Sport;

Sport *temp = sport;

sport->show_info();

sport = football;

sport->show_info();

cout <<'\n';

sport = basketball;

sport->show_info();

cout <<'\n';

football->Sport::show_info(); //<---- От наследника через его родителя обращаемся к родительской функции

sport = temp;

delete sport;

delete football; //Чистим память

delete basketball;

}

Рубрика: Базовые знания, level "classer", Знакомства, Классы, Наследование

Виртуальные функции. Ещё один пример

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета