imported>Alex NB OT: унификация языковых шаблонов

2025-11-15T11:10:15Z

унификация языковых шаблонов

Новая страница

{{Полиморфизм}}
'''Виртуальный метод''' ('''виртуальная функция''') — в [[объектно-ориентированное программирование|объектно-ориентированном программировании]] метод (функция) [[класс (программирование)|класса]], который может быть переопределён в [[наследование (программирование)|классах-наследниках]] так, что конкретная реализация метода для вызова будет определяться во время исполнения. Таким образом, программисту необязательно знать точный тип [[Объект (программирование)|объекта]] для работы с ним через виртуальные методы: достаточно лишь знать, что объект принадлежит классу или наследнику класса, в котором объявлен метод. Одним из переводов слова virtual с английского языка может быть «фактический», что больше подходит по смыслу. {{Нет АИ|16|9|2020}}

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

== Способ определения ==
Одни языки программирования (например, [[C++]], [[C Sharp|C#]], [[Delphi (язык программирования)|Delphi]]) требуют явно указывать, что данный метод является виртуальным. В других языках (например, [[Java]], [[Python]]) все методы являются виртуальными по умолчанию (но только те методы, для которых это возможно; например, в Java методы с доступом ''private'' не могут быть переопределены в связи с правилами видимости).

Базовый класс может и не предоставлять реализации виртуального метода, а только декларировать его существование. Такие методы без реализации называются «чистыми виртуальными» (перевод {{lang-en | pure virtual}}) или абстрактными. Класс, содержащий хотя бы один такой метод, тоже будет [[абстрактный класс|абстрактным]]. Объект такого класса создать нельзя (в некоторых языках допускается, но вызов абстрактного метода приведёт к ошибке). Наследники абстрактного класса должны предоставить<ref>{{Cite web|lang=ru|url=https://prog-cpp.ru/cpp-virtual/|title=Виртуальные функции|author=|website=|date=|publisher=|access-date=2020-09-16|archive-date=2020-09-24|archive-url=https://web.archive.org/web/20200924195711/https://prog-cpp.ru/cpp-virtual/|url-status=live}}</ref> реализацию для всех его абстрактных методов, иначе они, в свою очередь, будут абстрактными классами. Абстрактный класс, который содержит только абстрактные методы, называется [[Интерфейс (объектно-ориентированное программирование)|интерфейсом]].

== Реализация ==
Техника вызова виртуальных методов называется ещё «динамическим (поздним) связыванием». Имеется в виду, что имя метода, использованное в программе, связывается с адресом входа конкретного метода динамически (во время исполнения программы), а не статически (во время компиляции), так как в момент компиляции, в общем случае, невозможно определить, какая из существующих реализаций метода будет вызвана.

В компилируемых языках программирования динамическое связывание выполняется обычно с использованием ''[[таблица виртуальных методов|таблицы виртуальных методов]]'', которая создаётся компилятором для каждого класса, имеющего хотя бы один виртуальный метод. В элементах таблицы находятся указатели на реализации виртуальных методов, соответствующие данному классу (если в классе-потомке добавляется новый виртуальный метод, его адрес добавляется в таблицу, если в классе-потомке создаётся новая реализация виртуального метода - соответствующее поле в таблице заполняется адресом этой реализации). Таким образом, для адреса каждого виртуального метода в дереве наследования имеется одно, фиксированное смещение в таблице виртуальных методов. Каждый объект имеет техническое поле, которое при создании объекта инициализируется [[Указатель (тип данных)|указателем]] на таблицу виртуальных методов своего класса. Для вызова виртуального метода из объекта берётся указатель на соответствующую таблицу виртуальных методов, а из неё, по известному фиксированному смещению, — указатель на реализацию метода, используемого для данного класса. При использовании [[множественное наследование|множественного наследования]] ситуация несколько усложняется за счёт того, что таблица виртуальных методов становится нелинейной.

== Пример виртуальной функции на C++ ==
[[Файл:ClassDiagram for VirtualFunction.png|400px|thumb|right|Диаграмма класса Animal]]
Пример на [[C++]], иллюстрирующий отличие виртуальных функций от невиртуальных:

Предположим, базовый класс <code>Animal</code> (животное) может иметь виртуальный метод <code>eat</code> (есть, питаться, принимать пищу). Подкласс (класс-потомок) <code>Fish</code> (рыба) переопределит метод <code>eat()</code> не так, как его переопределит подкласс <code>Wolf</code> (волк), но можно вызвать <code>eat()</code> на любом экземпляре класса, унаследованного от класса <code>Animal</code>, и получить поведение <code>eat()</code>, соответствующее данному подклассу.

Это позволяет программисту обрабатывать список объектов класса <code>Animal</code>, вызывая над каждым объектом метод <code>eat()</code>, не задумываясь о том к какому подклассу принадлежит текущий объект (то есть как питается конкретное животное).

Интересной деталью виртуальных функций в C++ является поведение [[Аргумент по умолчанию|аргументов по умолчанию]]. При вызове виртуальной функции с аргументом по умолчанию тело функции берется у реального объекта, а значения аргументов по типу [[Ссылка (C++)|ссылки]] или указателя.

<source lang="cpp" enclose="div">
class Animal {
public:
void /*невиртуальный*/ move() {
std::cout << "This animal moves in some way" << std::endl;
}
virtual void eat() {
std::cout << "Animal eat something!" << std::endl;
}
virtual ~Animal(){} // деструктор
};

class Wolf : public Animal {
public:
void move() {
std::cout << "Wolf walks" << std::endl;
}
void eat(void) { // метод eat переопределён и тоже является виртуальным
std::cout << "Wolf eats meat!" << std::endl;
}
};

int main() {
Animal* zoo[] = {new Wolf(), new Animal()};
for(Animal* a:zoo) {
a->move();
a->eat();
delete a; // Так как деструктор виртуальный, для каждого
// объекта вызовется деструктор его класса
}
return 0;
}
</source>
Вывод: <pre>This animal moves in some way
Wolf eats meat!
This animal moves in some way
Animal eat something!</pre>

== Пример аналога виртуальных функций в PHP ==
Аналогом в PHP можно считать использование позднего статического связывания.<ref>{{Cite web|url=http://php.net/manual/ru/language.oop5.late-static-bindings.php|title=PHP: Позднее статическое связывание - Manual|publisher=php.net|access-date=2016-11-05|archive-date=2016-11-08|archive-url=https://web.archive.org/web/20161108043150/http://php.net/manual/ru/language.oop5.late-static-bindings.php|url-status=live}}</ref>

<source lang="php">
class Foo {
public static function baz() {
return 'вода';
}
public function __construct() {
echo static::baz(); // позднее статическое связывание
}
}

class Bar extends Foo {
public static function baz() {
return 'огонь';
}
}

new Foo(); // выведет 'вода'
new Bar(); // выведет 'огонь'
</source>

== Пример виртуальной функции в Delphi ==
[[Полиморфизм (программирование)|полиморфизм]] языка [[Object Pascal]], использующемся в 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;'''

Как видно в классе предке объявлена виртуальная функция — <code>VirtualProcedure</code>. Чтобы воспользоваться достоинствами полиморфизма, её нужно [[Перекрытие (программирование)|перекрыть]] в потомке.

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

{ 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;'''

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

# Ancestor static procedure.
# Ancestor virtual procedure.
# Ancestor static procedure.
# Descendant override procedure.

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

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

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

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

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

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

== Пример виртуального метода на C# ==
Пример виртуального метода на C#. В примере используется ключевое слово <code>base</code>, предоставляющее доступ к методу <code>a()</code> родительского (базового) класса '''''A'''''.<source lang="c#">
class Program
{
static void Main(string[] args)
{
A myObj = new B();
Console.ReadKey();
}
}

//Базовый класс A
public class A
{
public virtual string a()
{
return "огонь";
}
}

//Произвольный класс B, наследующий класс A
class B : A
{
public override string a()
{
return "вода";
}

public B()
{
//Выводим результат возвращаемый переопределённым методом
Console.Out.WriteLine(a()); //вода
//Выводим результат возвращаемый методом родительского класса
Console.Out.WriteLine(base.a()); //огонь
}
}
</source>

== Вызов метода предка из перекрытого метода ==
Бывает необходимо вызвать метод предка в перекрытом методе.

Объявим два класса. Предка(Ancestor):
TAncestor = '''class'''
'''private'''
'''protected'''
'''public'''
{Виртуальная процедура.}
'''procedure''' VirtualProcedure'''; virtual;'''
'''end;'''

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

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

Обращение к методу предка реализуется с помощью ключевого слова «inherited»

'''procedure''' TDescendant.VirtualProcedure;
'''begin'''
'''inherited;'''
'''end;'''
Стоит помнить, что в Delphi деструктор должен быть обязательно перекрытым — «override» — и содержать вызов деструктора предка

TDescendant = '''class'''(TAncestor)
'''private'''
'''protected'''
'''public'''
'''destructor''' Destroy; '''override;'''
'''end;'''

'''destructor''' TDescendant. Destroy;
'''begin'''
'''inherited;'''
'''end;'''

В языке C++ не нужно вызывать конструктор и деструктор предка, деструктор должен быть виртуальным. Деструкторы предков вызовутся автоматически.
Чтобы вызвать метод предка, нужно явно вызвать метод:

<source lang="cpp">
class Ancestor
{
public:
virtual void function1 () { printf("Ancestor::function1"); }
};

class Descendant : public Ancestor
{
public:
virtual void function1 () {
printf("Descendant::function1");
Ancestor::function1(); // здесь будет напечатано "Ancestor::function1"
}
};
</source>

Для вызова конструктора предка нужно указать конструктор:

<source lang="cpp">
class Descendant : public Ancestor
{
public:
Descendant(): Ancestor(){}
};
</source>

== Ещё примеры ==
;Первый пример
<source lang="cpp">
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 ();

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

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

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

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

<source lang="cpp">pointer->Ancestor::function1 ();</source>

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

;Второй пример
<source lang="cpp">
class A
{
public:
virtual int function () {
return 1;
}

int get() {
return this->function();
}
};

class B: public A
{
public:
int function() {
return 2;
}
};

#include <iostream>

int main() {
B b;

std::cout << b.get() << std::endl; // 2

return 0;
}
</source>

Несмотря на то, что в классе ''B'' отсутствует метод ''get()'', его можно позаимствовать у класса ''A'', при этом результат работы этого метода вернет вычисления для ''B::function()''!

;Третий пример
<source lang="cpp">
#include <iostream>
using namespace std;

struct IBase
{
virtual void foo(int n=1) const = 0;
virtual ~IBase() = 0;
};

void IBase::foo(int n) const {
cout << n << " foo\n";
}

IBase::~IBase() {
cout << "Base destructor\n";
}

struct Derived final : IBase
{
virtual void foo(int n=2) const override final {
IBase::foo(n);
}
};

void bar(const IBase& arg)
{
arg.foo();
}

int main () {
bar(Derived());
return 0;
}
</source>

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

Вывод программы будет следующим: <tt>1 foo\nBase destructor\n</tt>. Как мы видим, значение аргумента по-умолчанию взялось от типа ссылки, а не от реального типа объекта. Также как и деструктор.

Ключевое слово final показывает, что класс или метод нельзя переопределять, а override, что виртуальный метод явно переопределён.

== См. также ==
* [[Объектно-ориентированное программирование]]
* [[Полиморфизм (информатика)]]
* [[Абстрактный класс]]

== Примечания ==
{{примечания}}

== Ссылки ==
* [https://web.archive.org/web/20060429012936/http://www.parashift.com/c++-faq-lite/virtual-functions.html C++ FAQ Lite: Виртуальные функции в C++] {{ref|en}}
* [https://logic.pdmi.ras.ru/~smal/aptu/cpp10/2010_11_26.html Лекция. Виртуальные функции и полиморфизм] / Конспекты курса по C++ 2010/11, Санкт-Петербургское отделение Математического института им. В.А.Стеклова РАН

[[Категория:Метод (информатика)]]
[[Категория:Статьи с примерами кода C++]]

Виртуальный метод - История изменений

imported>Alex NB OT: унификация языковых шаблонов