我正在学习C++，我刚刚开始学习虚拟函数。
从我（在书中和网上）读到的内容来看，虚拟函数是基类中的函数，可以在派生类中重写。
但在本书的早些时候，当我学习基本继承时，我能够在派生类中重写基函数，而不使用虚函数。
那么我在这里错过了什么？我知道虚拟函数还有很多，它似乎很重要，所以我想清楚它到底是什么。我只是在网上找不到一个直截了当的答案。
当前回答
您需要虚拟方法来实现安全的下变频、简单和简洁。
这就是虚拟方法所做的：它们安全地向下转换，使用明显简单而简洁的代码，避免了在更复杂和冗长的代码中进行不安全的手动转换。
Non-virtual method ⇒ static binding ========================================
以下代码故意“不正确”。它没有将value方法声明为virtual，因此会产生意外的“错误”结果，即0:
#include <iostream>
using namespace std;
class Expression
{
public:
auto value() const
-> double
{ return 0.0; } // This should never be invoked, really.
};
class Number
: public Expression
{
private:
double number_;
public:
auto value() const
-> double
{ return number_; } // This is OK.
Number( double const number )
: Expression()
, number_( number )
{}
};
class Sum
: public Expression
{
private:
Expression const* a_;
Expression const* b_;
public:
auto value() const
-> double
{ return a_->value() + b_->value(); } // Uhm, bad! Very bad!
Sum( Expression const* const a, Expression const* const b )
: Expression()
, a_( a )
, b_( b )
{}
};
auto main() -> int
{
Number const a( 3.14 );
Number const b( 2.72 );
Number const c( 1.0 );
Sum const sum_ab( &a, &b );
Sum const sum( &sum_ab, &c );
cout << sum.value() << endl;
}
在注释为“坏”的行中，调用了Expression:：value方法，因为静态已知类型（编译时已知的类型）是Expression，而value方法不是虚拟的。
Virtual method ⇒ dynamic binding. ======================================
在静态已知类型表达式中将值声明为virtual可确保每次调用都会检查这是什么实际类型的对象，并调用该动态类型的值的相关实现：
#include <iostream>
using namespace std;
class Expression
{
public:
virtual
auto value() const -> double
= 0;
};
class Number
: public Expression
{
private:
double number_;
public:
auto value() const -> double
override
{ return number_; }
Number( double const number )
: Expression()
, number_( number )
{}
};
class Sum
: public Expression
{
private:
Expression const* a_;
Expression const* b_;
public:
auto value() const -> double
override
{ return a_->value() + b_->value(); } // Dynamic binding, OK!
Sum( Expression const* const a, Expression const* const b )
: Expression()
, a_( a )
, b_( b )
{}
};
auto main() -> int
{
Number const a( 3.14 );
Number const b( 2.72 );
Number const c( 1.0 );
Sum const sum_ab( &a, &b );
Sum const sum( &sum_ab, &c );
cout << sum.value() << endl;
}
这里的输出应该是6.86，因为虚拟方法是虚拟调用的。这也称为调用的动态绑定。执行一点检查，找到对象的实际动态类型，并调用该动态类型的相关方法实现。
相关的实现是最特定（最派生）类中的实现。
注意，这里的派生类中的方法实现没有标记为virtual，而是标记为override。它们可以被标记为虚拟，但它们是自动虚拟的。override关键字确保如果某个基类中没有这样的虚拟方法，那么您将得到一个错误（这是可取的）。
The ugliness of doing this without virtual methods ==================================================
如果没有虚拟绑定，则必须实现一些自己动手版本的动态绑定。这通常涉及不安全的手动降级、复杂性和冗长。
对于单个函数的情况，如这里所示，将函数指针存储在对象中并通过该函数指针进行调用就足够了，但即使如此，它也会涉及一些不安全的下变频、复杂性和冗长性，即：
#include <iostream>
using namespace std;
class Expression
{
protected:
typedef auto Value_func( Expression const* ) -> double;
Value_func* value_func_;
public:
auto value() const
-> double
{ return value_func_( this ); }
Expression(): value_func_( nullptr ) {} // Like a pure virtual.
};
class Number
: public Expression
{
private:
double number_;
static
auto specific_value_func( Expression const* expr )
-> double
{ return static_cast<Number const*>( expr )->number_; }
public:
Number( double const number )
: Expression()
, number_( number )
{ value_func_ = &Number::specific_value_func; }
};
class Sum
: public Expression
{
private:
Expression const* a_;
Expression const* b_;
static
auto specific_value_func( Expression const* expr )
-> double
{
auto const p_self = static_cast<Sum const*>( expr );
return p_self->a_->value() + p_self->b_->value();
}
public:
Sum( Expression const* const a, Expression const* const b )
: Expression()
, a_( a )
, b_( b )
{ value_func_ = &Sum::specific_value_func; }
};
auto main() -> int
{
Number const a( 3.14 );
Number const b( 2.72 );
Number const c( 1.0 );
Sum const sum_ab( &a, &b );
Sum const sum( &sum_ab, &c );
cout << sum.value() << endl;
}
看待这一点的一种积极方式是，如果您遇到了如上所述的不安全的下变频、复杂性和冗长，那么通常一个或多个虚拟方法确实会有帮助。
其他回答
下面是前两个答案的C++代码的合并版本。
#include <iostream>
#include <string>
using namespace std;
class Animal
{
public:
#ifdef VIRTUAL
virtual string says() { return "??"; }
#else
string says() { return "??"; }
#endif
};
class Dog: public Animal
{
public:
string says() { return "woof"; }
};
string func(Animal *a)
{
return a->says();
}
int main()
{
Animal *a = new Animal();
Dog *d = new Dog();
Animal *ad = d;
cout << "Animal a says\t\t" << a->says() << endl;
cout << "Dog d says\t\t" << d->says() << endl;
cout << "Animal dog ad says\t" << ad->says() << endl;
cout << "func(a) :\t\t" << func(a) << endl;
cout << "func(d) :\t\t" << func(d) << endl;
cout << "func(ad):\t\t" << func(ad)<< endl;
}
两种不同的结果是：
如果没有#define virtual，它将在编译时绑定。Animal*ad和func（Animal*）都指向Animal的says（）方法。
$ g++ virtual.cpp -o virtual
$ ./virtual
Animal a says ??
Dog d says woof
Animal dog ad says ??
func(a) : ??
func(d) : ??
func(ad): ??
使用#define virtual，它在运行时绑定。Dog*d、Animal*ad和func（Animal*）指向/引用Dog的says（）方法，因为Dog是它们的对象类型。除非未定义[Dog's says（）“woof”]方法，否则它将是在类树中首先搜索的方法，即派生类可能会覆盖其基类的方法[Eanimal's says）]。
$ g++ virtual.cpp -D VIRTUAL -o virtual
$ ./virtual
Animal a says ??
Dog d says woof
Animal dog ad says woof
func(a) : ??
func(d) : woof
func(ad): woof
有趣的是，Python中的所有类属性（数据和方法）都是虚拟的。由于所有对象都是在运行时动态创建的，因此不需要类型声明或关键字virtual。下面是Python的代码版本：
class Animal:
def says(self):
return "??"
class Dog(Animal):
def says(self):
return "woof"
def func(a):
return a.says()
if __name__ == "__main__":
a = Animal()
d = Dog()
ad = d # dynamic typing by assignment
print("Animal a says\t\t{}".format(a.says()))
print("Dog d says\t\t{}".format(d.says()))
print("Animal dog ad says\t{}".format(ad.says()))
print("func(a) :\t\t{}".format(func(a)))
print("func(d) :\t\t{}".format(func(d)))
print("func(ad):\t\t{}".format(func(ad)))
输出为：
Animal a says ??
Dog d says woof
Animal dog ad says woof
func(a) : ??
func(d) : woof
func(ad): woof
这与C++的虚拟定义相同。注意，d和ad是两个不同的指针变量，引用/指向同一个Dog实例。表达式（ad is d）返回True，其值与0xb79f72cc>处的<main.Dog对象相同。
下面是一个完整的示例，说明了为什么使用虚拟方法。
#include <iostream>
using namespace std;
class Basic
{
public:
virtual void Test1()
{
cout << "Test1 from Basic." << endl;
}
virtual ~Basic(){};
};
class VariantA : public Basic
{
public:
void Test1()
{
cout << "Test1 from VariantA." << endl;
}
};
class VariantB : public Basic
{
public:
void Test1()
{
cout << "Test1 from VariantB." << endl;
}
};
int main()
{
Basic *object;
VariantA *vobjectA = new VariantA();
VariantB *vobjectB = new VariantB();
object=(Basic *) vobjectA;
object->Test1();
object=(Basic *) vobjectB;
object->Test1();
delete vobjectA;
delete vobjectB;
return 0;
}
对虚拟函数的解释存在的问题是，它们没有解释如何在实践中使用它，以及它如何有助于维护。我创建了一个虚拟函数教程，人们已经发现它非常有用。此外，它基于战场前提，这让它更令人兴奋：https://nrecursions.blogspot.com/2015/06/so-why-do-we-need-virtual-functions.html.
考虑这个战场应用：
#include "iostream"
//This class is created by Gun1's company
class Gun1 {public: void fire() {std::cout<<"gun1 firing now\n";}};
//This class is created by Gun2's company
class Gun2 {public: void shoot() {std::cout<<"gun2 shooting now\n";}};
//We create an abstract class to interface with WeaponController
class WeaponsInterface {
public:
virtual void shootTarget() = 0;
};
//A wrapper class to encapsulate Gun1's shooting function
class WeaponGun1 : public WeaponsInterface {
private:
Gun1* g;
public:
WeaponGun1(): g(new Gun1()) {}
~WeaponGun1() { delete g;}
virtual void shootTarget() { g->fire(); }
};
//A wrapper class to encapsulate Gun2's shooting function
class WeaponGun2 : public WeaponsInterface {
private:
Gun2* g;
public:
WeaponGun2(): g(new Gun2()) {}
~WeaponGun2() { delete g;}
virtual void shootTarget() { g->shoot(); }
};
class WeaponController {
private:
WeaponsInterface* w;
WeaponGun1* g1;
WeaponGun2* g2;
public:
WeaponController() {g1 = new WeaponGun1(); g2 = new WeaponGun2(); w = g1;}
~WeaponController() {delete g1; delete g2;}
void shootTarget() { w->shootTarget();}
void changeGunTo(int gunNumber) {//Virtual functions makes it easy to change guns dynamically
switch(gunNumber) {
case 1: w = g1; break;
case 2: w = g2; break;
}
}
};
class BattlefieldSoftware {
private:
WeaponController* wc;
public:
BattlefieldSoftware() : wc(new WeaponController()) {}
~BattlefieldSoftware() { delete wc; }
void shootTarget() { wc->shootTarget(); }
void changeGunTo(int gunNumber) {wc->changeGunTo(gunNumber); }
};
int main() {
BattlefieldSoftware* bf = new BattlefieldSoftware();
bf->shootTarget();
for(int i = 2; i > 0; i--) {
bf->changeGunTo(i);
bf->shootTarget();
}
delete bf;
}
我鼓励您首先阅读博客上的文章，了解包装器类创建的原因。
如图所示，有各种火炮/导弹可以连接到战场软件，并且可以向这些武器发出命令，以进行射击或重新校准等。这里的挑战是能够在不必更改蓝色战场软件的情况下更改/更换火炮/导弹，并且能够在运行时切换武器，而无需更改代码并重新编译。
上面的代码显示了问题是如何解决的，以及具有精心设计的包装类的虚拟函数如何封装函数并帮助在运行时分配派生类指针。WeaponGun1类的创建确保了你将Gun1的处理完全分离到类中。无论你对Gun1做了什么改变，你只需要在WeaponGun1中做出改变，并有信心其他职业不会受到影响。
由于WeaponsInterface类，您现在可以将任何派生类分配给基类指针WeaponsIterface，并且因为它的函数是虚拟的，所以当您调用WeaponsIInterface的shootTarget时，派生类shootTarget将被调用。
最好的部分是，您可以在运行时更改枪（w=g1和w=g2）。这是虚拟函数的主要优势，这也是我们需要虚拟函数的原因。
因此，在更换枪支时，不再需要在不同的地方注释代码。现在，这是一个简单而干净的过程，添加更多的枪类也更容易，因为我们只需要创建一个新的WeaponGun3或WeaponGun 4类，我们可以确信它不会破坏BattlefieldSoftware的代码或WeaponGun1/WeaponGun2的代码。
你熟悉函数指针吗？虚拟函数也是一个类似的想法，只是您可以轻松地将数据绑定到虚拟函数（作为类成员）。将数据绑定到函数指针并不容易。对我来说，这是主要的概念区别。这里的许多其他答案只是说“因为…多态性！”
您需要至少1个级别的继承和一个升级来演示它。下面是一个非常简单的示例：
class Animal
{
public:
// turn the following virtual modifier on/off to see what happens
//virtual
std::string Says() { return "?"; }
};
class Dog: public Animal
{
public: std::string Says() { return "Woof"; }
};
void test()
{
Dog* d = new Dog();
Animal* a = d; // refer to Dog instance with Animal pointer
std::cout << d->Says(); // always Woof
std::cout << a->Says(); // Woof or ?, depends on virtual
}
