Виртуальная функция

В объектно-ориентированном программировании виртуальной функцией называется функция-член класса, которая может быть переопределена в классах-наследниках так, что конкретная реализация функции для вызова будет определяться во время исполнения. Таким образом, программисту необязательно знать точный тип объекта для работы с ним через виртуальные функции: достаточно лишь знать, что объект принадлежит классу или наследнику класса, в котором функция объявлена.

Виртуальные функции — один из важнейших приёмов реализации полиморфизма. Они позволяют создавать общий код, который может работать как с объектами базового класса, так и с объектами любого его класса-наследника. При этом, базовый класс определяет способ работы с объектами и любые его наследники могут предоставлять конкретную реализацию этого способа. В некоторых языках программирования, например в Java, все функции-члены класса, кроме статических, являются виртуальными.

Базовый класс может и не предоставлять реализации виртуальной функции, а только декларировать её существование. Такии функции без реализации называются «чисто виртуальными» (калька с англ. pure virtual) или абстрактными. Класс, содержащий хотя бы одну такую функцию, также называют абстрактным. Объект такого класса создать нельзя. Наследники абстрактного класса должны предоставить реализацию для всех его чисто виртуальных функций, иначе они, в свою очередь, будут абстрактными классами.

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

Содержание

Пример

Пример на C++, иллюстрирующий отличие виртуальных функций от невиртуальных:

    class Ancestor
    {
    public:
      virtual void  function1 () { cout << "Ancestor::function1()" << endl; }
      void          function2 () { cout << "Ancestor::function2()" << endl; }
    };
    class Descendant : public Ancestor
    {
    public:
      virtual void  function1 () { cout << "Descendant::function1()" << endl; }
      void          function2 () { cout << "Descendant::function2()" << endl; }
    };
    Descendant *pointer      = new Descendant ();
    Ancestor   *pointer_copy = pointer;
    pointer->function1 ();
    pointer->function2 ();
    pointer_copy->function1 ();
    pointer_copy->function2 ();

В этом примере класс Ancestor определяет две функции, одну из них виртуальную, другую — нет. Класс Descendant переопределяет обе функции. Однако, казалось бы одинаковое обращение к функциям, даёт разные результаты. На выводе программа даст следующее:

    Descendant::function1()
    Descendant::function2()
    Descendant::function1()
    Ancestor::function2()

То есть, в случае виртуальной функции, для определения реализации функции используется информация о типе объекта и вызывается «правильная» реализация, независимо от типа указателя. При вызове невиртуальной функции, компилятор руководствуется типом указателя или ссылки, поэтому вызываются две разные реализации function2(), несмотря на то, что используется один и тот же объект.

Следует отметить, что в С++ можно, при необходимости, указать конкретную реализацию виртуальной функции, фактически вызывая её невиртуально:

    pointer->Ancestor::function1 ();

для нашего примера выведет Ancestor::function1(), игнорируя тип объекта.

Пример виртуальной функции в Delphi

Язык Delphi тоже поддерживает полиморфизм. Рассмотрим пример:

Объявим два класса. Предка(Ancestor):

 TAncestor = class
 private
 protected
 public
   {Виртуальная процедура.} 
   procedure VirtualProcedure; virtual; 
   procedure StaticProcedure;
 end;

и его потомка (Descendant):

 TDescendant = class(TAncestor)
 private
 protected
 public
    {Перекрытие виртуальной процедуры.}
   procedure VirtualProcedure; override;
   procedure StaticProcedure;
 end;

Как видно в классе предке объявлена виртуальная функция - VirtualProcdure. Чтобы воспользоваться достоинствами полиморфизма её нужно перекрыть в потомке.

Реализация выглядит следующим образом:

 { TAncestor }
   
 procedure TAncestor.StaticProcedure;
 begin
   ShowMessage('Ancestor static procedure.');
 end;
   
 procedure TAncestor.VirtualProcedure;
 begin
   ShowMessage('Ancestor virtual procedure.');
 end;
 { TDescendant }
   
 procedure TDescendant.StaticProcedure;
 begin
   ShowMessage('Descendant static procedure.');
 end;
   
 procedure TDescendant.VirtualProcedure;
 begin
   ShowMessage('Descendant override procedure.');
 end;

Посмотрим как это работает:

 procedure TForm2.BitBtn1Click(Sender: TObject);
 var
   MyObject1: TAncestor;
   MyObject2: TAncestor;
 begin
   MyObject1 := TAncestor.Create;
   MyObject2 := TDescendant.Create;
   try
     MyObject1.StaticProcedure;
     MyObject1.VirtualProcedure;
     MyObject2.StaticProcedure;
     MyObject2.VirtualProcedure;
   finally
     MyObject1.Free;
     MyObject2.Free;
   end;
 end;

Заметьте, что в разделе var мы объявили два объекта MyObject1 и MyObject2 типа TAncestor. А при создании MyObject1 создали как TAncestor, а MyObject2 как TDescendant. Вот что мы увидим при нажатии на кнопку BitBtn1:

  1. Ancestor static procedure.
  2. Ancestor virtual procedure.
  3. Ancestor static procedure.
  4. Descendant override procedure.

Для MyObject1 все понятно, просто вызвались указанные процедуры. А вот для MyObject2 это не так.

Вызов MyObject2.StaticProcedure; привел к появлению «Ancestor static procedure.». Ведь мы объявили MyObject2: TAncestor, поэтому и была вызвана процедура StaticProcedure; класса TAncestor.

А вот вызов MyObject2.VirtualProcedure; привел к вызову VirtualProcdure; реализованной в потомке(TDescendant). Это произошло потому, что MyObject2 был создан не как TAncestor, а как TDescendant: MyObject2 := TDescendant.Create; . И виртуальный метод VirtualProcdure был перекрыт.

В Delphi полиморфизм реализован с помощью так называемой виртуальной таблицы методов (или VMT).

Достаточно часто виртуальные методы забывают перекрыть с помощью ключевого слова override. Это приводит к закрытию метода. В этом случае замещения методов в VMT не произойдет и требуемая функциональность не будет получена.

Эта ошибка отслеживается компилятором, который выдаёт соответствующее предупреждение.

См. также

Ссылки

 
Начальная страница  » 
А Б В Г Д Е Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ы Э Ю Я
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9 Home