虚きょ函数かんすう

在ざい面めん向こう对象程ほど序じょ设计领域，C++、Object Pascal 等とう语言中有ちゅうう虚きょ函数かんすう（英語えいご：virtual function）或ある虚きょ方法ほうほう（英語えいご：virtual method）的てき概念がいねん。这种函数かんすう或ある方法ほうほう可か以被子こ类继承和わ覆くつがえ盖，通常つうじょう使用しよう动态分派ぶんぱ实现。这一概念がいねん是ぜ面めん向こう对象程ほど序じょ设计中なか（运行时）多た型かた的てき重要じゅうよう组成部分ぶぶん。简言之の，虚きょ函数かんすう可か以给出目でめ标函数すう的てき定てい义，但ただし该目标的具体ぐたい指向しこう在ざい编译期き可能かのう无法确定。

虚きょ函数かんすう在ざい设计模も式しき方面ほうめん扮ふん演えんじ重要じゅうよう角かく色しょく。例れい如，《设计模も式しき》一书中提到的23种设计模式しき中ちゅう，仅5个对象ぞう创建模も式しき就有4个用到いた了りょう虚きょ函数かんすう（抽象ちゅうしょう工こう厂、工こう厂方法ほう、生成せいせい器き、原型げんけい），只ただ有ゆう单例没ぼつ有用ゆうよう到いた。

目的もくてき

虚きょ函数かんすう概念的がいねんてき引入可か以解决这样的问题：

在ざい面めん向こう对象程ほど序じょ设计中なか，派生はせい类继承うけたまわ自じ基もと类。使用しよう指ゆび针或ある引用いんよう访问派生はせい类对象ぞう时，指ゆび针或引用いんよう本身ほんみ所しょ指向しこう的てき类型是ぜ基もと类而不ふ是ぜ派生はせい类。如果派生はせい类覆盖了基もと类中的てき方法ほうほう，通つう过上述じょうじゅつ指ゆび针或引用いんよう调用该方法ほう时，可か以有两种结果：

调用到いた基もと类的方法ほうほう：编译器き根ね据すえ指ゆび针或引用いんよう的てき类型决定，称しょう作さく「早さ绑定」；
调用到いた派生はせい类的方法ほうほう：语言的てき运行时系统根据すえ对象的てき实际类型决定，称しょう作さく「迟绑定じょう」。

虚きょ函数かんすう的てき效果こうか属ぞく于后者しゃ。如果问题中ちゅう基もと类的函数かんすう是ぜ「虚きょ」的てき，则调用よう到いた的てき都と是ぜ最さい终派生はせい类（英語えいご：most-derived class）中ちゅう的てき函数かんすう实现，与あずか指ゆび针或引用いんよう的てき类型无关。反はん之これ，如果函数かんすう非ひ「虚きょ」，调用到いた的てき函数かんすう就在编译期き根ね据すえ指ゆび针或者しゃ引用いんよう所しょ指向しこう的てき类型决定。

有ゆう了りょう虚きょ函数かんすう，程ほど序じょ甚至能のう够调用よう编译期き还不存在そんざい的てき函数かんすう。

在ざい C++ 中なか，在ざい基もと类的成なり员函数すう声明せいめい前ぜん加か上じょう关键字じ virtual 即そく可か让该函数かんすう成なり为 虚きょ函数かんすう，派生はせい类中对此函数かんすう的てき不同ふどう实现都会とかい继承这一修おさむ饰符，允まこと许后续派生はせい类覆盖，达到迟绑定じょう的てき效果こうか。即そく便びん是ぜ基もと类中的てき成なり员函数すう调用虚きょ函数かんすう，也会调用到いた派生はせい类中的てき版本はんぽん。

程ほど式しき範はん例れい

例れい如，一いち個こ基礎きそ類別るいべつ Animal 有ゆう一いち個こ虛きょ擬なずらえ函はこ式しき eat。子こ類別るいべつ Fish 要よう實じつ做一いち個こ函はこ式しき eat()，這個子こ類別るいべつ Fish 與あずか子こ類別るいべつ Wolf 是ぜ完全かんぜん不同ふどう的てき，但ただし是ぜ你可以引用いんよう類別るいべつ Animal 底そこ下か的てき函はこ式しき eat() 定義ていぎ，而使用しよう子こ類別るいべつ Fish 底そこ下か函はこ式しき eat() 的てき處理しょり程ほど序じょ。

C++

以下いか程ほど式しき碼是 C++ 的てき程ほど式しき範はん例れい。要注意ようちゅうい的てき是ぜ，這個範はん例れい沒ぼつ有ゆう异常處理しょり的てき程ほど式しき碼。尤ゆう其是 new 或ある是ぜ vector::push_back 丟出一いち個こ异常時じ，程ほど式しき在ざい執行しっこう時じ有可ゆか能會のうかい出現しゅつげん崩くずし溃或是ぜ錯誤さくご的てき現象げんしょう。

類別るいべつ Animal 的てき區く塊かたまり圖ず

# include <iostream>
# include <vector>

using namespace std;
class Animal
{
public:
    virtual void eat() const { cout << "I eat like a generic Animal." << endl; }
    virtual ~Animal() {}
};
 
class Wolf : public Animal
{
public:
    void eat() const { cout << "I eat like a wolf!" << endl; }
};
 
class Fish : public Animal
{
public:
    void eat() const { cout << "I eat like a fish!" << endl; }
};
 
class GoldFish : public Fish
{
public:
    void eat() const { cout << "I eat like a goldfish!" << endl; }
};
 
 
class OtherAnimal : public Animal
{
};
 
int main()
{
    std::vector<Animal*> animals;
    animals.push_back( new Animal() );
    animals.push_back( new Wolf() );
    animals.push_back( new Fish() );
    animals.push_back( new GoldFish() );
    animals.push_back( new OtherAnimal() );
 
    for( std::vector<Animal*>::const_iterator it = animals.begin();
       it != animals.end(); ++it) 
    {
        (*it)->eat();
        delete *it;
    }
 
   return 0;
}

以下いか是ぜ虛きょ擬なずらえ函はこ式しき Animal::eat() 的てき輸出ゆしゅつ：

I eat like a generic Animal.
I eat like a wolf!
I eat like a fish!
I eat like a goldfish!
I eat like a generic Animal.

當とう Animal::eat() 不ふ是ぜ被ひ宣告せんこく為ため虛きょ擬なずらえ函はこ式しき時じ，輸出ゆしゅつ如下所しょ示しめせ：

I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.
I eat like a generic Animal.

Java

在ざいJava语言中ちゅう, 所有しょゆう的てき方法ほうほう默だま认都是ぜ"虚きょ函数かんすう". 只ただ有ゆう以关键字 final 标记的てき方法ほうほう才ざい是非ぜひ虚きょ函数かんすう. 以下いか是ぜ Java 中ちゅう虚きょ方法ほうほう的てき一いち个例子こ:

import java.util.*;

public class Animal {
   public void eat() { System.out.println("I eat like a generic Animal."); }
 
   public static void main(String[] args) {
      List<Animal> animals = new LinkedList<Animal>();

      animals.add(new Animal());
      animals.add(new Wolf());
      animals.add(new Fish());
      animals.add(new OtherAnimal());

      for (Animal currentAnimal : animals) {
         currentAnimal.eat();
      }
   }
}
 
public class Wolf extends Animal {
   public void eat() { System.out.println("I eat like a wolf!"); }
}
 
public class Fish extends Animal {
   public void eat() { System.out.println("I eat like a fish!"); }
}
 
public class OtherAnimal extends Animal {}

输出:

I eat like a generic Animal.
I eat like a wolf!
I eat like a fish!
I eat like a generic Animal.

C#

在ざい C# 语言中ちゅう, 对基类中的てき任にん何なん虚きょ方法ほうほう必须用よう virtual 修おさむ饰, 而衍生せい类中由よし基もと类继承而来的てき重じゅう载方法ほう必须用よう override 修おさむ饰. 以下いか是ぜ C# 的てき一いち个程序じょ实例:

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
  public class Animal
  {
    public virtual void Eat()
    {
      Console.WriteLine("I eat like a generic Animal.");
    }
  }

  public class Wolf : Animal
  {
    public override void Eat()
    {
      Console.WriteLine("I eat like a wolf!");
    }
  }

  public class Fish : Animal
  {
    public override void Eat()
    {
      Console.WriteLine("I eat like a fish!");
    }
  }

  public class GoldFish : Fish
  {
    public override void Eat()
    {
      Console.WriteLine("I eat like a goldfish!");
    }
  }

  public class OtherAnimal : Animal
  {
    // Eat() method is not overridden, so the base class method will be used.
  }

  public class Program
  {
    public static void Main(string[] args)
    {
      IList<Animal> animals = new List<Animal>();
      
      animals.Add(new Animal());
      animals.Add(new Wolf());
      animals.Add(new Fish());
      animals.Add(new GoldFish());
      animals.Add(new OtherAnimal());

      foreach (Animal currentAnimal in animals)
      {
        currentAnimal.Eat();
      }
    }
  }
}

输出:

I eat like a generic Animal.
I eat like a wolf!
I eat like a fish!
I eat like a goldfish!
I eat like a generic Animal.

抽象ちゅうしょう类和纯虚函数かんすう

纯虚函数かんすう或ある纯虚方法ほうほう是ぜ一个需要被非抽象的派生类覆盖（override）的てき虚きょ函数かんすう. 包含ほうがん纯虚方法ほうほう的てき类被称しょう作さく抽象ちゅうしょう类; 抽象ちゅうしょう类不能ふのう被ひ直接ちょくせつ实例化か。一个抽象基类的一个子こ类只ただ有ゆう在ざい所有しょゆう的てき纯虚函数かんすう在ざい该类(或ある其父类)内ない给出实现时, 才能さいのう直接ちょくせつ实例化か. 纯虚方法ほうほう通常つうじょう只ただ有ゆう声明せいめい(签名)而没有定ありさだ义(实现)，但ただし有ゆう特例とくれい情じょう形がた要求ようきゅう纯虚函数かんすう必须给出函数かんすう体たい定てい义.

作さく为一个例子こ, 抽象ちゅうしょう基もと类"MathSymbol"可能かのう提供ていきょう一いち个纯虚きょ函数かんすう doOperation(), 和かず衍生类 "Plus" 和わ "Minus" 提供ていきょうdoOperation() 的てき具体ぐたい实现. 由よし于 "MathSymbol" 是ぜ一いち个抽象ちゅうしょう概念がいねん, 为其每ごと个子类定义了同一どういつ的てき动作, 在ざい "MathSymbol" 类中执行 doOperation() 没ぼつ有ゆう任にん何なん意い义. 类似的てき, 一いち个给定じょう的てき "MathSymbol" 子こ类如果はて没ぼつ有ゆう doOperation() 的てき具体ぐたい实现是ぜ不完全ふかんぜん的てき.

虽然纯虚方法ほうほう通常つうじょう在ざい定てい义它的てき类中没ぼつ有ゆう实现, 在ざい C++ 语言中ちゅう, 允まこと许纯虚きょ函数かんすう在ざい定てい义它的てき类中包含ほうがん其实现, 这为衍生类提供ていきょう了りょう备用或ある默だま认的行ぎょう为. C++的てき虚きょ基もと类的虚きょ析构函数かんすう必须提供ていきょう函数かんすう体たい定てい义，否いや则链接时（linking）在ざい析构该抽象ちゅうしょう类的派生はせい实例对象的てき语句处会报错。^[1]

C++

在ざいC++语言中ちゅう, 纯虚函数かんすう用よう一种特别的语法[=0]定てい义（但ただし VS 也支持しじ abstract 关键字じ：virtual ReturnType Function()abstract;）, 见以下か示しめせ例れい.

class Abstract {
public:
   virtual void pure_virtual() = 0;
};

纯虚函数かんすう的てき定てい义仅提供ていきょう方法ほうほう的てき原型げんけい. 虽然在ざい抽象ちゅうしょう类中通常つうじょう不ふ提供ていきょう纯虚函数かんすう的てき实现, 但ただし是ぜ抽象ちゅうしょう类中可か以包含其实现, 而且可か以不在ざい声明せいめい的てき同どう时给出で定てい义^[2]. 每まい个非抽象ちゅうしょう子こ类仍然しか需要じゅよう重じゅう载该方法ほうほう, 抽象ちゅうしょう类中实现的てき调用可か以采用よう以下いか这种形式けいしき:

 void Abstract::pure_virtual() {
   // do something
 }
 
 class Child : public Abstract {
   virtual void pure_virtual(); // no longer abstract, this class may be
                                // instantiated.
 };
 
 void Child::pure_virtual() {
   Abstract::pure_virtual(); // the implementation in the abstract class 
                             // is executed
 }

构造与あずか析构时的行ぎょう为

在ざい对象的てき构造函数かんすう和わ析构函数かんすう中なか涉わたる及虚函数かんすう时，不同ふどう的てき语言有ゆう不同ふどう的てき规定。在ざい以 C++ 为代表だいひょう的てき一いち些语言ごと中ちゅう，虚きょ函数かんすう调度机つくえ制せい在ざい对象的てき构造和わ析构时有不同ふどう的てき语义，一般建议尽可能避免在 C++ 的てき构造函数かんすう中ちゅう调用虚きょ函数かんすう^[3]。而在 C#、Java 等とう另一些语言ごと中ちゅう，构造时可以调用よう派生はせい类中的てき实现，抽象ちゅうしょう工こう厂模式しき等ひとし设计模も式しき也鼓励在支持しじ这一特性的语言中使用这种用法。

参考さんこう文献ぶんけん

^ MSDN "Using dllimport and dllexport in C++ Classes" （页面存そん档备份，存そん于互联网档案あん馆）: However, because a destructor for an abstract class is always called by the destructor for the base class, pure virtual destructors must always provide a definition. Note that these rules are the same for nonexportable classes.
^ Standard C++ 98 - 10.4/2
^ Meyers, Scott. Never Call Virtual Functions during Construction or Destruction. June 6, 2005 [2018-06-22]. （原始げんし内容ないよう存そん档于2021-01-26）.

[1] MSDN "Using dllimport and dllexport in C++ Classes" （页面存そん档备份，存そん于互联网档案あん馆）: However, because a destructor for an abstract class is always called by the destructor for the base class, pure virtual destructors must always provide a definition. Note that these rules are the same for nonexportable classes.

[2] Standard C++ 98 - 10.4/2

[3] Meyers, Scott. Never Call Virtual Functions during Construction or Destruction. June 6, 2005 [2018-06-22]. （原始げんし内容ないよう存そん档于2021-01-26）.

[1]

[2]

[3]